算法回顾1

class Solution {
    public int removeElement(int[] nums, int val) {
        int fast = 0;
        int slow = 0;
        for (fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

用双指针写这道题，快慢指针初始值都为0，如果快指针所对应的值！=val，就把快指针对应的值赋值给慢指针，慢指针++，相等的话，不做操作，但是当遇到下一个不等的值时，不等处的值会覆盖相等处的值，最后，只需要return slow就会得到k的值了。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i = 0;
        int sum = 0;
        int subl = Integer.MAX_VALUE;
        int result =Integer.MAX_VALUE;
        for (int j = 0; j < nums.length; j++) { //j为终止位置
            sum += nums[j];
            while (sum >= target) {
                subl = j - i + 1;
                result = Math.min(subl, result);
                sum = sum - nums[i];
                i++;
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

这道题用滑动窗口的思想来写，也可以说是移动的双指针。遍历，让j表示终止位置，i表示起始位置sum+=nums[j],用while循环判断，当sum>target的时候，记录当前子数组的长度subl，和result相比取小值，这时，在缩减长度，sum-=nums[i],i++,如果sum仍然大于目标值target，则更新result，否则，跳出while循环，最后，返回result。

class Solution {
    public int[][] generateMatrix(int n) {
        int start_x = 0;
        int start_y = 0;
        int loop = n / 2; // 循环次数
        int[][] nums = new int[n][n];
        int k = 1; // 计数器
        int offset = 1; // 每次循环后需要增加的偏移量

        while (loop > 0) {
            int i = start_y;
            int j = start_x;
            // 上边：从左到右遍历
            for (; j < start_x + n - offset; j++) {
                nums[start_x][j] = k++;
            }
            // 右边：从上到下遍历
            for (; i < start_y + n - offset; i++) {
                nums[i][j] = k++;
            }
            // 下边：从右到左遍历
            for (; j > start_y; j--) {
                nums[i][j] = k++;
            }
            // 左边：从下到上遍历
            for (; i > start_x; i--) {
                nums[i][j] = k++;
            }

            // 更新起始点和偏移量
            start_x++;
            start_y++;
            offset += 2;
            loop--;
        }

        // 如果n为奇数，填入中心元素
        if (n % 2 == 1) {
            nums[start_x][start_y] = k;
        }

        return nums;
    }
}

遵循循环不变量的原则来写这道题，这里的不变量指的时每条边的处理规则，用左闭右开。n*n正方形，则他要循环的此时为n/2次，offset代表的时偏移量。

class Solution {
      public ListNode reverseBetween(ListNode head, int left, int right) {
        if (head == null || head.next == null || left == right)
            return head;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;
//将pre移动到left的前一个位置
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }
        ListNode curr = pre.next;
        ListNode thenext = null;
        //反转left到right之间的节点
        for (int i = left; i < right; i++) {
            thenext = curr.next;
            curr.next = thenext.next;
            thenext.next = pre.next;
            pre.next = thenext;
        }
        return dummy.next;
    }
}