刷代码随想录笔记（持续中..)

for-sq-in-happy

已于 2023-07-24 17:50:52 修改

阅读量402

点赞数

CC 4.0 BY-SA版权

文章标签：笔记算法 leetcode 链表

于 2023-07-24 17:41:02 首次发布

本文链接：https://blog.csdn.net/weixin_44614756/article/details/131901480

数组

704 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例一：

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例二：
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示
1.你可以假设 nums 中的所有元素是不重复的。
2.n 将在 [1, 10000]之间。
3.nums 的每个元素都将在 [-9999, 9999]之间。

题解

class Solution {
    public int search(int[] nums, int target) {
        int L=0;
        int R=nums.length - 1;
        while(L<=R){
            int M=L+((R-L)/2);  // 防止溢出 等同于(L+R)/2
            if(target>nums[M]){
                L=M+1;
            }else if(target<nums[M]){
                R=M-1;
            }else{
                return M;
            }
        }
        return -1;
    }
}

// 时间复杂度：O(log n)
// 空间复杂度：O(1)

27移除元素 (快慢指针）

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100
题解:

// fast 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
//slow 慢指针：指向更新 新数组下标的位置
class Solution {
    public int removeElement(int[] nums, int val) {
       int slow=0; 
       for(int fast=0;fast<nums.length;fast++){ 
           if(nums[fast]!=val) {
           nums[slow++]=nums[fast];
           }
       }
       return slow; 
    }
}

// 时间复杂度：O(n)
// 空间复杂度：O(1)

977. 有序数组的平方（双指针）

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

1 <= nums.length <= 104
104 <= nums[i] <= 104
nums 已按非递减顺序排序

题解：

class Solution {
   
   
    public int[] sortedSquares(int[] nums) {
   
   
        int L=0;
        int R=nums.length-1;
        int ans[]=new int [nums.length];//新数组用于返回；
        int p=nums.length-1; //因为在原数组中只能确定最大值在两边，所以新数组的最大值确定；
        while(L<=R){
   
   
           if((nums[L]*nums[L])<(nums[R]*nums[R])){
   
   
               ans[p]=nums[R]*nums[R];
               R--;
              
           }else{
   
   
               ans[p]=nums[L]*nums[L];
               L++;
           }
             p--;
           }
           return ans;
        }   
    }
 	时间复杂度：O(n)
	空间复杂度：O(1)

注意：
不要以为for里放一个while就以为是O(n^2)啊，主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)

209. 长度最小的子数组 (滑动窗口）

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

题解：

class Solution {
   
   

    // 滑动窗口
    public int minSubArrayLen(int s, int[] nums) {
   
   
        int left = 0;//用于窗口缩小
        int sum = 0;// 记录窗口大小
        int result = Integer.MAX_VALUE; //初使窗口最大
        for (int right = 0; right < nums.length; right++) {
   
   
            sum += nums[right];
            while (sum >= s) {
   
   
                result = Math.min(result, right - left + 1); //寻找最小区间
                sum -= nums[left++]; 
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
         // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
    }
}
时间复杂度：O(n)
空间复杂度：O(1)

59. 螺旋矩阵 II (模拟）

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例 1：
在这里插入图片描述

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1
输出：[[1]]

提示：

1 <= n <= 20

思路：

生成一个 n×n 空矩阵 mat，随后模拟整个向内环绕的填入过程：

定义当前左右上下边界 l,r,t,b，初始值 num = 1，迭代终止值 tar = n * n；
当 num <= tar 时，始终按照从左到右从上到下从右到左从下到上填入顺序循环，每次填入后：
执行 num += 1：得到下一个需要填入的数字；
更新边界：例如从左到右填完后，上边界 t += 1，相当于上边界向内缩 1。
使用num <= tar而不是l < r || t < b作为迭代条件，是为了解决当n为奇数时，矩阵中心数字无法在迭代过程中被填充的问题。
最终返回 mat 即可。

题解：

class Solution {
   
   
    public int[][] generateMatrix(int n) {
   
   
        int l = 0, r = n - 1, t = 0, b = n - 1;
        int[][] mat = new int[n][n];
        int num = 1, tar = n * n;
        while(num <= tar){
   
   
            for(int i = l; i <= r; i++) mat[t][i] = num++; // left to right.
            t++;
            for(int i = t; i <= b; i++) mat[i][r] = num++; // top to bottom.
            r--;
            for(int i = r; i >= l; i--) mat[b][i] = num++; // right to left.
            b--;
            for(int i = b; i >= t; i--) mat[i][l] = num++; // bottom to top.
            l++;
        }
        return mat;
    }
}

时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
空间复杂度 O(1)

链表

part 01

203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。
示例 1：
在这里插入图片描述

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

思路：删除链表中的节点

删除头节点 head=head->next;
删除非头节点

找到要删除节点x的前一个节点p
p->next=x-next;
1. 统一删除
设置虚拟头节点 dummyNode ，这样都变成删除非头节点的方式
return dummyNode->next;，这才是新的头结点

题解

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 */
public ListNode removeElements(ListNode head, int val) {
   
   
    if (head == null) {
   
   
        return head;
    }
    // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
    ListNode dummy = new ListNode(-1, head);
    ListNode pre = dummy;
    ListNode cur = head;
    while (cur != null) {
   
   
        if (cur.val == val) {
   
   
            pre.next = cur.next;
        } else {
   
   
            pre = cur;
        }
        cur = cur.next;
    }
    return dummy.next;
}

707. 设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将不会插入到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点

示例：

输入
[“MyLinkedList”, “addAtHead”, “addAtTail”, “addAtIndex”, “get”, “deleteAtIndex”, “get”]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3
myLinkedList.get(1); // 返回 3

提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

题解


class ListNode {
   
   
    int val;
    ListNode next;

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

class MyLinkedList {
   
   
    //size存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
   
   
        size = 0;
        head = new ListNode(0);
    }

    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {
   
   
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
   
   
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
   
   
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    //在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {
   
   
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
   
   
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
   
   
        if (index > size) {
   
   
            return;
        }
        if (index < 0) {
   
   
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
   
   
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    //删除第index个节点
    public void deleteAtIndex(int index) {
   
   
        if (index < 0 || index >= size) {
   
   
            return;
        }
        size--;
        if (index == 0) {
   
   
            head = head.next;
	    return;
        }
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
   
   
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
在这里插入图片描述

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：
在这里插入图片描述

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

题解：

// 双指针
class Solution {
   
   
    public ListNode reverseList(ListNode head) {
   
   
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
   
   
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev