手撕排序算法：快速排序

快速排序(Quick Sort)是一种分而治之的排序算法。它通过选择一个基准元素，将数组分为两部分，一部分的元素都比基准小，另一部分的元素都比基准大，然后对这两部分再进行快速排序，最终得到有序的数组。

1.算法思想

第一步、选择基准元素：从数组中选择一个元素作为基准。
第二步、分割数组：将比基准小的元素放在基准的左边，比基准大的元素放在基准的右边。
第三步、递归排序：对基准左边和右边的子数组分别进行快速排序。
重复步骤一至三，直到子数组的长度为1或0。

2.算法分析

2.1时间复杂度

最优情况：当每次选择的基准元素正好将数组分成两等分时，快速排序的时间复杂度是
o(nlogn)。
-最坏情况：当每次选择的基准元素是最大或最小元素时，快速排序的时间复杂度是O(n^ 2)
平均情况：在平均情况下，快速排序的时间复杂度也是O(nlogn)。

2.2空间复杂度

快速排序的空间复杂度是O(log),因为在递归调用中需要使用栈来存储中间结果。这意味着
在排序过程中，最多需要O(log)的额外空间来保存递归调用的栈帧。

3.算法优缺点

3.1算法的优点

1.高效性：快速排序在大多数情况下具有较高的排序效率。
2.适应性：适用于各种数据类型的排序。
3.原地排序：不需要额外的存储空间。

3.2算法的缺点

1.最坏情况性能：在最坏情况下，快速排序的时间复杂度可能退化为O(2)。
2.不稳定性：快速排序可能会破坏排序的稳定性，即相同元素的相对顺序可能会改变。

4.优化方案

1.选择合适的基准：选择合适的基准元素可以提高算法的性能。
2.三数取中：通过选择中间元素作为基准，可以避免最坏情况的出现。
3.分区的改进：可以使用双指针或其他方法来改进分区的过程，提高算法的效率。
4.小数组使用插入排序：对于小数组，可以直接使用插入排序，避免不必要的递归。

5.代码描述（C语言）

void Swap(int* a,int* b) {  
    int temp = *a;  
    *a = *b;  
    *b = temp;  
}  
// 1 ,3 ,4 ,2 ,6 ,5 ,9 ,7 ,8  
//         indx  
// 2 .3 .4 .1 .6 .5 .9 .7 .8  
// i                       j  
int Partition(int* num,int low,int high) {  
    int indx = low + rand()%(high - low + 1);  
    Swap(&num[indx],&num[0]);  
    int i = low;  
    int j = high;  
    int x = num[i];  
    while (i < j) {  
        while (i < j && num[j] > x) {  
            j--;  
        }  
        if(i < j) {  
            Swap(&num[i],&num[j]);  
            i++;  
        }  
        while (i < j && num[j] < x) {  
            i++;  
        }  
        if (i < j) {  
            Swap(&num[i].&num[j]) {  
                j--;  
            }  
        }  
    }  
    num[i] = x;  
    return i;  
}  
//num[low:high]  
void QuickSort(int num[],int low,int high) {  
    if(high >= low) {  
        return;  
    }  
    int pi = Partition(num,low,high);  
    QuickSort(num,low,pi - 1);  
    QuickSort(num,pi + 1, high);  
}

6.实战

6.1力扣217 存在重复元素

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false。

void Swap(int* a, int* b) {  
  
        int temp = *a;  
  
        *a = *b;  
  
        *b = temp;  
  
}  
  
    
int Partition(int* num, int low, int high) {  
  
  
        int indx = low + rand() % (high - low + 1);  
  
        Swap(&num[indx], &num[low]);  
  
        int i = low;  
  
        int j = high;  
  
        int x = num[low]; // 随机选择的基准元素  
  
        while (i < j) {  
  
                while (i < j && num[j] >= x) {  
  
                        j--;  
  
                }  
  
                if (i < j) {  
  
                        Swap(&num[i], &num[j]);  
  
                        i++;  
  
                }  
  
                while (i < j && num[i] <= x) {  
  
                        i++;  
  
                }  
  
                if (i < j) {  
  
                        Swap(&num[i], &num[j]);  
  
                        j--;  
  
                }  
  
        }  
  
        Swap(&num[low], &num[i]); // 将基准元素放到正确的位置  
  
        return i;  
  
}  
  
    
void QuickSort(int num[], int low, int high) {  
  
        if (high <= low) {  
  
                return;  
  
        }  
  
        int pi = Partition(num, low, high);  
  
        QuickSort(num, low, pi - 1);  
  
        QuickSort(num, pi + 1, high);  
  
}

  

bool containsDuplicate(int* num, int numsSize) {

    QuickSort(num, 0, numsSize - 1);

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

        if (num[i] == num[i - 1]) {

            return true;

        }

    }

    return false;

}

6.2 力扣169多数元素

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

void Swap(int* a,int* b) {    
int temp = *a;    
    *a = *b;    
    *b = temp;    
}  // 1 ,3 ,4 ,2 ,6 ,5 ,9 ,7 ,8  //         indx  // 2 .3 .4 .1 .6 .5 .9 .7 .8  // i                       j  int Partition(int* num,int low,int high) {    
int indx = low + rand()%(high - low + 1);    
    Swap(&num[indx],&num[0]);    
    int i = low;    
    int j = high;    
    int x = num[i];    
    while (i < j) {    
while (i < j && num[j] > x) {    
j--;    
        }    
if(i < j) {    
Swap(&num[i],&num[j]);    
            i++;    
        }    
while (i < j && num[j] < x) {    
i++;    
        }    
if (i < j) {    
Swap(&num[i],&num[j]);    
            j--;     
        }    
}    
num[i] = x;    
    return i;    
}  //num[low:high]  void QuickSort(int num[],int low,int high) {    
if(high >= low) {    
return;    
    }    
int pi = Partition(num,low,high);    
    QuickSort(num,low,pi - 1);    
    QuickSort(num,pi + 1, high);    
}  
int majorityElement(int* nums, int numsSize) {  
    QuickSort(nums,0,numsSize - 1);  
    return nums[numsSize / 2];  
}