Leetcode 912. 排序数组 —— 总结十大排序

已于 2023-09-21 10:46:12 修改
阅读量223 收藏 1
点赞数 2
分类专栏： Leetcode专栏 文章标签： leetcode 算法 排序算法
于 2023-05-30 19:20:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51322383/article/details/130913068
版权

文章目录

前言

这一篇打算用来写十大排序，尤其是三大很快的排序：快速、堆、归并，应该也是面试的重中之重。

题目

在这里插入图片描述
Leetcode 912. 排序数组

排序算法时间复杂度（平均）时间复杂度（最好）时间复杂度（最差）空间复杂度稳定性
直插排序O(n2)O(n2)O(n2)O(1)稳定
选择排序O(n2)O(n2)O(n2)O(1)不稳定
冒泡排序O(n2)O(n)O(n2)O(1)稳定
希尔排序O(n1.5)O(n)O(n2)O(1)不稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
快速排序O(nlogn)O(nlogn)O(n^2)O(logn)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
计数排序O(n+k)O(n+k)O(n+k)O(k)稳定
桶排序O(n+k)O(n+k)O(n^2)O(n+k)稳定
基数排序O(n*k)O(n*k)O(n*k)O(n+k)稳定

快乐的做法

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        sort(nums.begin(),nums.end());
        return nums;
    }
};

直接插入排序

  • 稳定性：稳定
  • 时间复杂度：O(n2)
  • 空间复杂度：O(1)
    在这里插入图片描述
  • 算法步骤
    1. 从第一个元素开始，该元素认为已经被排序；
    2. 取下一个元素，在已排序的序列中进行二分查找
    3. 根据下标l和r找到下标，r的右边一个就是应该插入的位置
    4. 将新元素插入到r后面
    5. 重复步骤2~4

代码（首刷看二分解析，更快）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        for(int i = 1; i < n; i++) {
            if(nums[i] >= nums[i-1])   // 两元素递增则直接插入
                continue;   
            int l = 0, r = i-1;
            // 二分查找，时间复杂度logn
            while(l <= r) { 
                int mid = (r-l)/2 + l;
                if(nums[mid] > nums[i]) {   // r右侧元素均大于 nums[i]，即 r 及其左侧元素均小于等于nums[i]
                    r = mid - 1;
                } else {
                    l = mid + 1;
                } 
            }
            int tmp = nums[i];
            for(int j = i-1; j >= r + 1; j--) {
                nums[j+1] = nums[j];
            }
            nums[r+1] = tmp;
        }
        return nums;
    }
};

该算法在LC上会超时，无法通过。

选择排序

  • 稳定性：不稳定
  • 时间复杂度：O(n2)
  • 空间复杂度：O(1)
    在这里插入图片描述
  • 算法步骤
    1. 第一层循环：[0,n-1]
    2. 第二层循环：[i+1,n]
    3. 循环遍历找到最小值ind，将i和ind交换

代码（首刷自解）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        for(int i = 0; i < n-1; i++) {
            int ind = i;
            for(int j = i+1; j < n; j++) {
                if(nums[j] < nums[ind]) {
                    ind = j;
                }
            }
            swap(nums[i], nums[ind]);
        }
        return nums;
    }
};

该算法在LC上会超时，无法通过。

冒泡排序

  • 稳定性：稳定
  • 时间复杂度：O(n2)
  • 空间复杂度：O(1)

在这里插入图片描述

  • 算法步骤
    1. 第一层循环[0,n-1]
    2. 第二层循环[0,n-1-i]
    3. 两两比较交换

代码（首刷自解）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        for(int i = 0; i < n-1; i++) {
            bool flag = false;
            for(int j = 0; j < n-i-1; j++) {
                if(nums[j] > nums[j+1]) {
                    swap(nums[j], nums[j+1]);
                    flag = true;
                }
            }
            if(!flag)
                break;
        }
        return nums;
    }
};

该算法在LC上会超时，无法通过。

希尔排序

  • 稳定性：不稳定
  • 时间复杂度：O(n1.5)
  • 空间复杂度：O(1)

在这里插入图片描述

  • 算法步骤：
    1. 选择一个增量序列T1，T2，… ，Tk，其中Ti>Tj，Tk=1，i>j；
    2. 每趟排序，根据对应的增量Ti，将待排序列分割成若干子序列，分别对各子序列进行直接插入排序；
    3. 按增量序列个数k，对序列进行k趟排序。

代码（首刷看解析）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        for(int gap = n/2; gap >= 1; gap /= 2) {
            for(int i = gap; i < n; i++) {
                shellSort(nums, gap, i);
            }
        }
        return nums;
    }
    void shellSort(vector<int>& nums, int gap, int i) {
        int j = i-gap;
        int tmp = nums[i];
        for(; j >= 0 && tmp < nums[j]; j -= gap) {
            nums[j+gap] = nums[j];
        }
        nums[j+gap] = tmp;
    }
};

第一个通过的排序，记得将判断条件放入for中，节省时间

归并排序

  • 稳定性：稳定
  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(n)
    在这里插入图片描述
  • 算法步骤
    1. 把长度为n的输入序列分成两个长度为n/2的子序列；
    2. 对这两个子序列分别采用归并排序（递归）；
    3. 将两个排序好的子序列合并成一个最终的排序序列（注意下标）。

代码（首刷调试看解析）

class Solution {
public:
    vector<int> tmp;    // 辅助数组
    vector<int> sortArray(vector<int>& nums) {
        tmp.resize(nums.size(), 0); // 初始化
        MergeSort(nums, 0, nums.size()-1);
        return nums;
    }
    void MergeSort(vector<int>& nums, int l, int r) {
        if(l >= r)
            return; // 出递归
        int mid = (r-l)/2+l;
        MergeSort(nums, l, mid);
        MergeSort(nums, mid+1, r);
        // 下面是归并操作
        int i = l, j = mid+1;
        int k = 0;
        while(i <= mid && j <= r) {
            if(nums[i] <= nums[j]) {
                tmp[k++] = nums[i++];
            } else {
                tmp[k++] = nums[j++];
            }
        }
        while(i <= mid) {
            tmp[k++] = nums[i++];
        }
        while(j <= r) {
            tmp[k++] = nums[j++];
        }
        for(int m = 0; m < r-l+1; m++) {
            nums[m+l] = tmp[m];
        }
    }
};

代码（二刷看解析）

class Solution {
public:
    vector<int> tmp;
    vector<int> sortArray(vector<int>& nums) {
        tmp.resize(nums.size());
        mergeSort(nums, 0, nums.size() - 1);
        return nums;
    }
    void mergeSort(vector<int>& nums, int l, int r) {
        if(l >= r)
            return;
        int mid = (l+r)/2;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid+1, r);
        int i = l, j = mid+1;
        int k = 0;
        while(i <= mid && j <= r) {
            if(nums[i] < nums[j]) {
                tmp[k++] = nums[i++];
            } else {
                tmp[k++] = nums[j++];
            }
        }
        while(i <= mid) tmp[k++] = nums[i++];
        while(j <= r) tmp[k++] = nums[j++];
        for(int m = 0; m < r-l+1; m++) {
            nums[l+m] = tmp[m];
        }
    }
};

代码（9.1 三刷自解）

class Solution {
public:
    vector<int> tmp;
    vector<int> sortArray(vector<int>& nums) {
        tmp.resize(nums.size());
        mergeSort(nums, 0, nums.size()-1);
        return nums;
    }
    void mergeSort(vector<int>& nums, int left, int right) {
        if(left >= right)
            return;
        int mid = (left+right)/2;
        mergeSort(nums, left, mid);
        mergeSort(nums, mid+1, right);
        int i = left, j = mid+1;
        int k = 0;
        
        while(i <= mid && j <= right) {
            if(nums[i] < nums[j])
                tmp[k++] = nums[i++];
            else tmp[k++] = nums[j++];
        }
        while(i <= mid)
            tmp[k++] = nums[i++];
        while(j <= right)
            tmp[k++] = nums[j++];
        for(int m = 0; m < k; m++) 
            nums[left+m] = tmp[m];
    }
};

代码（9.21 四刷自解）

class Solution {
public:
    vector<int> tmp;
    vector<int> sortArray(vector<int>& nums) {
        tmp = vector<int>(nums.size());
        mergeSort(nums, 0, nums.size()-1);
        return nums;
    }
    void mergeSort(vector<int>& nums, int l, int r) {
        if(l >= r)
            return;
        int mid = (l+r)/2;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid+1, r);
        int i = l, j = mid+1;
        int k = 0;
        while(i <= mid && j <= r) {
            if(nums[i] < nums[j]) {
                tmp[k++] = nums[i++];  
            } else {
                tmp[k++] = nums[j++];  
            }
        }
        while(i <= mid) {
            tmp[k++] = nums[i++];
        }
        while(j <= r) {
            tmp[k++] = nums[j++];
        }
        
        for(i = 0; i < k; i++) {
            nums[l+i] = tmp[i];
        }
    }
};

快速排序

  • 稳定性：不稳定
  • 最好时间复杂度：O(nlogn)
  • 最差时间复杂度：O(n2)
  • 空间复杂度：O(logn)
    在这里插入图片描述
  • 算法步骤（左右指针法）
    1. 挑选一个pivot ；
    2. 每次移动指针再判断和pivot的大小，两两交换
    3. 递归recursive：按照[left,r]和[r+1,right]递归

快速排序最好情况下：O（nlogn） ，最坏情况下退化为选择排序（例如每次选择的都是最大值，之后遍历左边的 n -1 序列）：O（n2）

代码（首刷看解析）

rand() % (b-a+1)+ a ： a~b 之间的一个随机整数。

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        QuickSort(nums, 0, nums.size()-1);
        return nums;
    }
    void QuickSort(vector<int>& nums, int left, int right) {
        if(left >= right) 
            return;
        int pivot = nums[rand()%(right-left+1)+left];
        int l = left-1, r = right+1;    // 左右指针初始指向边界外侧
        while(l < r) {
            while(nums[++l] < pivot);   // 每次先移动指针，再做判断，这样不会陷入循环
            while(nums[--r] > pivot);
            if(l < r) swap(nums[l], nums[r]);
        }
        QuickSort(nums, left, r);
        QuickSort(nums, r+1, right);
    }
};

代码（二刷看解析）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        QuickSort(nums, 0, nums.size() - 1);
        return nums;
    }
    void QuickSort(vector<int>& nums, int left, int right) {
        if(left >= right)
            return; // 返回条件
        int pivot = nums[rand()%(right - left + 1) + left];
        int l = left - 1, r = right + 1;
        while(l < r) {
            while(nums[++l] < pivot);
            while(nums[--r] > pivot);
            if(l < r) swap(nums[l], nums[r]);
        }
        QuickSort(nums, left, r);
        QuickSort(nums, r+1, right);
    }
};

代码（8.31 三刷自解）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
    void quickSort(vector<int>& nums, int left, int right) {
        if(left >= right)
            return;
        int pivot = nums[rand()%(right-left+1)+left];
        int l = left-1, r = right+1;
        while(l < r) {
            while(nums[++l] < pivot);
            while(nums[--r] > pivot);
            if(l < r)
                swap(nums[l], nums[r]);
        }
        quickSort(nums, left, r);
        quickSort(nums, r+1, right);
    }
};

代码（9.21 四刷自解）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
    void quickSort(vector<int>& nums, int l, int r) {
        if(l >= r)
            return;
        int pivot = nums[rand()%(r-l)+l];
        int left = l-1, right = r+1;
        while(left < right) {
            while(nums[++left] < pivot);
            while(nums[--right] > pivot);
            if(left < right) 
                swap(nums[left], nums[right]);
        }
        quickSort(nums, l, right);
        quickSort(nums, right+1, r);
    }
};

堆排序

  • 稳定性：不稳定
  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(1)
    在这里插入图片描述
  • 算法步骤
    1. 建立堆
    2. 把堆首（最大值）和堆尾互换
    3. 把堆的尺寸减一，重新构建堆，目的是把新的数组顶端数据调整到相应位置
    4. 重复步骤2和3，直到堆的尺寸为1

代码（首刷调试看解析）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        buildHeap(nums);
        int n = nums.size();
        for(int i = n-1; i > 0; i--) {
            swap(nums[0], nums[i]);
            heapAdjust(nums, 0, i);
        }
        return nums;
    }
    void buildHeap(vector<int>& nums) {
        int n = nums.size();
        for(int i = (n-1)/2; i >= 0; i--) { // 从下往上建立
            heapAdjust(nums, i, n);
        }
    }
    void heapAdjust(vector<int>& nums, int i, int n) {  // 调整为从上往下
        while(i*2+1 < n) {  // n为个数,当还有儿子的时候
            int child = i*2+1;
            if(child+1 < n && nums[child+1] > nums[child])
                child++;
            if(nums[child] > nums[i]) {
                swap(nums[child], nums[i]);
                i = child;
            } else {
                break;
            }
        }
    }
};

代码（二刷调试看解析）

三个注意点：

  1. heapAdjust的参数需要指明长度，因为最后面的都是已经排好序的
  2. 一开始构建堆的时候，for需要i>=0
  3. 堆排序时heapAdjust的参数：长度需要-1
class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        buildHeap(nums);
        for(int i = nums.size() - 1; i; i--) {
            swap(nums[0], nums[i]);
            heapAdjust(nums, 0, i-1);
        }
        return nums;
    }
    void buildHeap(vector<int>& nums) {
        int n = nums.size() - 1;
        for(int i = n/2; i >= 0; i--) {
            heapAdjust(nums, i, n);
        }
    }
    void heapAdjust(vector<int>& nums, int k, int len) {
        // int n = nums.size() - 1;
        for(int i = k*2+1; i <= len; i = i*2+1) {
            if(i+1 <= len && nums[i+1] > nums[i]) i++;
            if(nums[i] > nums[k]) {
                swap(nums[k], nums[i]);
                k = i;
            } else {
                break;
            }
        }
    }
};

代码（9.1 三刷自解）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        buildHeap(nums);
        int n = nums.size();
        for(int i = 0; i < n; i++) {
            swap(nums[0], nums[n-i-1]);
            heapAdjust(nums, 0, n-i-2);
        }
        return nums;
    }
    void buildHeap(vector<int>& nums) {
        int n = nums.size();
        for(int i = (n-1)/2; i >= 0; i--) {
            heapAdjust(nums, i, n-1);
        }
    }
    void heapAdjust(vector<int>& nums, int k, int n) {
        for(int i = k*2+1; i <= n; i = i*2+1) {
            if(i+1 <= n && nums[i+1] > nums[i])
                i++;
            if(nums[k] < nums[i]) {
                swap(nums[k], nums[i]);
                k = i;
            } else {
                break;
            }
        }
    }
};

代码（9.21 四刷自解）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
       int n = nums.size()-1;
       biuldHeap(nums);
       for(int i = n; i; i--) {
           swap(nums[i], nums[0]);
           heapAdjust(nums, i-1, 0);
       }
       return nums;
    }
    void biuldHeap(vector<int>& nums) {
        int n = nums.size()-1;
        for(int i = (n-1)/2; i >= 0; i--)
            heapAdjust(nums, n, i);
    }
    void heapAdjust(vector<int>& nums, int n, int k) {
        for(int i = k*2+1; i <= n; i = i*2+1) {
            if(i+1 <= n && nums[i+1] > nums[i])
                i++;
            if(nums[k] < nums[i]) {
                swap(nums[k], nums[i]);
                k = i;
            }
        }
    }
};

计数排序

时间复杂度：O(n+k)
空间复杂度：O(k)
稳定性：稳定

先假设 20 个数列为：{9, 3, 5, 4, 9, 1, 2, 7, 8，1，3, 6, 5, 3, 4, 0, 10, 9, 7, 9}。

让我们先遍历这个无序的随机数组，找出最大值为 10 和最小值为 0。这样我们对应的计数范围将是 0 ~ 10。然后每一个整数按照其值对号入座，对应数组下标的元素进行加1操作。
在这里插入图片描述
eg：大小写都包含的字符串转成全小写且排好序

void countingSort(std::vector<int>& arr) {
    int maxVal = *max_element(arr.begin(), arr.end()); // 获取最大值

    // 创建计数数组并初始化为0
    std::vector<int> count(maxVal + 1, 0);

    // 计算每个元素的出现次数
    for (int val : arr) {
        count[val]++;
    }

    // 重新生成排序后的数组
    int index = 0;
    for (int i = 0; i <= maxVal; i++) {
        for (int j = 0; j < count[i]; j++) {
            arr[index++] = i;
        }
    }
}
JehanRio
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode刷题 十大排序算法 C++实现（剑指offer5个）
yiluyouni19的博客
03-06 417
目录 十大经典排序算法 十大经典排序算法 常考排序 快速排序（Quick Sort） 归并排序（Merge Sort） 堆排序（Heap Sort） 二叉堆 优先队列 堆排序 普通排序算法 1、冒泡排序 鸡尾酒排序 8、计数排序（Counting Sort） 9、桶排序（Bucket Sort） 2、选择排序（Selection Sort） 3、插入排序（Insertion Sort） 4、希尔排序（Shell Sort） 10、基数排序（Radix Sort） 十大.
php-leetcode题解之删除排序数组中的重复项.zip
06-11
在本压缩包“php-leetcode题解之删除排序数组中的重复项.zip”中，主要包含的是使用PHP解决LeetCode上的一道经典问题——删除排序数组中的重复项。这道题目要求我们在保持数组排序的前提下，移除重复的元素，只保留...
leetcode 排序数组 十大排序算法实现
qq_41918762的博客
04-01 1245
leetcode912. 排序数组 十大排序算法实现 文章目录leetcode912. 排序数组 十大排序算法实现[912. 排序数组](https://leetcode-cn.com/problems/sort-an-array/)题目描述排序算法分类算法复杂度Solution Ideabubble sort(冒泡排序)Selection sort(选择排序)Insertion sort(插入排...
十大排序算法（C++）LeetCode题解 912.排序数组
TheCleaner7的博客
08-22 519
题目：     给你一个整数数组nums，请你将该数组升序排列。     注：有关排序算法的具体讲解解析，初学者可观看LeetCode官方的Leetbook《排序算法全解析》 一、时间复杂度O(n²)的排序算法     由于时间复杂度太高，下述三个排序方法提交LeetCode均会超时。 冒泡排序，空间复杂度O(1)     冒泡排序是最基本的排序算法
LeetCode笔记——912.排序数组
吾门的博客
02-13 312
912.排序数组
每日刷题——leetcode912.排序数组
weixin_43839651的博客
03-31 230
题目描述：给定一个数组nums，将数组升序排序。 示例： 输入：[5，2，3，1] 输出：[1，2，3，5] 解法一：插入排序 思想：从数组的第二个数开始与前一个数进行比较，如果后面的数比前面的数小，则进行交换。算法复杂度为O(n2n^2n2) 题解： def sortArray(self, nums): for i in range(1,len(nums)): for j in rang...
leetcode做题日记——912. 排序数组
weixin_39072831的博客
01-10 358
请你将该数组升序排列。1.选择排序（超时）
【数组排序——快速排序】Leetcode 912. 排序数组
享受当下
03-09 410
Leetcode 912. 排序数组（快速排序实现） 题目描述：给你一个整数数组 nums，请你将该数组升序排列。 基本思想：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。 中心思想：将比枢轴值小的放在左边，比枢轴值大的放在右边。 时间复杂度： 最优的情况下：复杂度为O(nlogn)， 此时每次所选的枢轴值都能将待排序列均匀的划分成两部分。 最坏的情况下：复杂度为O(n^2)，此时待排序列为正序
Leetcode——912. 排序数组
qq_37724465的博客
03-31 93
题目传送门 介绍两种方法，第一种就是直接调库，第二种是希尔排序。 class Solution { public: vector<int> sortArray(vector<int>& nums) { sort(nums.begin(),nums.end()); return nums; } }; class...
【数组排序——归并排序】Leetcode 912. 排序数组
享受当下
03-10 179
Leetcode 912. 排序数组（归并排序） 题目描述：给你一个整数数组 nums，请你将该数组升序排列。 基本思想：它的原理是将要排序的数组先找中心点mid=(start+end)/2，然后分成2半，左半部分和右半部分，然后继续对左半部分和右半部分同样找中心分成两半，直到无法再分，此时左半部分和右半部分都是一个单值了；然后开始归并（过程中进行排序），将这两个单值合并成一个有序的两个值的序列，再向上依次归并，就是一开始分成2半的逆过程（归并过程中会进行排序），最后全部归并完，就会得到排好序的序列了。
【数组排序——堆排序】Leetcode 912. 排序数组
享受当下
03-08 371
Leetcode 912. 排序数组（堆排序实现） 题目描述：给你一个整数数组 nums，请你将该数组升序排列。 补充小知识：堆就是一个完全二叉树 堆排序的基本思想：将要排列的数组构建为一个大顶堆（升序的话），这一过程可以在原数组中进行；然后将堆顶元素（也就是最大值）和堆数组末尾元素交换，此时末尾就是最大值；再将数组中前n-1个元素重新调整为大顶堆，此时的堆顶就是原n个元素的数组的次大值。如此反复进行，就会得到一个升序排列的数组。 中心思想：将每棵子树调整为大顶堆（升序的话） 时间复杂度： 初始构建堆时
php-leetcode题解之按奇偶排序数组2.zip
06-07
接着，我们来讨论这个问题的核心——按奇偶性排序数组。这个问题的解决方案可以使用多种方法，但在这里，我们主要关注PHP的实现。PHP是一种广泛用于Web开发的脚本语言，它支持丰富的数组操作函数，使得解决此类问题...
python-leetcode面试题解之第33题搜索旋转排序数组-python题解.zip
03-12
在本压缩包中，我们关注的是一个Python编程与算法相关的主题，特别针对LeetCode平台上的第33题——"搜索旋转排序数组"。这是一道常见的面试题，旨在考察候选人在处理数组问题时的逻辑思维和算法应用能力，特别是在...
Leetcode、剑指Offer——名企面试官精讲典型编程题.zip
02-04
《LeetCode与剑指Offer——名企面试官精讲典型编程题》是一个针对程序员面试准备的重要资源包。它包含了来自LeetCode平台以及《剑指Offer》书籍中的经典编程题目，这些题目广泛应用于各大知名企业的面试过程中，是...
算法和数据结构练习（Leetcode）.zip
01-05
《算法和数据结构练习——基于LeetCode平台》 在计算机科学与信息技术领域，算法和数据结构是基础且至关重要的组成部分。LeetCode是一个在线平台，它提供了丰富的编程挑战，特别是针对算法和数据结构的实践题目，...
leetcode--恢复二叉搜索树
最新发布
liulanba的博客
07-09 301
给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树。示例 1：输入：root = [1,3,null,null,2]输出：[3,1,null,null,2]解释：3 不能是 1 的左孩子，因为 3 > 1。交换 1 和 3 使二叉搜索树有效。示例 2：输入：root = [3,1,4,null,null,2]输出：[2,1,4,null,null,3]解释：2 不能在 3 的右子树中，因为 2 < 3。
刷leetcode中常用且有效的方法总结
路有瑶台的博客
07-04 302
刷题的时候经常会因为不知道一个方法多写很多行代码，既然有trick为何不用！你问我眼中为何常含泪水，因为我忘记方法忘的深沉。join（）是 Python 中的一个字符串方法，它用于将序列（如列表、元组、集合等，但集合需要首先转换为列表或其他有序序列，因为集合是无序的）中的元素以指定的字符连接生成一个新的字符串。方法来更新计数器中的计数。可以传递另一个可迭代对象或者另一个。提供了一个快速简单的方式来统计哈希对象在集合中出现的次数。
力扣考研经典题 反转链表
qq_55751640的博客
07-07 310
头插法： 不断的将cur指针所指向的节点放到头节点之前，然后头节点指向cur节点，因为最后返回的是head.next。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 284
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
leetcode questions.pdf
10-16
SingleElementinaSortedArray是寻找排序数组中唯一出现一次的元素，而CoinChange2则是计算用不同面值硬币组成特定金额的组合数。" 首先，我们来详细讨论第一个问题——SingleElementinaSortedArray。这个问题的目标...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值