C++排序

选择排序：

首先是明确一些函数：然后是弄清楚每种排序算法的思路！

void swap(vector<int>a, int i, int j)
{
int t = a[i];
a[i] = a[j];
a[j] = t;
}

简单的交换数组中的两个元素的函数实现！

1.选择排序：使用下标总是从后面选择出当前最小的元素值，然后使用其的下标与当前的i的值位置的元素进行交换，记住i是最外层循环的值，所以在使用的时候必须将上线设定为：nums.size() -1的值，依次从当前的i的值后面的元素出发依次选择。选择最小的放在最前面

void sort(vector<int>nums) //选择排序
{
//总是先选择后再交换的，使用下标的值进行选择，然后进行交换！
int size = nums.size();
int min = 0;
for(int i=0; i< size -1; i++) {
int min = i;
for(int j = i+1; j < size; j++){
if(nums[j] > nums[min]) {
min = j;
}
}
int cnt = nums[min];
nums[min] = nums[i];
nums[i] = cnt;
}
}

2.冒泡排序：思想是每一次将列表中的最大值放到数组的最末端上，所以外部循环应该是逆序开始的，然后每次针对于前方的全部元素进行一个比较，只要是比后者大的就交换，最终最大的元素会浮现到最末端。额外使用一个标记判断当前是否有元素交换，否则代表已经为有序的直接返回。将当前最大的依次冒泡到最后

``void sort(vectornums) //冒泡排序{int size = nums.size();bool isSorted = false;for(int i = size -1 ; i >=0 && !isSorted; i–){isSorted = true;for(int j = 0; j < i; j++){if(nums[j+1] < nums[j]) {isSorted =false;swap(nums[j+1], nums[j]);}}}}

3.插入排序，总是将当前新来的元素插入到之前已经有序的序列中，所以外层循环应该从1开始，内存循环应该是从当前i=1的开始，然后去判断是否小于之前的元素则交换否则就是对应的位置。

``void sort(vectornums){for(int i =1; i <nums.size();i++){for(int j=i; j>0&&(nums[j]<nums[j-1]);j–){swap(nums[j], nums[j-1]);}}}

4.希尔排序：因为直接插入排序的方式速度较慢，而且只是交换相邻的元素，每次只能减少逆序数量为1.

int N = nums.length;
int h = 1;

while (h < N / 3) {
h = 3 * h + 1; // 1, 4, 13, 40, ...
}

while (h >= 1) {
for (int i = h; i < N; i++) {
for (int j = i; j >= h && less(nums[j], nums[j - h]); j -= h) {
swap(nums, j, j - h);
}
}
h = h / 3;
}

5.归并排序：分治法实现的，先分成为一个个小的然后依次进行排序，当只有一个元素的时候就是有序的状态了，然后将对应的元素进行合并起来即可。使用递归的方式完成。

``void sort(vector&nums, int L, int R){if(L == R){return;}int mid = L + ((R- L) /2);sort(nums, L, mid);sort(nums, mid+1, R);merge(nums, L, mid, R);}

void merge(vector<int>&nums, int L, int mid, int R)
{ //合并的代码
vector<int> temp(R - L +1);
int i = 0;
int p1 = L;
int p2 =mid + 1;
while(p1 <= mid && p2 <= R) {
temp[i++] = nums[p1] < nums[p2] ? nums[p1++] : nums[p2++];
}
while(p1 <= mid) {
temp[i++] = nums[p1++];
}
while(p2 <= R) {
temp[i++] = nums[p2++];
}
for(int i=0; i < temp.size(); i++) {
nums[L + i] = temp[i];
}
}

可以是自顶向下的归并排序：将原先的大数组分成两个小数组处理，每次都可以将问题对半分成两个子问题。

快速排序：是使用一个数来将数组进行切分的方法，将原先的数组进行分成两个部分的方式！总是在后面找一个比当前数字大的，再从前面找一个比当前数字小的。直到结束。总是将找到的元素跟之前的标杆值进行替换的，依次循环进行！low < high作为每个终止条件不可以忘记！

void quickSort(vector<int>&nums, int low, int high)
{
if(low <high) {
int index = getIndex(nums, low, high);
quickSort(nums, low, index -1);
quickSort(nums, index + 1, high);
}
}
int getIndex(vector<int>&nums, int low, int high)
{
int temp = nums[low];
while(low < high) {
while(low<high && nums[high] >= temp) {
high--;
}
nums[low] = nums[high];
while(low < high && nums[low] <= temp) {
low++;
}
nums[high] = nums[low];
}
nums[low] = temp;
return low;
}

1. 堆

堆中某个节点的值总是大于等于或小于等于其子节点的值，并且堆是一颗完全二叉树。堆可以用数组来表示，这是因为堆是完全二叉树，而完全二叉树很容易就存储在数组中。位置 k 的节点的父节点位置为 k/2，而它的两个子节点的位置分别为 2k 和 2k+1。这里不使用数组索引为 0 的位置，是为了更清晰地描述节点的位置关系。

void swap(vector<int>&arr, int a, int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
void sort(vector<int>&arr)
{ //构建大顶堆
for(int i=arr.size()/2-1;i>=0;--i){
adjustHeap(arr,i,arr.size());
}
//调整结构+交换堆顶和莫为元素
for (int j=arr.size()-1;j>0;j--){
swap(arr,0,j);
adjustHeap(arr,0,j);
}
}
void adjustHeap(vector<int>&arr, int i, int length)
{
int temp = arr[i];
for(int k = i*2+1; k < length; k = k*2+1){
if(k+1 < length && arr[k] < arr[k+1]) {
k++;
}
if(arr[k] > temp) {
arr[i] = arr[k];
i =k;
} else{
break;
}
}
arr[i] = temp;
}

快希选堆不稳定，快希归堆速度快。