Leetcode101_排序算法_912排序数组

最新推荐文章于 2024-06-20 20:23:55 发布

诶你爱我吗

最新推荐文章于 2024-06-20 20:23:55 发布

阅读量108

点赞数

分类专栏： LeetCode 文章标签：排序算法算法数据结构

本文链接：https://blog.youkuaiyun.com/weixin_44244154/article/details/125835018

版权

LeetCode 专栏收录该内容

60 篇文章

订阅专栏

本文详细介绍了七大经典排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。每种排序算法都有清晰的实现代码和工作原理说明，帮助读者深入理解各种排序算法的优缺点及其应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

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

2.选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

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

3.插入排序

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

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

4.快速排序

class Solution {
public:
    int sort(vector<int>& nums,int left,int right){
        int privot = rand()%(right - left + 1) + left;
        int tmp = nums[privot];
        nums[privot] = nums[left];
        nums[left] = tmp;
        while(left < right){
            while(left < right && nums[right] >= tmp)
                right--;
            nums[left] = nums[right];
            while(left < right && nums[left] <= tmp)
                left++;
            nums[right] = nums[left];
        }
        nums[left] = tmp;
        return left;
    }
    void quick_sort(vector<int>& nums,int left,int right){
        if(left >= right) return;
        int mid = sort(nums,left,right);
        quick_sort(nums,left,mid - 1);
        quick_sort(nums,mid + 1,right);
    }
    vector<int> sortArray(vector<int>& nums) {
       quick_sort(nums,0,nums.size() - 1);
       return nums;
    }
};

5.归并排序

class Solution {
public:
    void mergesort(vector<int>& nums,int left,int right,vector<int>& buffer){
        if(left == right) return;
        int mid = left + (right - left)/2;
        mergesort(nums,left,mid,buffer);
        mergesort(nums,mid + 1,right,buffer);
        int p = left,q = mid + 1;
        int pos = p;
        while(p <= mid && q <= right){
            if(nums[p] <= nums[q]) buffer[pos++] = nums[p++];
            else buffer[pos++] = nums[q++];
        }
        while(p <= mid) buffer[pos++] = nums[p++];
        while(q <= right) buffer[pos++] = nums[q++];
        for(int i = left;i <= right;i++)
            nums[i] = buffer[i];
    }
    vector<int> sortArray(vector<int>& nums) {
       vector<int> buffer(nums.size());
       mergesort(nums,0,nums.size() - 1,buffer);
       return nums;
    }
};

6.堆排序

参考视频，讲的真好

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