力扣刷题集锦

最新推荐文章于 2024-08-04 16:25:50 发布

Jam的bf

最新推荐文章于 2024-08-04 16:25:50 发布

阅读量940

点赞数 1

分类专栏：算法文章标签： leetcode

本文链接：https://blog.csdn.net/qq_35842663/article/details/118529962

版权

算法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文汇总了HOT100算法挑战中的关键题目，包括两数之和、寻找中位数、链表操作（如两数相加、删除倒数第N个节点）、合并有序链表，以及字符串相关问题。深入解析并提供了高效算法实现，涉及哈希表、动态规划、双指针等技巧。

摘要由CSDN通过智能技术生成

力扣刷题

一、HOT100

一、HOT100

(一) 数组

1.两数之和

在这里插入图片描述
方法一：暴力
确定左起点之后遍历右边所有节点，当满足两个节点之和等于target时返回结果。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int len = nums.length;
        int[] result = new int[2];

        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j < len; j++){
                if (nums[i] + nums[j] == target) {
                    result[0] = i;
                    result[1] = j;
                    return result;
                }
            }
        }
        return result;
    }
}

时间复杂度：O(N^2)
空间复杂度：O(1)

方法二：哈希表
一次遍历数组，期间使用哈希表记录遍历过的节点，然后同时判断当前节点和历史节点之和是否等于targe，等于就返回结果。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer>map=new HashMap<>();
        int[] res=new int[2];
        
        if(nums==null||nums.length==0)return res;
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
               res[0]=i;
               res[1]=map.get(target-nums[i]);
            }
            //判断之后put防止添加自己
            map.put(nums[i],i);
        }
        return res;
    }
}

⚠️：哈希表添加元素放在判断之后，因为如果放在之前，会导致一个元素在一次循环中被访问两次。反面示例：【3，2，4】
时间复杂度：O(N)
空间复杂度：O(N)

4.寻找两个正序数组的中位数

(二)链表

2.两数相加

在这里插入图片描述
方法一：模拟法
因为链表是倒序的，所以可以直接遍历节点进行相加运算，每计算1个节点就存到结果链表中。
期间注意进位对循环的作用。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        //哑节点记录结果链表头节点位置
        ListNode dummy = new ListNode(-1);
        ListNode head = dummy;

        int c = 0;
        int value = 0;
        //停止相加的条件是两个链表为空且进位为0
        while (l1 != null || l2 != null || c != 0) {
            //提前判断空，确定加的数
            int x = l1 == null ? 0 : l1.val;
            int y = l2 == null ? 0 : l2.val;
            //加法过程
            value = x + y + c;
            c = value / 10;
            //更新结果链表
            head.next = new ListNode(value % 10);
            head = head.next;
            //更新l1和l2
            if (l1 != null) {
                l1 = l1.next;
            }
            if (l2 != null) {
                l2 = l2.next;
            }
        }
        return dummy.next;
    }
}

时间复杂度：O(max(m,n))
空间复杂度：O(1) //⚠️结果空间不计入复杂度

19.删除链表的倒数第N个结点

在这里插入图片描述
方法一：堆栈
因为题目要求的是删除倒数第n个节点，所以自然想到堆栈，出栈的时候记录删除节点的前后节点，然后改变指向即可，不过要注意删除头节点的情况。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //创建哑节点
        ListNode dummy = new ListNode(-1, head);

        Deque<ListNode> stack = new LinkedList<>();

        //压栈为了后面的倒序
        while (head != null) {
            stack.offerFirst(head);
            head = head.next;
        }

        //删除节点的前一个节点
        ListNode pre = null;
        //删除节点的后一个节点
        ListNode post = null;

        //记录删除节点的前后节点
        for (int i = 1; i <= (n+1); i++) {
            ListNode tmp = stack.pollFirst();
            if (i == (n-1)) {
                post = tmp;
            }

            if (i == (n+1)) {
                pre = tmp;
            }
        } 

        //如果pre为null,说明删除的是头节点，直接指向后面一个节点(当整个链表只有一个节点的时候为null)
        if (pre == null) {
            dummy.next = post;
        } else {
            pre.next = post;
        }

        //返回结果
        return dummy.next;
    }
}

时间复杂度：O(N)
空间复杂度：O(N)

可以改进下：
哑节点主要有两个作用：

记录头节点的位置用于结果返回
哑节点不在原始链表范围内，可以避免涉及到头节点时一系列的空节点判断
上面的解题过程，第二个优点没有用到，最后还要去判断前继结点是否为null，那其实原链表最多删去头节点，而头节点的前继节点是哑节点，不为空，所以可以把哑节点压栈，要删除的节点出栈后，栈顶就是前继节点，直接原地修改指向就行。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //创建哑节点
        ListNode dummy = new ListNode(-1, head);

        Deque<ListNode> stack = new LinkedList<>();

        //从哑节点开始遍历可以避免判断删除头节点的情况
        ListNode curNode = dummy;

        //压栈为了后面的倒序
        while (curNode != null) {
            stack.offerFirst(curNode);
            curNode = curNode.next;
        }

        //弹出删除结点停止
        for (int i = 1; i <= n; i++) {
            stack.pollFirst();
        }

        //找到前一个节点
        ListNode prev = stack.peekFirst();
        //此时压哑节点入栈的优点就体现了，prev不可能为null,因为n不可能到达哑节点的位置
        //更改指向
        prev.next = prev.next.next;

        //返回结果
        return dummy.next;
    }
}

时间复杂度：O(N)
空间复杂度：O(N)

方法二：双指针
快慢指针先保持n个间隔，然后同时移动，当快指针到达尾部时，慢指针位于删除节点的前继节点。注意哑节点的作用(快慢指针从哑节点开始)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //创建哑节点
        ListNode dummy = new ListNode(-1, head);
        //创建快慢指针,从哑节点开始为了避免删除头节点时不必要的空判断
        ListNode fast = dummy;
        ListNode slow = dummy;
        //快指针先移动n位
        int cnt = 0;
        while ((cnt++) < n) {
            fast = fast.next;
        }
        //当快指针指向null时代表到链表尾部了，此时slow处于删除节点的前继
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        //前继指向后继
        slow.next = slow.next.next;
        //返回结果
        return dummy.next;
    }
}

时间复杂度：O(N)
空间复杂度：O(1)

方法三：递归

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    private int k = 0;
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if (head == null) {
            return null;
        }

        head.next = removeNthFromEnd(head.next, n);

        if ((++k) == n) {
            return head.next;
        }

        return head;
    }
}

时间复杂度：O(N)
空间复杂度：O(N)

21.合并两个有序链表

在这里插入图片描述
方法一：迭代
遍历两个链表的每个节点，每次结果链表指向较小的节点，最后指向不为null的链表。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        //创建哑节点
        ListNode dummy = new ListNode(-1);
        ListNode head = dummy;

        //只要有一个为null就退出循环
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                head.next = l1;
                l1 = l1.next;
            } else {
                head.next = l2;
                l2 = l2.next;
            }

            head = head.next;
        }

        //结果链表接上不为null的链表
        if (l1 == null) {
            head.next = l2;
        }
        
        if (l2 == null) {
            head.next = l1;
        }

        //返回结果
        return dummy.next;

    }
}

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

方法二：递归法
可以提炼出一个子问题：合并(L1, L2)等价于L1 -> next = 合并(L1 -> next, L2) (l1.val < l2.val)
子问题和原问题具有相同结构，所以可以自上而下地进行递归，结束条件是有一个链表为空。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val <= l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else if (l1.val > l2.val) {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
        return null;
    }
}

时间复杂度：O(m+n)
空间复杂度：O(m+n)

(三) 字符串

3.无重复字符的最长子串

刚开始这些写的：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s.length() == 0) {
            return 0;
        }

        int result = 0;
        int len = s.length();
        //记录字符出现的最新位置
        Map<Character, Integer> indexMap = new HashMap<>();
        char[] chs = s.toCharArray();
        for (int i = 0; i < len; i++) {
            int index = indexMap.getOrDefault(chs[i],-1);
            if ((i - index) > result) {
                result = i - index;
            }
            indexMap.put(chs[i], i);
        } 
        return result;
    }
}

在这里插入图片描述
这样肯定不对的，题目要求的是最长子串，而我这是记录字符串中每一位字符的不重复索引的最大值。

主体解题思想应该是记录子字符串的起始位置，当右指针遇到相同的字符时更新起始位置。
可以计算出每个字符作为字符串末尾时的子字符串长度，最后选择最大的，这样可以使用dp，因为以后一个字符结尾的子字符串长度依赖于前一个子串长度
dp[j]定义为以索引j的字符为结尾的不重复的子串的长度，只不过需要分三种情况：

dp[j] = dp[j-1] + 1, j - i > dp[j-1] 该位置j结尾的子串还没有出现重复字符
dp[j] = j - i, j - i < dp[j-1] 该位置j结尾的子串出现重复字符
dp[j] = j - i, j - i = dp[j-1] 该位置j结尾的字符和位置i的字符重复了
i, j 分别记录位置j字符的最新索引。
下面这个讲的更好，区间比较概念更易懂：

方法一：动态规划

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //判断特殊情况
        if (s.length() == 0) {
            return 0;
        }

        //创建返回结果，注意至少为1
        int result = 1;

        //创建dp数组和初始化
        int len = s.length();
        char[] chs = s.toCharArray();
        int[] dp = new int[len];
        dp[0] = 1;

        //记录字符出现的最新索引
        Map<Character, Integer> indexMap = new HashMap<>();
        indexMap.put(chs[0], 0);

        //函数主体：遍历字符串
        for (int rightIndex = 1; rightIndex < len; rightIndex++) {
            //获得当前字符的最新索引
            int leftIndex = indexMap.getOrDefault(chs[rightIndex],-1);
            //计算该字符的左右索引之差
            int diff = rightIndex - leftIndex;
            //dp主体
            if (diff > dp[rightIndex - 1]) {
                dp[rightIndex] = dp[rightIndex - 1] + 1;
            }
            else if (diff <= dp[rightIndex - 1]) {
                dp[rightIndex] = diff;
            }
            //更新字符索引
            indexMap.put(chs[rightIndex], rightIndex);
            //更新最大子串长度
            if (dp[rightIndex] > result) {
                result = dp[rightIndex];
            }
        } 

        //返回结果
        return result;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)//⚠️字符的 ASCII 码范围为 0 ~ 127，哈希表最多使用 O(128) = O(1)大小的额外空间。

map的作用主要是获取当前字符的左边界，所以也可以用循环线性查找：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //判断特殊情况
        if (s.length() == 0) {
            return 0;
        }

        //创建返回结果，注意至少为1
        int result = 1;

        //创建dp数组和初始化
        int len = s.length();
        char[] chs = s.toCharArray();
        int[] dp = new int[len];
        dp[0] = 1;

        //函数主体：遍历字符串
        for (int rightIndex = 1; rightIndex < len; rightIndex++) {
            //获得当前字符的最新索引
            int leftIndex = rightIndex - 1;
            while (leftIndex >= 0) {
                if (chs[leftIndex] == chs[rightIndex]) {
                    break;
                }

                leftIndex--;
            }
            //计算该字符的左右索引之差
            int diff = rightIndex - leftIndex;
            //dp主体
            if (diff > dp[rightIndex - 1]) {
                dp[rightIndex] = dp[rightIndex - 1] + 1;
            }
            else if (diff <= dp[rightIndex - 1]) {
                dp[rightIndex] = diff;
            }

            //更新最大子串长度
            if (dp[rightIndex] > result) {
                result = dp[rightIndex];
            }
        } 

        //返回结果
        return result;
    }
}

方法二：双指针
滑动窗口思想：左右指针控制窗口大小。

固定左边界时，当右边界的下一个值不超过len且窗口内不包含该元素时就更新右边界，然后更新长度；
左边界更新时记得窗口移除上一个左边界元素。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //判断特殊情况
        if (s.length() == 0) {
            return 0;
        }

        //初始化
        int len = s.length();
        char[] chs = s.toCharArray();
        
        //右边界初始为-1
        int right = -1;
        //返回结果至少为1
        int result = 1;

        //滑动窗口内的元素集合
        Set<Character> set = new HashSet<>();

        //函数主体
        for (int left = 0; left < len; left++) {
            //左边界加1 -> 上一个左边界字符删除
            if (left != 0) {
                set.remove(chs[left - 1]);
            }
            //当前右边界没超 && 当前滑动窗口内没有右边界元素
            //+1是因为初始为-1，字符本身也要计算
            while ( (right+1) < len && !set.contains(chs[right+1])) {
                set.add(chs[right+1]);

                right++;
            }
            //更新结果
            result = Math.max(result, right - left + 1);
        }
        //返回结果
        return result;
    }
}

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

20.有效的括号

在这里插入图片描述
堆栈法：
栈顶元素和字符元素不匹配就压栈，否则就出栈，最后判断栈空。

class Solution {
    public boolean isValid(String s) {
        
        int len = s.length();
        //判断特殊情况
        if (len == 1) {
            return false;
        }
        //初始化
        Deque<Character> deque = new LinkedList<>();
        char[] chs = s.toCharArray();

        //函数主体
        for (Character ch : chs) {
            //堆栈不为空的情况下，栈顶遇到匹配的字符的时候才会弹出，否则一直压栈
            if (!deque.isEmpty() && ((deque.peekFirst() == '(' && ch == ')') || (deque.peekFirst() == '{' && ch == '}') || (deque.peekFirst() == '[' && ch == ']'))) {
                deque.pollFirst();
            } else {
                deque.offerFirst(ch);
            }
        }

              deque.offerFirst(ch);
            }
        }

        //返回结果
        return deque.isEmpty();
    }
}

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

在较长字符串的情况下可以使用哈希表来提前返回：
其实当栈顶字符和当前字符不匹配的时候就可以判定为false了，没必要继续压栈判断了

class Solution {
    public boolean isValid(String s) {

        int len = s.length();
        //改进1:只要字符数为奇数，肯定不能完全闭合
        if ((len & 1) == 1) {
            return false;
        }

        //map记录字符对
        Map<Character, Character> map = new HashMap<>() {{
            put(')', '(');
            put('}', '{');
            put(']', '[');
        }};

        //初始化
        char[] chs = s.toCharArray();
        Deque<Character> stack = new LinkedList<>();

        //函数主体
        for (Character ch : chs) {
            //如果此时的字符是map的key，就代表需要判断是否弹出，否则压栈等待下一次判断
            if (map.containsKey(ch)) {
                //改进2:提前返回
                //一旦栈顶字符跟value不匹配意味着后面就不可能闭合了，或者右字符要添加到空栈中也无法闭合，所以直接返回false，提前返回，后面没必要判断了
                if (stack.isEmpty() || stack.peekFirst() != map.get(ch)) {
                    return false;
                }

                stack.pollFirst();
            } else {
                stack.offerFirst(ch);
            }
        }

        return stack.isEmpty();
    }
}

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

(四) 回溯

解决一个回溯问题，实际上就是一个决策树的遍历过程,是一种穷举算法。
你只需要思考 3 个问题：

1、路径：也就是已经做出的选择。

2、选择列表：也就是你当前可以做的选择。

3、结束条件：也就是到达决策树底层，无法再做选择的条件。

回溯算法的框架:

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

46.全排列

在这里插入图片描述
思想：
保存根节点到每个叶子结点的路径

class Solution {
    //返回结果，全局域
    private List<List<Integer>> result = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        //记录路径
        LinkedList<Integer> track = new LinkedList<>();
        backtrack(nums, track);
        return result;
    }

    public void backtrack(int[] nums, LinkedList<Integer> track) {
        //当到达叶子节点时，更新结果列表
        if (track.size() == nums.length) {
            result.add(new LinkedList(track));
            return;
        }
        //遍历数组中的每一个数
        for (int i = 0; i < nums.length; i++) {
            //排除已经添加的重复元素
            if (track.contains(nums[i])) {
                continue;
            }
            //做选择
            track.add(nums[i]);
            //递归回溯，进入下一层决策树
            backtrack(nums, track);
            //撤销选择
            track.removeLast();
        }
    }
}

注意⚠️：

类型选择LinkedList方便删除最近一个元素，并且声明的时候，不要new List<LinkedList>(), 直接LinkedList<>()就行。
result.add(track); 这样写返回的都为空，因为是浅拷贝，刚开始值是赋进去了，但是后面remove了之前add的arraylist地址里的数据，所以为空。

时间复杂度：O(nnn! )
递归函数的时间复杂度 = 递归函数本身的复杂度 * 递归函数被调用的次数(决策树上节点的个数) = n*n * n!
空间复杂度：O(n)

关于去除重复元素的方法还有两种：可将时间复杂度将为O(n*n! )

交换元素
记录在当前路径上某节点是否被遍历过

51.N皇后

在这里插入图片描述
思想：
按照行列穷举放置皇后，放置之前先判断是不是合法的。

class Solution {
    //结果集
    private List<List<String>> result = new ArrayList<>();
    
    public List<List<String>> solveNQueens(int n) {
        //棋盘布局
        ArrayList<StringBuilder> board = new ArrayList<>();
        //初始化棋盘为空
        StringBuilder tmp = new StringBuilder();
        for (int i = 0; i < n; i++) {
            tmp.append('.');
        }
        for (int i = 0; i < n; i++) {
            board.add(new StringBuilder(tmp));
        }
        //回溯
        backtrack(board, 0);
        //返回结果
        return result;
    }

    public void backtrack(ArrayList<StringBuilder> board, int row) {
        //获取总行数/列数
        int n = board.size();
        //当到第n行时转化为string添加到结果集中
        if (row == n) {
            ArrayList<String> tmp = new ArrayList<String>();
            for (int i = 0; i < n; i++) {
                tmp.add(board.get(i).toString());
            }
            result.add(tmp);
            return;
        }
        //遍历每一行的每一列
        for (int col = 0; col < n; col++) {
            //当前坐标不能放置皇后
            if (!isValid(board, row, col)) {
                continue;
            }

            board.get(row).setCharAt(col, 'Q');
            backtrack(board, row+1);
            board.get(row).setCharAt(col, '.');
        }
    }

    //判断是否可以在目标位置放皇后
    boolean isValid(ArrayList<StringBuilder> track, int row, int col){
        int  n = track.size();
        // 检查列是否有皇后冲突
        for(int i = 0; i < n; i++){
            if(track.get(i).charAt(col) == 'Q') 
                return false;
        }
        // 检查右上方是否有皇后冲突
        for(int i = row-1, j = col+1; 
                i >=0 && j <n; i--,j++) {
            if(track.get(i).charAt(j) == 'Q') 
                return false;
        }
        // 检查左上方是否有皇后冲突
        for(int i= row-1, j = col-1; 
                i >=0 && j >=0; i--,j--) {
            if(track.get(i).charAt(j) == 'Q') 
                return false;
        }
        return true;  
    }
}