代码随想录leetcode刷题Day05-数组复习+链表

//54. 螺旋矩阵
/*
给你一个 m 行 n 列的矩阵 matrix ，
请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
 */


在使用二维数组对象时，注意length所代表的长度，
数组名后直接加上length(如arr.length)，所指的是有几行(Row)；
指定索引后加上length(如arr[0].length)，指的是该行所拥有的元素，也就是列(Column)数目。

//定上下左右边界的方法
class Solution2 {
    public List<Integer> spiralOrder(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        List list = new ArrayList<Integer>(m * n);

        int t = 0, l = 0;
        int b = m - 1;
        int r = n - 1;
        int index = 0;

        while (index < m * n) {
            for (int i = l; i <= r && index < m * n; i++) {
                list.add(matrix[t][i]);
                index++;
            }
            t++;

            for (int i = t;i <= b && index < m * n;i++){
                list.add(matrix[i][r]);
                index++;
            }
            r--;

            for (int i = r;i >= l && index < m * n;i--){
                list.add(matrix[b][i]);
                index++;
            }
            b--;

            for (int i = b;i >= t && index < m * n;i--){
                list.add(matrix[i][l]);
                index++;
            }
            l++;
        }
        return list;
    }
}

//根据奇偶判断循环次数方法
class Solution3 {
    public List<Integer> spiralOrder(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int startx = 0;
        int starty = 0;
        int endx = n;
        int endy = m;
        int i, j;
        int loop = ((m < n) ? m : n) / 2;

        List list = new ArrayList<Integer>(m * n);
        while (loop != 0) {

            for (j = startx; j < endx - 1; j++) {
                list.add(matrix[startx][j]);
            }
            for (i = starty; i < endy - 1; i++) {
                list.add(matrix[i][j]);
            }
            for (; j > startx; j--) {
                list.add(matrix[i][j]);
            }
            for (; i > starty; i--) {
                list.add(matrix[i][j]);
            }
            startx++;
            starty++;
            endx--;
            endy--;
            loop--;
        }

        if (m > n && n % 2 != 0){
            for (i = starty;i < endy;i++){
                list.add(matrix[i][starty]);
            }
        }
        if (m < n && m % 2 != 0){
            for (j = startx;j < endx;j++){
                list.add(matrix[startx][j]);
            }
        }
        if (m == n && m % 2 != 0){
            list.add(matrix[startx][starty]);
        }
        return list;
    }
}

//数组复习
public class q1 {
    public static void main(String[] args) {

    }
}

/*
704. 二分查找
给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ，
写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。
 */
class Solution {
    public int search(int[] nums, int target) {
        int len = nums.length;
        if (nums[0] > target || nums[len - 1] < target) {
            return -1;
        }
        int head = 0;
        int end = len - 1;
        int middle;
        while (head <= end) {
            middle = head + (end - head) / 2;
            if (nums[middle] == target) {
                return middle;
            } else if (nums[middle] > target) {
                end = middle - 1;
            } else {
                head = middle + 1;
            }
        }
        return -1;
    }
}

/*
27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
 */

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

class Solution2 {
    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        for (int i = 0; i < len; i++) {
            if (nums[i] == val) {
                for (int j = i; j < len - 1; j++) {
                    nums[j] = nums[j + 1];
                }
                i--;
                len--;
            }
        }
        return len;
    }
}

/*
209. 长度最小的子数组
给定一个含有n个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组[numsl, numsl+1, ..., numsr-1, numsr] ，
并返回其长度。如果不存在符合条件的子数组，返回 0 。
 */
class Solution3 {
    public int minSubArrayLen(int target, int[] nums) {
        int i = 0, j = 0, sum = 0;
        int subLen;
        int res = nums.length + 1;
        for (; i < nums.length; i++) {
            sum += nums[i];
            while (sum >= target) {
                subLen = i - j + 1;
                res = Math.min(res, subLen);
                sum -= nums[j];
                j++;
            }
        }
        if (res != nums.length + 1) {
            return res;
        } else {
            return 0;
        }
    }
}

/*
59.螺旋矩阵II
给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
 */
class Solution4 {
    public int[][] generateMatrix(int n) {
        int[][] arr = new int[n][n];
        int t = 0, l = 0, count = 0, i = 0, j = 0;
        int b = n - 1, r = n - 1;
        while (count < n * n) {
            for (j = l; j <= r; j++) {
                arr[t][j] = ++count;
            }
            t++;

            for (i = t; i <= b; i++) {
                arr[i][r] = ++count;
            }
            r--;

            for (j = r; j >= l; j--) {
                arr[b][j] = ++count;
            }
            b--;

            for (i = b; i >= t; i--) {
                arr[i][l] = ++count;
            }
            l++;
        }
        return arr;
    }
}

//203. 移除链表元素
//给你一个链表的头节点 head 和一个整数 val ，
// 请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。


//这个题目头节点可能存储数据，需要细心
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //头节点如果数据匹配到，就更换头节点，注意是循环
        while (head != null && head.val == val) {
            head = head.next;
        }
        ListNode temp = head;
        //注意这里，可能传进来一个null
        while (temp != null && temp.next != null) {
            if (temp.next.val == val) {
                temp.next = temp.next.next;//匹配到，就删除
            } else {//没有匹配到，就使得temp向下遍历
                temp = temp.next;
            }
        }
        return head;
    }
}

//可以使用定义虚拟头节点的方式处理
class Solution1 {
    public ListNode removeElements(ListNode head, int val) {
        //我们定义一个虚拟头节点，指向head，这样head就不需要单独操作
        ListNode virNode = new ListNode(-1,head);
        ListNode temp = virNode;
        //temp不会是null，因为temp指向虚拟节点
        while (temp.next != null){
            if (temp.next.val == val){
                temp.next = temp.next.next;
            }else{
                temp = temp.next;
            }
        }
        return virNode.next;
    }
}

class LinkedNodeList{
    private ListNode head;

    public ListNode getHead() {
        return head;
    }

    public void setHead(ListNode head) {
        this.head = head;
    }

    public LinkedNodeList(ListNode head) {
        this.head = head;
    }

    public LinkedNodeList() {
    }

    public void list(){

    }
}
class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }

    @Override
    public String toString() {
        return "ListNode{" +
                "val=" + val +
                '}';
    }
}

//707. 设计链表
/*
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：
val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果要使用双向链表，
则还需要一个属性prev以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第index个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为val的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第index个节点之前添加值为val的节点。如果index等于链表的长度，
则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引index 有效，则删除链表中的第index 个节点。
 */


class MyLinkedList {
    int size;
    LinkNode head;

    public MyLinkedList() {
        head = new LinkNode();
        this.size = 0;
    }

    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        LinkNode temp = head;
        for (int i = 0; i <= index; i++) {
            temp = temp.next;
        }
        return temp.val;
    }

    public void addAtHead(int val) {
        size++;
        LinkNode node1 = new LinkNode(val);
        node1.next = head.next;
        head.next = node1;
    }

    public void addAtTail(int val) {
        LinkNode node1 = new LinkNode(val);
        LinkNode temp = head;

        for (int i = 0; i < size; i++) {
            temp = temp.next;
        }
        node1.next = null;
        temp.next = node1;
        size++;

    }

    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        size++;
        if (index < 0) {
            index = 0;
        }

        LinkNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        LinkNode node1 = new LinkNode(val);
        node1.next = temp.next;
        temp.next = node1;

    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        LinkNode temp = head;

        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

class LinkNode {
    public int val;
    public LinkNode next;

    public LinkNode() {
    }

    public LinkNode(int val) {
        this.val = val;
    }
}