7/30 链表和数组的双指针----快慢指针和左右指针

链表双指针

解决链表的合并分解，寻找倒数节点和中点，判断环，找到环的起点和链表交点
合并两个有序链表:

var mergeTwoLists = function(list1, list2) {
    let temp =new ListNode() 
    let result = temp
    while(list1 !==null &&list2!==null) {
        if(list1.val>list2.val) {
            temp.next = list2
            list2 = list2.next
        }
        else {
            temp.next = list1
            list1 = list1.next
        }
        temp = temp.next
    }
    if(list1!==null ) {
        temp.next =list1
    }
    else temp.next = list2
    return result.next
};

分隔链表:注意取消原来链表的关系，因为用新链表指向原链表的某节点，该节点的指向需要设置为空，然后后续更新才不会出错，不然，可能会出现环

var partition = function(head, x) {
    let below = new ListNode() ,above = new ListNode()
    let belowFlag = below
    let aboveFlag = above
    while(head !== null) {
        if(head.val >=x) {
            above.next = head
            above = above.next
        }
        else {
        below.next = head
        below = below.next
        }
        let temp = head.next
        head.next = null
        head = temp
    }
    below.next = aboveFlag.next
    return belowFlag.next

};

合并 K 个升序链表：(合并可以常规判断最小值，填入新链表，移动指针；或者直接全部放在一起排序 )：注意break和continue，并且记住凡是分解链表，一定要记得取消原链表关系，合并无所谓（因为新链表关系不会和原链表有交集）

var mergeKLists = function(lists) {
    if(lists.length==0) {
        return null
    }
    else if(lists.length === 1) {
        return lists[0]
    }
    else {
        let temp = new ListNode()
        let tempFlag = temp
       while(lists.length>0) {
           let flag = 0
           let min = 10001
           let index = 0;
            for(let idx =0;idx<lists.length;idx ++) {
                if(lists[idx]) {
                    if(lists[idx].val<min) {
                        min = lists[idx].val
                        index = idx
                    }
                }
                else {
                    lists.splice(idx,1);
                    flag ++
                    break;
                }
            }
            if(min === 10001 || flag!==0) {
                continue
            }
            temp.next = lists[index]
            temp = temp.next
            lists[index] =lists[index].next
       }
       return tempFlag.next
    }

};

删除链表的倒数第 N 个结点（注意临界值）

var removeNthFromEnd = function(head, n) {
    let start1 = head
    let start = head
for(let i=0;i<n;i++) {
    start = start.next
}
if(start==null) {
    return head.next
}
    while(start.next) {
        start1 = start1.next
        start = start.next
    }
    start1.next = start1.next.next
    return head

};

判断链表是否包含环快慢指针
环形链表 II:快慢指针判断环，快慢指针找起点

var detectCycle = function(head) {
        let slow = head
        let fast = head
        while(fast !== null && fast.next!==null) {
            slow = slow.next
            fast = fast.next.next
            if(slow === fast) {
                slow = head
                while(slow !==fast) {
                    slow = slow.next
                    fast = fast.next
                }
                return slow
            }
        }
        return null

};

相交链表:本质就是让两个头指针同时到达一个节点，可以先得到两个链表的长度，然后让长链表先走len1-len2，或者两个链表的指针走到尽头就换到另外一个链表，这样也能做到类似的效果

var getIntersectionNode = function(headA, headB) {
    let a = headA
    let b = headB
    while(a !== b) {
        if(a === null) {a = headB}
        else a = a.next
        if(b === null) {b = headA}
        else b = b.next
    }
    return a
};

数组双指针

快慢指针：解决数组的原地删除，以及滑动窗口

删除有序数组中的重复项

var removeDuplicates = function(nums) {
     if (nums.length == 0) {
 return 0;
 }
    let slow = 0,fast = 0
    while(fast <nums.length) {
        if (nums[fast] != nums[slow]) {
 slow++;
 // 维护 nums[0..slow] ⽆重复
 nums[slow] = nums[fast];
 }
 fast++;
    }
    
    return slow+1
};

删除排序链表中的重复元素

var deleteDuplicates = function(head) {
    let slow = head
    let fast = head 
    if(fast == null) {
        return null
    }
    if(fast.next===null) {
        return fast
    }
    while(fast!==null) {
        if(fast.val !== slow.val) {
           slow.next = fast
           slow = slow.next
        }
        fast = fast.next
    }
    slow.next = null
    return head
};

移除元素

var removeElement = function(nums, val) {
    let slow = 0,fast =0
    if(nums.length===0) {
        return 0
    }
    while(fast<nums.length) {
        if(nums[fast]!==val ){
            nums[slow++] = nums[fast]
        }
        fast =fast+1
    }
    return slow
};



或者
var removeElement = function(nums, val) {
 for(let i = 0;i<nums.length;i++) {
     if(nums[i]===val) {
         nums.splice(i,1)
         i=i-1
     }
 }
 return nums.length
};

左右指针：—二分查找，nsum，数组reverse，回文串判断

二分查找 :事先需要排序

int binarySearch(nums, target) {
 // ⼀左⼀右两个指针相向⽽⾏
 let left = 0, right = nums.length - 1;
 while(left <= right) {
 let mid = (right + left) / 2;
 if(nums[mid] == target)
 return mid; 
 else if (nums[mid] < target)
 left = mid + 1; 
 else if (nums[mid] > target)
 right = mid - 1;
 }
 return -1;
}

两数之和以及nSum问题
两数之和 II - 输入有序数组:核心，左右指针，小就向右，大就向左，去重就循环一样的，找到一个就存起来，大于2的比如3就再加一层循环

var twoSum = function(numbers, target) {
    let left =0;
    let right = numbers.length-1
    while(left<right) {
        if(numbers[left]+numbers[right]===target) {
            return [left+1,right+1]
        }
        else if(numbers[left]+numbers[right]>target) {
            right--
        }
        else left++
    }
};

解决2数之和–进阶

//我们可以在sum等于target的时候将左右指针同时移动1。当然，前提是可以有相同的组合，如果不允许，那么就向左向右移动到底
var twoSum = function(numbers, target) {
    let left =0;
    let right = numbers.length-1
    let result = []
    while(left<right) {
        if(numbers[left]+numbers[right]===target) {
       		left++;right--;
       		//lo  = numbers[left]
       		//hi = numbers[right]
       		//  while (left < right && nums[left] == lo) left++;
            //while (left < right && nums[right] == hi) right--;
            result.push([left,right])
        }
        else if(numbers[left]+numbers[right]>target) {
            right--
        }
        else left++
    }
};

三数之和:穷举第一个数（不能重复），然后另外两个数要从第一个数右边去找（不然不就重复了嘛）

var threeSum = function(numbers, target) {
=
    let result = []
	for(let i=0;i<numbers.length;) {
		let val = numbers[i]
		while(numbers[i] === val && i<numbers.length-1) {
			i++
		}
		for(item in towSum(numbers,i,target-val)) {
		 	item.unshift(val)
		 	result.push(item)
		}
	}
	return result
};

多数之和:直接递归！！！

  vector<vector<int>> nSumTarget(
            vector<int>& nums, int n, int start, int target) {
 
        int sz = nums.size();
        vector<vector<int>> res;
        // 至少是 2Sum，且数组大小不应该小于 n
        if (n < 2 || sz < n) return res;
        // 2Sum 是 base case
        if (n == 2) {
            // 双指针那一套操作
            int lo = start, hi = sz - 1;
            while (lo < hi) {
                int sum = nums[lo] + nums[hi];
                int left = nums[lo], right = nums[hi];
                if (sum < target) {
                    while (lo < hi && nums[lo] == left) lo++;
                } else if (sum > target) {
                    while (lo < hi && nums[hi] == right) hi--;
                } else {
                    res.push_back({left, right});
                    while (lo < hi && nums[lo] == left) lo++;
                    while (lo < hi && nums[hi] == right) hi--;
                }
            }
        } else {
            // n > 2 时，递归计算 (n-1)Sum 的结果
            for (int i = start; i < sz; i++) {
                vector<vector<int>>
                        sub = nSumTarget(nums, n - 1, i + 1, target - nums[i]);
                for (vector<int>& arr : sub) {
                    // (n-1)Sum 加上 nums[i] 就是 nSum
                    arr.push_back(nums[i]);
                    res.push_back(arr);
                }
                while (i < sz - 1 && nums[i] == nums[i + 1]) i++;
            }
        }
        return res;
    }

反转字符串

var reverseString = function(s) {
    return s.reverse()
};

//或者双指针
var reverseString = function(s) {
    let left =0,right = s.length-1
    while(left<right) {
        let temp = s[left]
        s[left] = s[right]
        s[right] = temp
        left++
        right--
    }
    return s
};

最长回文子串
:从中间开始的双指针

var longestPalindrome = function(s) {
  let result = ""
  const find = (s,i,j)=>{
    if(s[i]!==s[j])
    return ""
      while(i>=0 && j <s.length && s[i]===s[j]){
        i--;
        j++;
      }
      // console.log(s.slice(i+1,j))
      return s.slice(i+1,j)
  }
    let length = s.length
    for(let i = 0;i <length;i++) {
      let s1 = find(s,i,i)
      let s2 = find(s,i,i+1)
      if(s1.length>s2.length) {
        result = result.length>s1.length?result:s1
        // console.log("result",result)
      }
      else {
        result = result.length>s2.length?result:s2
        // console.log("result",result)
      }
    }
    return result
};