链表

反转链表

leetcode - 图1

  1. 输入：head = [1,2,3,4,5]
  2. 输出：[5,4,3,2,1]

方法一：迭代
在遍历链表时，将当前节点的 next 指针改为指向前一个节点，由于节点没有应用其前一个节点，因此必须事先存储其前一个节点，在更改引用之前，还需要存储后一个节点，最后返回新的头引用。

  1. var reverseList = function(head){
  2.         let prev = null;
  3.       let curr = head;
  4.       while(curr){
  5.         const next = curr.next
  6.         curr.next = prev 
  7.           prev = curr 
  8.           curr = next 
  9.      }
  10.   return prev
  11. }

复杂度分析

  • 时间复杂度：O(n)O(n)，其中 nn 是链表的长度。需要遍历链表一次。
  • 空间复杂度：O(1)O(1)。

两数之和

  1. <script>
  2.         /*  
  3.             第一次写法：
  4.             存在问题 循环并不是根据 ，拿第一个值后，在依次匹配
  5.             所以找匹配值的方式需要变成 目标值 - 当前值
  7.             思路，先拿一个固定的值，在用后面的值跟它进行匹配
  8.         */
  9.         var twoSum = function (nums, target) {
  10.             let obj = []
  11.             for (let i = 0; i < nums.length; i++) {
  12.                 for (let j = i + 1; j < nums.length; j++) {
  13.                     //注意 这边不可以用相加来判断
  14.                     if (nums[j] == target - nums[i]) {
  15.                         obj.push(i, j)
  16.                         return obj
  17.                     }
  18.                 }
  19.             }
  20.         };
  22.         // var twoSum = function (nums, target) {
  23.         //     let i = nums.length
  24.         //     while (i > 1) {
  25.         //         //pop 是会删除数组的
  26.         //         let last = nums.pop()
  27.         //         //在数组中没有找到与之可以相加等于目标值的情况
  28.         //         if (nums.indexOf(target - last) > -1) {
  29.         //             return [nums.indexOf(target - last), nums.length]
  30.         //         }
  31.         //         i--
  32.         //     }
  33.         // }
  35.         var nums = [1, 1, 1, 1, 1, 4]
  36.         var target = 5
  37.         console.log(twoSum(nums, target))
  38.     </script>