DAY1-双指针

         双指针部分主要是需要理清覆盖逻辑，重点可以关注LeetCode844。

 LeetCode704. 二分查找

	/**
	 * 二分查找
	 * @param nums
	 * @param target
	 * @return
	 */
    public int search(int[] nums, int target) {
    	//定义指针
    	int p=0,q=nums.length-1;
    	int mid;
    	
    	//循环遍历二分查找，注意if里的条件不要写反
    	while(p<=q) {
    		mid= (p+q)/2;
    		if(nums[mid]==target) {
    			return mid;
    		}else if(nums[mid]<target) {
    			p=mid+1;
    		}else {
    			q=mid-1;
    		}
    	}
    	
    	//该数值不存在
    	return -1;
    }

LeetCode34. 在排序数组中查找元素的第一个和最后一个位置

	/**
	 * 二分查找+扩散
	 * @param nums
	 * @param target
	 * @return
	 */
	public int[] searchRange(int[] nums, int target) {

		// 数组为空时返回
		if (nums.length == 0) {
			return new int[] { -1, -1 };
		}
		int p = 0, q = nums.length - 1, mid = 0;

		while (p <= q) {
			mid = (q + p) / 2;
			//二分查找找到目标值
			if (nums[mid] == target) {
				int start = mid, end = mid;
				//扩散部分，注意边界问题
				while (start >= 0 && nums[start] == target) {
					start--;
				}
				//剪多了需要恢复回来
				if (start < 0 || nums[start] != target) {
					start++;
				}
				while (end <= nums.length - 1 && nums[end] == target) {
					end++;
				}
				if (end > nums.length - 1 || nums[end] != target) {
					end--;
				}
				return new int[] { start, end };
			} else if (nums[mid] < target) {
				p = mid + 1;
			} else {
				q = mid - 1;
			}
		}

		return new int[] { -1, -1 };
	}

LeetCode27. 移除元素

	/**
	 * 移除元素
	 * @param nums
	 * @param val
	 * @return
	 */
    public int removeElement(int[] nums, int val) {
    	int p=0;
    	
    	for(int i=0;i<nums.length;i++) {
    		//如果不等于该元素，则覆盖
    		if(nums[i]!=val) {
    			nums[p]=nums[i];
    			p++;
    		}
    	}
    	
    	return p;
    }

LeetCode26.删除排序数组中的重复项

    public int removeDuplicates(int[] nums) {
    	int p=0,flagx=0;
    	
    	//处理第一个值
    	if(nums.length>=1) {
    		flagx=nums[0];
    		p++;
    	}
    	
    	for(int i=1;i<nums.length;i++) {
    		//若该值与前面的值不同，则覆盖
    		if(flagx!=nums[i]) {
    			nums[p]=nums[i];
    			p++;
    			flagx=nums[i];
    		}
    		
    	}
    	
    	return p;
    }

LeetCode844.比较含退格的字符串

	/**
	 * 分别遍历两个字符串
	 * @param s
	 * @param t
	 * @return
	 */
    public static boolean backspaceCompare(String s, String t) {
    	
    	//处理空字符串
    	if(s.equals("")||t.equals("")) {
    		if(s.equals(t)) {
    			return true;
    		}
    		return false;
    	}
    	
    	//倒序比较
    	int sp=s.length()-1,tp=t.length()-1,fs=0,ft=0;
    	
    	//循环条件->从and改成or防止情况"bbbextm","bbb#extm"
    	while(sp>=0||tp>=0) {
    		
    		//处理s字符串
    		while(sp>=0) {
    			//将fs从局部变量改成全局变量-》成功的关键？
    			if(s.charAt(sp)=='#') {
    				sp--;
    				fs++;
    			}else if(fs>0) {
    				sp--;
    				fs--;
    			}else {
    				break;
    			}
    		}
    		
    		//处理t字符串
    		while(tp>=0) {
    			if(t.charAt(tp)=='#') {
    				tp--;
    				ft++;
    			}else if(ft>0) {
    				tp--;
    				ft--;
    			}else {
    				break;
    			}
    		}
    		
    		System.out.println("s:"+s.charAt(sp)+"   "+"t:"+t.charAt(tp));
    		
    		//处理有一方为0的状况
    		if(sp>=0&&tp>=0) {
        		if(s.charAt(sp)!=t.charAt(tp)) {
        			return false;
        		}
    		}else {
    			if(sp>=0||tp>=0) {
    				return false;
    			}
    		}

    		sp--;
    		tp--;
    	}
    	
    	return true;
    }

LeetCode977.有序数组的平方

	/**
	 * 倒序双指针
	 * @param nums
	 * @return
	 */
    public int[] sortedSquares(int[] nums) {
    	
    	int[] new_nums = new int[nums.length];
    	int p=0,q=nums.length-1,now=nums.length-1;
    	
    	
    	while(now>=0) {
    		if(nums[p]*nums[p]>=nums[q]*nums[q]) {
    			new_nums[now]=nums[p]*nums[p];
    			p++;
    			now--;
    		}else {
    			new_nums[now]=nums[q]*nums[q];
    			q--;
    			now--;
    		}
    	}
    	return new_nums;
    }