面试手撕快排
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(logn)
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]];
}
}
}
}
