数组：双指针思想及其应用

删除数组元素

leetcode27删除指定元素

        快慢双指针：

        代码：

/**
     * 方法1：使用快慢型双指针
     *
     * @param nums
     * @param val
     * @return
     */
    public static int removeElement(int[] nums, int val) {
        int slow=0,fast=0;
        for (fast=0;fast<nums.length;fast++){
            if (nums[fast]!=val){
                nums[slow]=nums[fast];
                slow++;
            }
        }
        return slow;
    }

对撞双指针：

 

代码

/**
     * 方法2：使用对撞型双指针
     *
     * @param nums
     * @param val
     * @return
     */


    public static int removeElement2(int[] nums, int val) {
        int right = nums.length - 1;
        int left = 0;

        for (left = 0; left <= right; ) {
            if ((nums[left] == val) && (nums[right] != val)) {
                int tmp = nums[left];
                nums[left] = nums[right];
                nums[right] = tmp;

            }

            if (nums[left] != val) {
                left++;
            }
            if (nums[right] == val){
                right--;
            }

        }
        return left ;
    }

 优化对撞

/**
     * 方法三：优化对撞型双指针
     * @param nums
     * @param val
     * @return
     */
    public static int removeElement3(int[] nums, int val) {
        int right = nums.length-1;
        for (int left = 0; left < right; ) {
            if (nums[left] == val) {
                nums[left] = nums[right ];
                right--;
            } else {
                left++;
            }
        }
        return right;
    }

leetcode26删除重复项

public static int removeDuplicates(int[] nums) {
        int slow=1;
        for (int fast=1;fast<nums.length;fast++){
            if (nums[slow-1]!=nums[fast]){
                nums[slow]=nums[fast];
                slow++;
            }
        }
        return slow;
    }

leetcode80保留2个重复项

 

public static int removeDuplicates2(int[] nums) {
        int slow=0,val=-1,count=-1;
        for (int fast=0;fast<nums.length;fast++,slow++){
            if (nums[fast]!=val){
                val=nums[fast];
                count=1;
            }else if (nums[fast]==val){
                count++;
                if (count==3){
                    while (fast<nums.length&&nums[fast]==val){
                        fast++;

                    }
                    if (fast>=nums.length){
                        return slow;
                    }else {
                        nums[slow]=nums[fast];
                        val=nums[fast];
                        count=1;
                    }
                }
            }
            nums[slow]=nums[fast];
        }
        return slow;
    }

leetcode905按奇偶排序

public int[] sortArrayByParity(int[] nums) {
        if (nums == null || nums.length == 0)
            return new int[0];
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                // 左边是偶数, 右边是奇数的情况
                if ((nums[j] & 1) == 0 && (nums[j + 1] & 1) == 1) {
                    int tmp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = tmp;
                }
            }
        }
        return nums;
    }

leetcode189数组轮转 

 

 

 双反转

public void rotate(int[] nums, int k) {
         k %= nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }
    public static void reverse(int[] nums, int start, int end) {
        while (start<end){
            int temp=nums[end];
            nums[end]=nums[start];
            nums[start]=temp;
            start++;
            end--;
        }
    }

leetcode228数组区间 

 public List<String> summaryRanges(int[] nums) {
        List<String> res = new ArrayList<>();
        // slow 初始指向第 1 个区间的起始位置
        int slow = 0;
        for (int fast = 0; fast < nums.length; fast++) {
            // fast 向后遍历，直到不满足连续递增(即 nums[fast] + 1 != nums[fast + 1])
            // 或者 fast 达到数组边界，则当前连续递增区间 [slow, fast] 遍历完毕，将其写入结果列表。
            if (fast + 1 == nums.length || nums[fast] + 1 != nums[fast + 1]) {
                // 将当前区间 [slow, fast] 写入结果列表
                StringBuilder sb = new StringBuilder();
                sb.append(nums[slow]);
                if (slow != fast) {
                    sb.append("->").append(nums[fast]);
                }
                res.add(sb.toString());
                // 将 slow 指向更新为 fast + 1，作为下一个区间的起始位置
                slow = fast + 1;
            }
        }
        return res;
    }

剑指offer05替换字符串空格

public static String replaceSpace2(StringBuffer s) {
        if (s == null)
            return null;
        int numOfblank = 0;//空格数量
        int len = s.length();
        for (int i = 0; i < len; i++) {  //计算空格数量
            if (s.charAt(i) == ' ')
                numOfblank++;
        }
        s.setLength(len + 2 * numOfblank); //设置长度
        int fast = len - 1;  //两个指针
        int slow = (len + 2 * numOfblank) - 1;
        while (fast >= 0 && slow > fast) {
            char c = s.charAt(fast);
            if (c == ' ') {
                fast--;
                s.setCharAt(slow--, '0');
                s.setCharAt(slow--, '2');
                s.setCharAt(slow--, '%');
            } else {
                s.setCharAt(slow, c);
                fast--;
                slow--;
            }
        }
        return s.toString();
    }