常见的几种排序：
文章目录
1.插入排序 n^2 最好 n
看这一个数组，先考虑一般情况：即在中间时候的插入一个值 ，对其进行排序
此时：需要往前依次与数组中的值比较，比6大的值需要往后移动，直到出现第一个小于6的值，在此时往后移动数据可能覆盖到当前的6，就比如此处的9往后移动，因此需要保存一下需要插入排序的值
//单趟的插入排序
int end;
//保存一下需要插入排序的数据，防止往后移动时被覆盖
int tmp = a[end + 1];
while (end >= 0)
{
//值大就往后挪动，否则跳出挪动，直接放值
if (tmp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tmp;
为什么控制循环的条件是end>=0?
因为：假如插入的数据为0；那么就会将该数组的数据全部向后移动一个位置，到最后的时候，end就变为了-1；此时就应该插入到第一个位置 即a[0]；而此时也满足插入的位置a[end+1]
此时，仅仅模拟了一个数的插入，若让一个数组排序时，需要外套一个循环，让end从第0个位置开始，此时tmp保存end+1此时为0+1=1，即让数组第二个位置向前插入排序。最后到n-1结束，因为 需要保证下标 end+1<n防止数组越界
void InsertSort(int* a, int n)//时刻注意n与数组下标的关系
{
for (int i = 0; i < n - 1; i++)
{
//end被赋值，用i赋值，代表将数组依次插入排序
int end = i;
int tmp = a[end + 1];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
//别忘了
a[end + 1] = tmp;
}
}
2.希尔排序（插排plus）n^1.3
希尔排序是插入排序的升级版（每间隔为gap个的数据比较），而插入排序是希尔排序的特例（每次和前一个比较），此时先说结论，将插入排序的数据每一段距离（gap）比较，就是希尔排序了
希尔排序是让一个数组，相隔较远的距离的较小的数据快速挪动到前边，较大的数据快速挪动到最后边，这样叫做预排序，因为插入排序适合于那种数组的值相差不是很大的情况，而这样的预排序会让最后一次的插入排序的时间大大缩短，虽然看起来麻烦了，但是时间复杂度确实是减小了
for (int i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
希尔排序就是先将数组跳着插入排序一下，使其大致有顺序，有利于之后的插入排序
插入排序是间隔为1的排序，而希尔排序先将此数组相隔为gap的值插入排序一下，最后再来一次插入排序
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
//gap > 1 跳跃排序
//gap = 1 插入排序
gap = gap / 3 + 1;
//i < n - gap 防止 *1 处越界，因为是间隔着插入排序
for (int i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[end + gap]; //此处标记为 *1
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
//end-=gap 不用担心end 小于0
//与后边end+gap相互照应
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
可以看出，当gap==1的时候就是插入排序了
3.冒泡排序 n^2 最好 n
void BubbleSort(int* a, int n)
{
//此处控制 n个数，需要 n-1 趟次
for (int j = 0; j < n - 1 ; j++)
{
//用一个布尔值，来判断数组是否进行了 换位
//若未进行换位置（间接意思就是以及有序）
//则直接break出循环，不再继续循环比较
bool exchange = false;
//这是一趟，用来依次比较前后两个数 将其中的一个最值沉底
for (int i = 0; i < n - 1 - j ; i++)
{
if (a[i] > a[i + 1])
{
//交换函数，即将这两个数进行交换
Swap(&a[i], &a[i + 1]);
exchange = true;
}
}
if (exchange == false)
break;
}
}
4.堆排 n*logN
先向下调整建堆，然后将堆中的第一个值与最后一个值进行交换，然后再将第一个值向下调整建堆
void AdjustDown(int* a, int parent, int size)
{
int child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && a[child + 1] > a[child])
{
child++;
}
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int n)
{
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, i, n);
}
//end 两个作用，作为数组中的最后一个值进行交换
//同时也作为新堆的 size 总个数
int end = n - 1;
while (end > 0)
{
//此处将 a[0] 与 a[end] 进行交换后
//a[end] 在向下调整时，将不作为堆中的值
//end 同时也作为新堆的个数
Swap(&a[0], &a[end]);
AdjustDown(a, 0, end);
end--;
}
}
5.选择排序 n^2
每次遍历一遍数组，分别找出最大值和最小值并于首尾的值进行交换
void SelectSort(int *a,int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int mini = begin, maxi = begin;
//找小找大
for (int i = begin + 1; i <= end; i++)
{
if (a[i] < a[mini])
mini = i;
if (a[i] > a[maxi])
maxi = i;
}
//交换
swap(&a[begin], &a[mini]);
//防止最大数位于begin位置，于mini交换时被换走
if (maxi == begin)
maxi = mini;
swap(&a[end], &a[maxi]);
//循环的条件，直至找到中间位置
//如果是奇数个，最后一次时，begin++于end--处于同一位置，不需要排序了
//而且其他小数在其前，大数在其后，本身就已然有序
//如果是偶数，最后的情况是begin>end，循环跳出
begin++;
end--;
}
}
6.快排 n*logN 最坏n^2
首先先谈谈，数组的快排
快排就是一种二叉树前序遍历的思想，每趟的过程就是将一个数组的下标为0的位置的值（简介为key）排在一个合适的位置，让此位置之前的值全部小于key，大于key的值全部在其后，等于就无所谓了
然后找到key最后排的位置的下标（keyi），将此区间一分为2即[0,keyi-1] [keyi+1,n]然后采用前序的思想递归子问题
int _quicksort(int* a, int begin, int end)
{
int keyi = begin;
int prev = begin, cur = begin + 1;
while (cur <= end)
{
if (a[cur] < a[keyi] && ++prev != cur)
swap(a[cur], a[prev]);
cur++;
}
swap(a[prev], a[keyi]);
return prev;
}
void quicksort(int* a, int begin, int end)
{
if (begin >= end)
return;
int keyi = _quicksort(a, begin, end);
quicksort(a, begin, keyi - 1);
quicksort(a, keyi + 1, end);
}
控制递归终止的条件是，数组剩一个值，或者无值，此时跳出递归
看最后这个数组的每一个数值都在了一个合适的位置，就排序完成
可以看出递归的终止体条件为begin>=end
等于的情况是一个值，不需要排序了
大于的情况是无值，为什么会有小于情况呢？因为如果prev刚好在左右边界返回时，你接下来递归左右，左为prev时：传递的可是keyi-1（而此时begin可是keyi）,右为prev时：keyi+1作为下一个的begin（此时下一个的end是keyi）就会导致小于情况
接下来就是链表的排序：
链表排序和数组排序的思想一样，仍使用这种方法，只不够控制的是指针的移动（不再是下标），并且此方法是在能交换节点的值的情况才能使用，否则就要使用下边的归并链表排序
listnode* _quicksort(listnode* head, listnode* tail)
{
int key = head->_val;
listnode* prev = head;
listnode* cur = head->_next;
while (cur != tail)
{
if (cur->_val < key)
{
prev = prev->_next;
if (prev != cur)
{
swap(prev->_val, cur->_val);
}
}
cur = cur->_next;
}
swap(head->_val, prev->_val);
return prev;
}
void QuickSort(listnode* head,listnode* tail)
{
if (head == tail || head->_next == tail)
return;
listnode* keyP = _quicksort(head, tail);
QuickSort(head, keyP);
QuickSort(keyP->_next, tail);
}
在此，我小说三个注意点：
1.链表递归的条件是一个节点或者零个节点判断代码为head=tail为空 head->next=tail为一个
2.第二点就是子函数的while控制条件，因为数组排序时，传递的是keyi-1，所以有等号，而链表想找一个节点的前一个节点效率太低，干脆就传此节点，并且循环条件为 !=
3.最好对比两个快排，你可以发现有异曲同工之妙
7.归并排序 n*logN
顺序表的归并：
如果说快排是二叉树前序思想，那么归并排序便是二叉树后序思想；大体思想就是，将一个数组一分为二，而递归下去的继续二分，继续二分…直到剩一个数据时便返回上一递归的位置，然后将与其同时递归下来的另一个区间的数据，归并排序一下（就等价于两个有序表的排序罢了）此时仍是作为上一递归的一个子集，而同理另一子集也归并完成，继续将这两段区间归并一下，循环往复在最后时，此数组的左区间有序，右区间有序 ，再使用归并排序，此时数据已然有序
需要注意的点是：在两个区间归并时，可能会有覆盖问题，此时可以考虑开一个等长的数组就行辅助，映射出相对位置并最后拷贝回原数组
void _MergeSort(int* a, int begin, int end, int* tmp)
{
if (begin == end)
return;
int mid = (begin + end) / 2;
_MergeSort(a, begin, mid, tmp);
_MergeSort(a, mid + 1, end, tmp);
//两个有序表的和并（开始处）
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
//用j=begin来表示此区间相对a数组起始位置的偏移量
//即映射出相对位置即可，每一段排序完成，即数组排序完成
int j = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
//有序表合并（结束处）
//拷贝到原数组
memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}
此时控制递归终止的条件和快排不同，此时只需要判断beign==end就行，因为传入的是mid或者mid+1，而mid意味着是中间的数，mid+1最大（联系两个数的数组）也就是最后一个数的下标，不存在会越界的情况，但是如果你嫌麻烦，完全可以一视同仁，全记为beign>=end递归跳出
链表的归并排序
我首先提一点，链表归并排序是交换节点的做法，因为链表的插入删除效率比较高，而为什么数组需要开空间呢?因为你归并的时候可能会覆盖数据啊，如果你倒着归并，不开辅助数组也行，这里使用了以空间换时间
而反过来看链表，链表不存在覆盖问题，所以不需要开辅助链表，只需递归归并两个有序链表即可,再想一下，你交换节点，那么头节点就可能作为大值被换走，此时需要改变头节点，当然你可以用引用或者二级指针或者返回值来操作，我这里使用返回值
listnode* _mergesort(listnode* list1, listnode* list2)
{
listnode* newhead = (listnode*)malloc(sizeof(listnode));
listnode* tail = newhead;
while (list1 != nullptr && list2 != nullptr)
{
if (list1->_val < list2->_val)
{
tail->_next = list1;
list1 = list1->_next;
}
else
{
tail->_next = list2;
list2 = list2->_next;
}
tail = tail->_next;
}
tail->_next = list1 == nullptr ? list2 : list1;
return newhead->_next;
}
listnode* MergeSort(listnode* head)
{
//断言不为空
assert(head);
//递归的条件，一个值时；跳出递归
if (head->_next == nullptr)
return head;
//找中间节点
listnode* slow = head;
listnode* fast = head->_next;
while (fast != nullptr && fast->_next != nullptr)
{
fast = fast->_next->_next;
slow = slow->_next;
}
//将链表二分
listnode* _head = slow->_next;
slow->_next = nullptr;
//递归，并返回归并完的头指针
listnode* left = MergeSort(head);
listnode* right = MergeSort(_head);
//左子集链表与右子集链表归并排序，并返回归并完的头指针
return _mergesort(left, right);
}
需要注意的点为：
1.链表归并需要返回头指针，因为交换的是节点，头节点可能改变
2.不需要开辅助空间进行辅助
3.所以链表一般采用归并排序，时间复杂度小，空间复杂度也小
8.计数排序 n+m（数据最大差值）
思想是哈希，找出最大数最小数，开一个区间（能够放下最大最小的区间），遍历一遍数组，让每个值映射到一个辅助数组下标，此下标为（该值 减去 min值），然后需要从头拷贝的原数组
void CountSort(int* a, int n)
{
int max = a[0], min = a[0];
for (int i = 1; i < n; i++)
{
if (a[i] < min)
min = a[i];
if (a[i] > max)
max = a[i];
}
int range = max - min + 1;
int* count = (int*)calloc(range,sizeof(int));
for (int i = 0; i < n; i++)
{
count[a[i] - min]++;
}
int j = 0;
for (int i = 0; i < range; i++)
{
while (count[i]--)
{
a[j++] = i + min;
}
}
free(count);
}
扫一扫
3033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
