手撕快排 C++

面试手撕快排

图解快排

class Solution {
public:
    void quickSort(vector<int>& nums, int start, int end){
        // 边界条件
        if(start >= end)
            return;
        // 随机选取一个元素当哨兵
        int l = start, r = end, cur = rand() % (end - start + 1) + start;
        swap(nums[l], nums[cur]);
        int guard = nums[l];
        while(l < r){
            // 右边的向左直到找到第一个比guard小的
            while(l < r && nums[r] >= guard) r--;
            // 左边向右找
            while(l < r && nums[l] <= guard) l++;
            if(l < r){
                swap(nums[l], nums[r]);
            }
        }
        swap(nums[start], nums[l]);
        quickSort(nums, start, l-1);
        quickSort(nums, r+1, end);
    }

    vector<int> sortArray(vector<int>& nums) {
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
};

/

#include<iostream>
#include<vector>
#include <algorithm>
using namespace std;

//快速排序：以左节点为锚点，
void quickSort(vector<int>&nums, int startIndex, int endIndex) {
        if (startIndex >= endIndex) return;
        
        int x = rand() % (endIndex - startIndex + 1) + startIndex; // 基于随机的原则
        swap(nums[startIndex], nums[x]);
        int firstNum = nums[startIndex];
        
        int l = startIndex, r = endIndex;
        while (l < r) {
            // 从后往前走，将比第一个小的移到前面
            while (l < r && nums[r] >= firstNum) --r;
            if (l < r) {
                nums[l] = nums[r];
            }
            // 从前往后走，将比第一个大的移到后面
            while (l < r && nums[l] <= firstNum) ++l;
            if (l < r) {
                nums[r] = nums[l];
            }
        }
        nums[l] = firstNum;
        // 自顶向下
        quickSort(nums, startIndex, l - 1);
        quickSort(nums, l + 1, endIndex);
    }

int main() {
    vector<int> vec = {49,38,65,97,76,13,27,49};
    quickSort(vec, 0, vec.size()-1);
    for(auto v:vec) cout<<v<<endl;
    return 0;
}

数组中第K大的元素力扣215

快排衍生出的快速选择法：在快排算法的基础上，由于题目只要求我们找出第K大的数，而快排，每次划分都可以确定一个元素的最终位置，根据这一特性，我们便可解决本题。在找第K大数过程中，我们无需对整个数组排序，只需要在每次划分中查看本次划分后的枢纽元素是否是第K大数，如果划分得到的枢纽元素正好就是我们需要的第K大数，即mid == nums.size() - k，就直接返回该元素；否则，如果 mid 比目标下标小，就递归右子区间，否则递归左子区间。这样就可以把原来递归两个区间变成只递归一个区间，提高了时间效率。
时间复杂度:O(N)
空间复杂度:O(log⁡n)

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        srand(time(0));
        k = k - 1;
        int start = 0, end = nums.size()-1;
        while(start < end){
            int l = start, r = end;
            swap(nums[start], nums[rand()%(end - start + 1) + start]);
            int pivot = nums[start];
            while(l < r){
                while((l < r) && (pivot>=nums[r])) r--;
                while((l < r) && (nums[l]>=pivot)) l++;
                if (l < r) swap(nums[l], nums[r]);
            }
            swap(nums[start], nums[l]);
            if(k<=l) end = l-1;
            if(l<=k) start = l+1;
        }
        return nums[k];
    }
};

别人写的八大排序

1. 插入排序

 //insertSort 每次将当前元素插入到前面已经排好序的元素中
    public static void insertSort(int[] a){
        int N = a.length;
        for (int i = 0; i < N; i++) {
            int temp = a[i];
            int j = i;
            for (; j > 0 && a[j-1] > temp; j--) {
                 a[j] = a[j-1];
            }
            a[j] = temp;
        }
    }

2.选择排序

//selectSort 每次将当前元素替换为后面最小的元素
       public static void selectSort(int [] nums){
       int N = nums.length;
       for(int i = 0;  i < N;  i ++){
           int min = i;
           for(int j = i + 1; j < N; j ++){
               if(nums[j] < nums[min]) min = j;
        
           }
               int t = nums[i];
               nums[i] = nums[min];
               nums[min] = t;
       }
   } 

3. 希尔排序

 //shellSort 将数组分组，并不断减小分组的步长直到为1，每次分组均进行插入排序
    public static void shellSort(int[] a){
        for (int step = a.length/2; step > 0; step/=2) {
            for (int i = step; i < a.length; i++) {
                int temp = a[i];
                int j = i;
                for (; j >= step && a[j-step] > temp ; j-=step) {
                    a[j] = a[j-step];
                }
                a[j] = temp;
            }
        }
    }

4. 递归排序

//mergeSort 递归 对两个有序节点序列进行合并来实现排序，分治思想

    //分解的方法
    public void mergeSort(int[] arr,int left,int right){
        //如果左边索引小于右边就可以一直分，l=r时，就是分到只剩一个数了
        if(left<right){
            int mid = (left + right) / 2;//左少右多
            //向左递归分解
            mergeSort(arr,left,mid);
            //向右递归分解
            mergeSort(arr,mid+1,right);
            //合并
            merge(arr,left,mid,right);
        }
    }

    //合并的方法
    /**
     *
     * @param arr 待排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边结束索引
     * @return
     */
    public void merge(int[] arr, int left,int mid,int right) {
         int i = left;
         int j = mid +1;
         int[] temp = new int[right-left+1];//中转数组
         int t = 0;//temp数组的当前索引

        //合并数组，比较找最大
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j])temp[t++] = arr[i++];
            else temp[t++] = arr[j++];
        }
        while (i<=mid) temp[t++] = arr[i++];
        while (j<=right) temp[t++] = arr[j++];

        //将temp数组拷贝到arr数组，并不是每次都拷贝所有
        t = 0;
        while (left<=right) arr[left++] = temp[t++];
    }

5.堆排序

//heapSort 构建大顶堆或者小顶堆，将堆顶元素与堆尾元素交换后再调整，如此反复
    public void heapSort(int[] arr){
        //构建大顶堆 k为最后一个非叶子节点，逐渐-1，即从下向上，从右往左
        for(int k = arr.length/2 - 1;k>=0;k--){
            adjustHeap(arr,k,arr.length);
        }

        //排序 交换+调整
        int temp =0;
        for (int i = arr.length-1; i >= 0; i--) {
            temp =arr [0];
            arr[0] = arr[i];
            arr[i] = temp;
            adjustHeap(arr,0,i);
        }
    }

    /**
     *
     * @param arr 待调整数组
     * @param i 非叶子节点在数组中的索引
     * @param length 对多少个元素进行调整
     */
    public void adjustHeap(int[] arr,int i,int length){
        int temp = arr[i];//取出当前非叶子叶结点的值
        //k为当前节点的左子节点
        for(int k = 2*i+1;k<length;k=2*k+1){
           if(k+1<length && arr[k+1]>arr[k]){//右子节点大于左子节点
               k++;//k指向右子节点
           }
           if(arr[k]>temp){//如果当前节点大于父节点就交换
                arr[i] = arr[k];
                i =k;//!!!!!!精髓，因为该子节点值大小发生了改变，可能会使其子根堆发生改变，索引要调整其子根堆
           }else {
               break;//否则直接退出，因为其后面的节点一定满足堆定义
           }
        }
        arr[i] = temp;
    }

6. 快速排序

//quickSort 每次选择一个元素并且将整个数组以这个元素分为两部分，小于该元素的放右边，大于该元素的放左边
    public void quickSort(int[] arr,int l,int r){
        if(l<r){ //跳出递归的条件
            //partition就是划分操作，将arr划分成满足条件的两个子表
            int pivotpos = partition(arr,l,r);
            //依次对左右两个子表进行递归排序
            quickSort(arr,l,pivotpos);
            quickSort(arr,pivotpos+1,r);
        }
    }

    public int partition(int[] arr,int l,int r){
        //以当前数组的最后一个元素作为中枢pivot，进行划分
        int pivot = arr[r];
        while (l<r){
           while (l<r && arr[l]<pivot) l++;
            arr[r] = arr[l];//将比中枢值大的移动到右端r处 由于r处为中枢或者该位置值已经被替换到l处，所以直接可以替换
           while (l<r && arr[r]>=pivot) r--;
            arr[l] = arr[r];//将比中枢值小的移动到左端l处 由于前面l处的值已经换到r处，所以该位置值也可以替换掉
        }
        //l==r时，重合，这个位置就是中枢的最终位置
        arr[l] = pivot;
        //返回存放中枢的最终位置
        return l;
    }

7. 冒泡排序

 //bubbleSort n-1遍历，每次找到未排序数组的最大值
    public void bubbleSort(int[] arr){
        for (int i = arr.length-1; i >= 0; i--) {
            for (int j = 0; j < i; j++) {
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

8. 序号排序

//radixSort 按位数进行排序，借助桶bucket进行分配与收集
    public void radixSort(int[] arr){
        int max = 0;
        for (int i : arr) {
            if(i>max) max = i;
        }
        int count = (max+"").length();

        for (int i = 1; i <= count; i++) {

            //分配
            int[][] bucket = new int[10][arr.length];
            //bucketCount用于统计该桶中元素的数量
            int[] bucketCount = new int[10];
            for (int value : arr) {
                bucket[value % (10 * i)][bucketCount[value % (10 * i)]++] = value;
            }

            //收集
            int k = 0;
            for (int j = 0; j < 10; j++) {
                //如果桶中有数据，放入数组
                if(bucketCount[j]!=0) {
                    //循环该桶，取出元素到arr中，每取一个元素，桶中元素-1
                    while (bucketCount[j]!=0) arr[k++] = bucket[j][--bucketCount[j]];
                }
            }
        }
    }