代码随想录 刷题记录-23 单调栈

于 2024-09-01 23:30:00 发布
阅读量541 收藏 12
点赞数 6
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Renas_TJOvO/article/details/141723198
版权

题目对“下一个更高”或者“下一个更低”有要求，可以考虑单调栈

（也可以考虑双指针，双指针往往能够把时间复杂度的指数减一）

1.739. 每日温度

思路

首先想到的当然是暴力解法，两层for循环，把至少需要等待的天数就搜出来了。时间复杂度是O(n^2)

那么接下来在来看看使用单调栈的解法。

什么时候用单调栈呢？

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)。

例如本题其实就是找找到一个元素右边第一个比自己大的元素，此时就应该想到用单调栈了。

单调栈的原理是什么呢？为什么时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？

单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。

更直白来说，就是用一个栈来记录我们遍历过的元素，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。

在使用单调栈的时候首先要明确如下几点：

1.单调栈里存放的元素是什么？

单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取。

2.单调栈里元素是递增呢？ 还是递减呢？

本题中，我们要求的是“下一个更大”，当新元素大于栈内元素时，我们知道新元素就是站内比它小的元素的“下一个更大”，所以只有新元素小于栈顶元素时才可以入栈，维护的是栈顶到栈底非严格递增的栈。

使用单调栈主要有三个判断条件。

  • 当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
  • 当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
  • 当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况

把这三种情况分析清楚了，也就理解透彻了。

本题图解参考：739每日温度单调栈图解

单调栈递增（从栈口到栈底顺序），就是求右边第一个比自己大的，单调栈递减的话，就是求右边第一个比自己小的。

代码如下：

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int[] result = new int[temperatures.length];
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(0);
        for(int i = 1 ; i < temperatures.length ;i++){
            if(temperatures[stack.peek()] >= temperatures[i]){
                stack.push(i);
            }else{
                while(!stack.isEmpty() && temperatures[stack.peek()]< temperatures[i]){
                    result[stack.peek()] = i - stack.pop();
                }
                stack.push(i);
            }
        }

        while(!stack.isEmpty()){
            result[stack.pop()] = 0;
        }
        return result;
    }
}

2.496.下一个更大元素 I

暴力搜索：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] res = new int[nums1.length];
        for(int i = 0 ; i < nums1.length ; i++){
            res[i] = -1;
        }
        for(int i = 0 ; i < nums1.length ; i++){
            for(int j = 0 ; j < nums2.length ; j++){
                if(nums1[i] == nums2[j]){
                    for(int k = j+1 ; k < nums2.length ; k++){
                        if(nums1[i] < nums2[k]){
                            res[i] = nums2[k];
                            break;
                        }
                    }
                    break;
                }
            }
        }
        return res;
    }
}

由于题目要求求的是“下一个更大”，考虑使用单调栈降低时间复杂度

从题目示例中我们可以看出最后是要求nums1的每个元素在nums2中下一个比当前元素大的元素，那么就要定义一个和nums1一样大小的数组result来存放结果。

这个result数组初始化应该为多少呢？

题目说如果不存在对应位置就输出 -1 ，所以result数组如果某位置没有被赋值，那么就应该是是-1，所以就初始化为-1。

在遍历nums2的过程中，我们要判断nums2[i]是否在nums1中出现过，因为最后是要根据nums1元素的下标来更新result数组。

注意题目中说是两个没有重复元素 的数组 nums1 和 nums2。

没有重复元素，我们就可以用map来做映射了。根据数值快速找到下标，还可以判断nums2[i]是否在nums1中出现过。

使用单调栈的思路和纯使用单调栈寻找“下一个更大”一样，只是这一次在填写答案的时候，先检查要填写的数字是否在nums1里，如果有，就填写，如果没有就不用填写。

代码如下：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer,Integer> map = new HashMap<>();
        Deque<Integer> stack = new ArrayDeque<>();
        int[] res = new int[nums1.length];
        for(int i = 0 ; i < nums1.length ;i++){
            res[i] = -1;
        }
        for(int i = 0; i < nums1.length ; i++){
            map.put(nums1[i],i);
        }
        stack.push(0);
        for(int i = 1 ; i < nums2.length ; i++){
            //仍然像正常遍历求nextBigger一样维护单调栈
            //但是在出栈（填写答案）的时候判断是不是nums1里的元素即可
            while(!stack.isEmpty() && nums2[stack.peek()] < nums2[i]){
                if(map.containsKey(nums2[stack.peek()])){
                    res[map.get(nums2[stack.peek()])] = nums2[i];
                }
                stack.pop();
            }
            stack.push(i);
        }
        return res;
    }
}

3.503.下一个更大元素II

思路：既然是循环，那么把原来的操作进行一遍后，再来一遍，就可以得到循环的结果。

代码如下：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int[] res = new int[nums.length];
        Deque<Integer> stack = new ArrayDeque<>();
        for(int i = 0 ; i < nums.length ;i++){
            res[i] = -1;
        }
        stack.push(0);
        for(int i = 0; i < nums.length ;i++){
            if(nums[stack.peek()] < nums[i]){
                while(!stack.isEmpty() && nums[stack.peek()] < nums[i]){
                    res[stack.peek()] = nums[i];
                    stack.pop();
                }
            }
            stack.push(i);
        }

        for(int i = 0; i < nums.length ;i++){
            if(nums[stack.peek()] < nums[i]){
                while(!stack.isEmpty() && nums[stack.peek()] < nums[i]){
                    res[stack.peek()] = nums[i];
                    stack.pop();
                }
            }
            stack.push(i);
        }
        return res;
    }
}

精简版本：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int[] res = new int[nums.length];
        Deque<Integer> stack = new ArrayDeque<>();
        for(int i = 0 ; i < nums.length ;i++){
            res[i] = -1;
        }
        stack.push(0);
        for(int i = 0; i < nums.length*2 ;i++){
            if(nums[stack.peek()] < nums[i%nums.length]){
                while(!stack.isEmpty() && nums[stack.peek()] < nums[i%nums.length]){
                    res[stack.peek()] = nums[i%nums.length];
                    stack.pop();
                }
            }
            stack.push(i%nums.length);
        }
        return res;
    }
}

4.42. 接雨水

思路1：前后缀

根据本题要求的物理特性，把每一个格子看成一个独立的水桶，它能盛多少水取决于水桶左右的最小高度。因此我们要计算出它的右边的最大和左边的最大，在这两个最大中取最小，再减去地基的高度，这就是这个水桶能盛水的数量。

暴力模拟（会时间超限，时间复杂度O(n^2)：

class Solution {
    public int trap(int[] height) {
        int res = 0;
        for(int i = 0; i < height.length ;i++){
            if(i == 0 || i == height.length-1) continue;
            int left = height[i] , right = height[i];
            for(int j = i-1 ; j >= 0 ; j--){
                left = Math.max(left,height[j]);
            }
            for(int j = i+1 ; j < height.length ;j++){
                right = Math.max(right,height[j]);
            }
            res += (Math.min(left,right)-height[i]);
        }
        return res;
    }
}

思路2：考虑使用双指针求前后缀降低时间复杂度：

class Solution {
    public int trap(int[] height) {
        int[] maxLeft = new int[height.length];
        maxLeft[0] = height[0];
        int[] maxRight = new int[height.length];
        maxRight[height.length-1] = height[height.length-1];
        for(int i = 1; i < height.length ; i++){
            maxLeft[i] = Math.max(height[i],maxLeft[i-1]);
        }
        for(int i = height.length-2 ; i >= 0 ; i--){
            maxRight[i] = Math.max(maxRight[i+1],height[i]);
        }
        int result = 0;
        for(int i = 0 ; i < height.length ; i++){
            result += (Math.min(maxLeft[i],maxRight[i]) - height[i]);
        }
        return result;

    }
}

这里的思想是考虑到maxLeft 和 maxRight 的计算存在重复，因此使用了 maxLeft 和 maxRight两个数组来记录已经计算过的结果。同时也用到了动态规划的思想，使用记录过的已经计算过的结果来得到新的要计算的结果，需要考虑遍历顺序和初始化的问题。

思路3：单调栈

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，就可以考虑用单调栈了。

1.单调栈的解题思路以行的方式考虑雨水累加，这样一层层计算，层的宽度与 当前下标 和 下一个更高的下标 有关，层高与 Math.min（左高，右高） - 底高 有关。

2.使用单调栈内元素的顺序：

从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。

如图：

42.接雨水4

3.遇到相同的元素

遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。

例如 5 5 1 3 这种情况。如果添加第二个5的时候就应该将第一个5的下标弹出，把第二个5添加到栈中。

因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度。

如图所示：

42.接雨水5

4.栈里存放什么元素

使用单调栈，也是通过 长 * 宽 来计算雨水面积的。

长就是通过柱子的高度来计算，宽是通过柱子之间的下标来计算，

栈里就存放下标就行，想要知道对应的高度，通过height[stack.top()] 就知道弹出的下标对应的高度了。

单调栈处理逻辑

以下操作过程其实和 739. 每日温度 (opens new window)也是一样的，建议先做 739. 每日温度 (opens new window)。

以下逻辑主要就是三种情况

  • 情况一：当前遍历的元素（柱子）高度小于栈顶元素的高度 height[i] < height[st.top()]
  • 情况二：当前遍历的元素（柱子）高度等于栈顶元素的高度 height[i] == height[st.top()]
  • 情况三：当前遍历的元素（柱子）高度大于栈顶元素的高度 height[i] > height[st.top()]

先将下标0的柱子加入到栈中，st.push(0);。 栈中存放我们遍历过的元素，所以先将下标0加进来。

然后开始从下标1开始遍历所有的柱子，for (int i = 1; i < height.size(); i++)。

如果当前遍历的元素（柱子）高度小于栈顶元素的高度，就把这个元素加入栈中，因为栈里本来就要保持从小到大的顺序（从栈头到栈底）。

代码如下：

if (height[i] < height[st.top()])  st.push(i);

如果当前遍历的元素（柱子）高度等于栈顶元素的高度，要跟更新栈顶元素，因为遇到相相同高度的柱子，需要使用最右边的柱子来计算宽度。

代码如下：

if (height[i] == height[st.top()]) { // 例如 5 5 1 7 这种情况
  st.pop();
  st.push(i);
}

如果当前遍历的元素（柱子）高度大于栈顶元素的高度，此时就出现凹槽了，如图所示：

42.接雨水4

取栈顶元素，将栈顶元素弹出，这个就是凹槽的底部，也就是中间位置，下标记为mid，对应的高度为height[mid]（就是图中的高度1）。

此时的栈顶元素st.top()，就是凹槽的左边位置，下标为st.top()，对应的高度为height[st.top()]（就是图中的高度2）。

当前遍历的元素i，就是凹槽右边的位置，下标为i，对应的高度为height[i]（就是图中的高度3）。

此时大家应该可以发现其实就是栈顶和栈顶的下一个元素以及要入栈的元素，三个元素来接水！

那么雨水高度是 min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度，代码为：int h = min(height[st.top()], height[i]) - height[mid];

雨水的宽度是 凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度），代码为：int w = i - st.top() - 1 ;

当前凹槽雨水的体积就是：h * w。

求当前凹槽雨水的体积代码如下：

while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while，持续跟新栈顶元素
    int mid = st.top();
    st.pop();
    if (!st.empty()) {
        int h = min(height[st.top()], height[i]) - height[mid];
        int w = i - st.top() - 1; // 注意减一，只求中间宽度
        sum += h * w;
    }
}

逻辑详细的完整代码如下：

class Solution {
    public int trap(int[] height) {
    //横向切分，思路是单调栈，注意下一个元素与当前栈顶元素 因 大小不同 造成的不同逻辑
        int sum = 0;
        Deque<Integer> stack = new ArrayDeque<>();//存放下标，如果要取高度，则用height取
        stack.push(0);
        for(int i = 1; i < height.length ; i++){
            if(height[stack.peek()] > height[i]){
                stack.push(i);
            }else if(height[stack.peek()] == height[i]){
                stack.pop();
                stack.push(i);
            }else{
                while(!stack.isEmpty() && height[stack.peek()] < height[i]){
                    int mid = stack.pop();
                    int right = i;
                    if(!stack.isEmpty()){
                        int left = stack.peek();
                        int w = right - left - 1;
                        int h = Math.min(height[right],height[left]) - height[mid];
                        sum += h*w;
                    }
                }
                stack.push(i);
            }

        }
        return sum;
    }
}

对重复的地方进行优化；

class Solution {
    public int trap(int[] height) {
    //横向切分，思路是单调栈，注意下一个元素与当前栈顶元素 因 大小不同 造成的不同逻辑
        int sum = 0;
        Deque<Integer> stack = new ArrayDeque<>();//存放下标，如果要取高度，则用height取
        stack.push(0);
        for(int i = 1; i < height.length ; i++){
            if(height[stack.peek()] == height[i]){
                stack.pop();
            }else if(height[stack.peek()] < height[i]){
                while(!stack.isEmpty() && height[stack.peek()] < height[i]){
                    int mid = stack.pop();
                    int right = i;
                    if(!stack.isEmpty()){
                        int left = stack.peek();
                        int w = right - left - 1;
                        int h = Math.min(height[right],height[left]) - height[mid];
                        sum += h*w;
                    }
                }
            }
            stack.push(i);
        }
        return sum;
    }
}

5.84.柱状图中最大的矩形

暴力解法

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int sum = 0;
        for (int i = 0; i < heights.size(); i++) {
            int left = i;
            int right = i;
            for (; left >= 0; left--) {
                if (heights[left] < heights[i]) break;
            }
            for (; right < heights.size(); right++) {
                if (heights[right] < heights[i]) break;
            }
            int w = right - left - 1;
            int h = heights[i];
            sum = max(sum, w * h);
        }
        return sum;
    }
};

如上代码并不能通过leetcode，超时了，因为时间复杂度是$O(n^2)$。

双指针法

（但是时间复杂度仍然是O(n^2)）量级：

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        vector<int> minLeftIndex(heights.size());
        vector<int> minRightIndex(heights.size());
        int size = heights.size();

        // 记录每个柱子 左边第一个小于该柱子的下标
        minLeftIndex[0] = -1; // 注意这里初始化，防止下面while死循环
        for (int i = 1; i < size; i++) {
            int t = i - 1;
            // 这里不是用if，而是不断向左寻找的过程
            while (t >= 0 && heights[t] >= heights[i]) t = minLeftIndex[t];
            minLeftIndex[i] = t;
        }
        // 记录每个柱子 右边第一个小于该柱子的下标
        minRightIndex[size - 1] = size; // 注意这里初始化，防止下面while死循环
        for (int i = size - 2; i >= 0; i--) {
            int t = i + 1;
            // 这里不是用if，而是不断向右寻找的过程
            while (t < size && heights[t] >= heights[i]) t = minRightIndex[t];
            minRightIndex[i] = t;
        }
        // 求和
        int result = 0;
        for (int i = 0; i < size; i++) {
            int sum = heights[i] * (minRightIndex[i] - minLeftIndex[i] - 1);
            result = max(sum, result);
        }
        return result;
    }
};

单调栈

寻找leftNextLow 和 rightNextLow;

分别存放i对应的左边第一个更小元素位置 和 右边第一个更小元素位置；

注意遍历顺序和初始化：

leftNextLow初始化成 -1 (可以认为是没有更小的情况下，-1的位置没有元素，高度是0，是左边第一个更小元素的位置），从右往左遍历。

同理， rightNextLow初始化成 height.length ，从左往右遍历。

遍历，取最大的 height[i] * (rightNextLow[i] - leftRightLow[i] - 1);

class Solution {
    public static int largestRectangleArea(int[] heights) {
        int res = 0;
        int[] leftNextLow = new int[heights.length];
        for(int i = 0; i < heights.length ; i++){
            leftNextLow[i] = -1;
        }
        int[] rightNextLow = new int[heights.length];
        for(int i = 0 ; i < heights.length ; i++){
            rightNextLow[i] = heights.length;
        }
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(0);
        for(int i = 1 ; i < heights.length ; i++){
            while(!stack.isEmpty() && heights[stack.peek()] > heights[i]){
                rightNextLow[stack.peek()] = i;
                stack.pop();
            }
            stack.push(i);
        }

        while(!stack.isEmpty()) stack.pop();
        stack.push(heights.length-1);
        for(int i = heights.length - 2 ; i >= 0 ; i--){
            while(!stack.isEmpty() && heights[stack.peek()] > heights[i]){
                leftNextLow[stack.peek()] = i;
                stack.pop();
            }
            stack.push(i);
        }

        for(int i = 0; i < heights.length ; i++){
            int w = rightNextLow[i] - leftNextLow[i] - 1;
            int h = heights[i];
            res = Math.max(res,w*h);
        }
        return res;
    }
}

Renas_TJOvO
关注
  • 6
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录-大厂八股文-面试
04-25
"代码随想录-大厂八股文-面试" 从标题和描述中，我们可以看出这篇文章主要讲述的是代码随想录的大厂八股文面试相关知识点。下面将对这些知识点进行详细的解释和总结。 首先，代码随想录是一种常用的编程技巧，旨在...
代码随想录刷题打卡day02
04-18
3. 代码重构：代码中声明的数组 `int[] nums = {1};` 在 `while` 循环中使用时，包含等号的条件可以避免在临界情况下（如数组只有一个元素）发生数组越界的问题。 4. 数组操作与指针移动：在双指针法中，通常需要对...
leetcode-master（代码随想录出品）-算法题资源
07-03
LeetCode 20060w50C++JavaPythonGoJavaScript
数据结构
2301_80184169的博客
08-28 583
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
25版王道数据结构课后习题详细分析 第五章 树与二叉树 5.4 树、森林
2406_86301373的博客
08-26 580
解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 879
数组，双链表实现队列，附完整代码
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
weixin_44399845的博客
08-28 872
BM_BC算法：坏字符
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
2303_80388948的博客
08-27 1203
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1200
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
Java算法之插入排序（Insertion Sort）
最新发布
weixin_38959316的博客
08-29 319
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
数据结构（邓俊辉）学习笔记】串 06——KMP算法：构造next[]表
weixin_44399845的博客
08-27 775
KMP算法：构造next[]表
初识数据结构
qixi_ao的博客
08-26 584
数据结构
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 1231
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
数据结构——单向链表
m0_61965705的博客
08-28 787
算法：快指针先走k步，慢指针和快指针每次走1步(快指针总是领先慢指针k步)，当快指针走到末尾时,慢指针即指向链表倒数第k个节点。无头单向链表，节点插入在头的话，每次头结点都会变，所以有了有头链表，头结点的pNext总是指向链表的第一个节点。算法：快指针pFast每次走2步，慢指针pSlow每次走1步，快指针到达末尾时，慢指针所在的位置即为中间位置。因为快指针第一次比慢指针多1，第二次快指针比慢指针快2，依次类推，环长一定是一个自然数，所以一定能相遇。每次选出最小的，第二小的...最大的，
数据结构 链表
2301_79898193的博客
08-28 340
1.链表可以动态的增加或者减少节点，而顺序表在一开始就定义了大小，扩展或缩小数组会涉及内存的重新分配，效率低下；2.插入和删除效率 链表更容易时间复杂度为O（1），顺序表需要整个移动大量资源时间复杂度为O(n);3.链表的内存可以是碎片化不连续的内存，而顺序表一定是需要连续的内存，会出现浪费行为。数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。4.链表的插入和删除效率很高。
树数据结构（Tree Data Structures）的全面指南：深度解析、算法实战与应用案例
Chauvin的博客
08-27 1856
树数据结构（Tree Data Structures）作为计算机科学中的基石之一，以其独特的层次结构和分支特性，在众多领域发挥着关键作用。从文件系统的组织到数据库的索引，从编译原理的语法分析到人工智能的决策制定，树数据结构无处不在。本文将深入探讨树数据结构的基本概念、类型、遍历方式及其在实际应用中的广泛案例。
数据结构（邓俊辉）学习笔记】串 07——KMP算法：分摊分析
weixin_44399845的博客
08-27 581
KMP算法：分摊分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值