十大排序算法
1、冒泡法
void BubbleSort(int nums[], int n)
{
// cout << "Bubble Sort " << endl;
int temp = 0;
int exchange = 0;
for (int i = 0; i < n - 1; i++) {
exchange = 0;
for (int j = n - 1; j > i; j--) {
if (nums[j] < nums[j - 1]) {
temp = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = temp;
exchange = 1;
}
}
if (exchange == 0) {
return ;
}
}
}
2 、选择排序
// 选择排序
// 首先，找到数组中最小的元素，拎出来，将它和数组的第一个元素交换位置，
// 第二步，在剩下的元素中继续寻找最小的元素，拎出来，和数组的第二个元素交换位置，如此循环，直到整个数组排序完成。
void SelectionSort(int nums[], int n)
{
int min = 0; // 记录最小元素下标
int temp = 0;
for (int i = 0; i < n; i++) {
min = i;
for (int j = i + 1; j < n; j++) {
if (nums[min] > nums[j]) {
min = j;
}
}
if (min != i) {
temp = nums[i];
nums[i] = nums[min];
nums[min] = temp;
}
}
}
3、 插入排序
// 插入排序
// 插入排序的思想和我们打扑克摸牌的时候一样，
// 从牌堆里一张一张摸起来的牌都是乱序的，我们会把摸起来的牌插入到左手中合适的位置，让左手中的牌时刻保持一个有序的状态。
void InsertionSort(int nums[], int n)
{
for (int i = 1; i < n; i++) {
int temp = nums[i];
int j = 0;
for (j = i - 1; j >= 0; j--) { //移动操作
if (nums[j] > temp) {
nums[j + 1] = nums[j];
} else {
break;
}
}
nums[j + 1] = temp;
}
}
4、希尔排序
/ 希尔排序
// 希尔排序这个名字，来源于它的发明者希尔，也称作“缩小增量排序”，是插入排序的一种更高效的改进版本。
// 我们知道，插入排序对于大规模的乱序数组的时候效率是比较慢的，因为它每次只能将数据移动一位，
// 希尔排序为了加快插入的速度，让数据移动的时候可以实现跳跃移动，节省了一部分的时间开支。
void ShellSort(int nums[], int n)
{
int gap = n / 2;
while(gap > 0) {
for (int i = gap; i < n; i++) {
int temp = nums[i];
int j = 0;
for (j = i - gap; j >= 0; j -= gap) { //移动操作
if (nums[j] > temp) {
nums[j + gap] = nums[j];
} else {
break;
}
}
nums[j + gap] = temp;
}
gap = gap / 2;
}
}
5、归并排序
// 归并排序
// 归并算法的核心思想是分治法，就是将一个数组一刀切两半，递归切，直到切成单个元素，
// 然后重新组装合并，单个元素合并成小数组，两个小数组合并成大数组，直到最终合并完成，排序完毕。
// 两数组进行组合
void Merge(int list1[], int list1Size, int list2[], int list2Size)
{
int temp[list1Size + list2Size];
int i = 0;
int j = 0;
int k = 0;
while ((i < list1Size) && (j < list2Size)) {
if (list1[i] < list2[j]) {
temp[k++] = list1[i++];
} else {
temp[k++] = list2[j++];
}
}
while (i < list1Size) {
temp[k++] = list1[i++];
}
while (j < list2Size) {
temp[k++] = list2[j++];
}
for (int m = 0; m < list1Size + list2Size; m++) {
list1[m] = temp[m];
}
}
void MergeSort(int nums[], int n)
{
if (n <= 1) {
return ;
}
int *list1 = nums;
int list1Size = n/2;
int *list2 = nums + list1Size;
int list2Size = n - list1Size;
MergeSort(list1, list1Size);
MergeSort(list2, list2Size);
Merge(list1, list1Size, list2, list2Size);
}
6、快速排序
// 快速排序
// 快速排序的核心思想也是分治法，分而治之。它的实现方式是每次从序列中选出一个基准值，其他数依次和基准值做比较，比基准值大的放右边，
// 比基准值小的放左边，然后再对左边和右边的两组数分别选出一个基准值，进行同样的比较移动，重复步骤，直到最后都变成单个元素，整个数组就成了有序的序列。
void QSort(int nums[], int s, int t)
{ int i = s;
int j = t;
int temp = 0;
if (s < t) {
temp = nums[s];
while(i != j) {
while (j > i && nums[j] > temp) {
j--;
}
nums[i] = nums[j];
while (i < j && nums[i] < temp) {
i++;
}
nums[j] = nums[i];
}
nums[i] = temp;
QSort(nums, s, i - 1);
QSort(nums, i + 1, t);
}
}
void QuickSort(int nums[], int n)
{
QSort(nums, 0, n - 1);
}
7、堆排序
// 堆排序
// 堆这种数据结构来进行排序的算法
// 两种实现，最大堆和最小堆
// 堆（以下全都默认为最大堆）看成一棵完全二叉树，但是位于堆顶的元素总是整棵树的最大值，
// 每个子节点的值都比父节点小，由于堆要时刻保持这样的规则特性，所以一旦堆里面的数据发生变化，我们必须对堆重新进行一次构建。
void HeapAdjust(int nums[], int index, int length)
{
int leftChild = 2 * index + 1;
int rightChild = leftChild + 1;
int present = index;//要调整的节点下标
//下沉左边
if (leftChild < length && nums[leftChild] > nums[present]) {
present = leftChild;
}
//下沉右边
if (rightChild < length && nums[rightChild] > nums[present]) {
present = rightChild;
}
//如果下标不相等 证明调换过了
if (present != index) {
//交换值
int temp = nums[index];
nums[index] = nums[present];
nums[present] = temp;
//继续下沉
HeapAdjust(nums, present, length);
}
}
void HeapSort(int nums[], int n)
{
for (int i = n / 2; i >= 0; i--) {
HeapAdjust(nums, i, n);
}
int temp = 0;
for (int i = n - 1; i > 0; i--) {
temp = nums[0];
nums[0] = nums[i];
nums[i] = temp;
HeapAdjust(nums, 0, i - 1);
}
}
8、计数排序
// 计数排序
void CountSort(int nums[], int n)
{
// 找最大元素
int max = nums[0];
for (int i = 1; i < n; i++) {
if (max < nums[i]) {
max = nums[i];
}
}
// 统计数据出现次数
int aCountNums[max + 1] = { 0 };
for (int i = 0; i < n; i++) {
aCountNums[nums[i]]++;
nums[i] = 0;
}
int j = 0;
for (int i = 0; i <= max; i++) {
if (aCountNums[i] > 0) {
nums[j++] = i;
}
}
}
9、桶排序
桶排序可以看成是计数排序的升级版，它将要排的数据分到多个有序的桶里，每个桶里的数据再单独排序，再把每个桶的数据依次取出，即可完成排序。
10、基数排序
基数排序可以看成桶排序的扩展，也是用桶来辅助排序。思想很简单，不管你的数字有多大，我一位一位的排，0-9最多也就十个桶，先按权重小的位置排序，然后按权重大的位置排序
整体测试代码
#include <iostream>
using namespace std;
//数组 nums
int nums[] = {8, 2, 5, 9, 7};
// 输出数组
void Show(int tabs[], int n, string s = "")
{
cout << s;
for (int i = 0 ; i < n; i++) {
cout << tabs[i] << " ";
}
cout << endl;
}
// 冒泡法
void BubbleSort(int nums[], int n)
{
int temp = 0;
int exchange = 0;
for (int i = 0; i < n - 1; i++) {
exchange = 0;
for (int j = n - 1; j > i; j--) {
if (nums[j] < nums[j - 1]) {
temp = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = temp;
exchange = 1;
}
}
if (exchange == 0) {
return ;
}
}
}
// 选择排序
// 首先，找到数组中最小的元素，拎出来，将它和数组的第一个元素交换位置，
// 第二步，在剩下的元素中继续寻找最小的元素，拎出来，和数组的第二个元素交换位置，如此循环，直到整个数组排序完成。
void SelectionSort(int nums[], int n)
{
int min = 0; // 记录最小元素下标
int temp = 0;
for (int i = 0; i < n; i++) {
min = i;
for (int j = i + 1; j < n; j++) {
if (nums[min] > nums[j]) {
min = j;
}
}
if (min != i) {
temp = nums[i];
nums[i] = nums[min];
nums[min] = temp;
}
}
}
// 插入排序
// 插入排序的思想和我们打扑克摸牌的时候一样，
// 从牌堆里一张一张摸起来的牌都是乱序的，我们会把摸起来的牌插入到左手中合适的位置，让左手中的牌时刻保持一个有序的状态。
void InsertionSort(int nums[], int n)
{
for (int i = 1; i < n; i++) {
int temp = nums[i];
int j = 0;
for (j = i - 1; j >= 0; j--) { //移动操作
if (nums[j] > temp) {
nums[j + 1] = nums[j];
} else {
break;
}
}
nums[j + 1] = temp;
}
}
// 希尔排序
// 希尔排序这个名字，来源于它的发明者希尔，也称作“缩小增量排序”，是插入排序的一种更高效的改进版本。
// 我们知道，插入排序对于大规模的乱序数组的时候效率是比较慢的，因为它每次只能将数据移动一位，
// 希尔排序为了加快插入的速度，让数据移动的时候可以实现跳跃移动，节省了一部分的时间开支。
void ShellSort(int nums[], int n)
{
int gap = n / 2;
while(gap > 0) {
for (int i = gap; i < n; i++) {
int temp = nums[i];
int j = 0;
for (j = i - gap; j >= 0; j -= gap) { //移动操作
if (nums[j] > temp) {
nums[j + gap] = nums[j];
} else {
break;
}
}
nums[j + gap] = temp;
}
gap = gap / 2;
}
}
// 归并排序
// 归并算法的核心思想是分治法，就是将一个数组一刀切两半，递归切，直到切成单个元素，
// 然后重新组装合并，单个元素合并成小数组，两个小数组合并成大数组，直到最终合并完成，排序完毕。
// 两数组进行组合
void Merge(int list1[], int list1Size, int list2[], int list2Size)
{
int temp[list1Size + list2Size];
int i = 0;
int j = 0;
int k = 0;
while ((i < list1Size) && (j < list2Size)) {
if (list1[i] < list2[j]) {
temp[k++] = list1[i++];
} else {
temp[k++] = list2[j++];
}
}
while (i < list1Size) {
temp[k++] = list1[i++];
}
while (j < list2Size) {
temp[k++] = list2[j++];
}
for (int m = 0; m < list1Size + list2Size; m++) {
list1[m] = temp[m];
}
}
void MergeSort(int nums[], int n)
{
if (n <= 1) {
return ;
}
int *list1 = nums;
int list1Size = n/2;
int *list2 = nums + list1Size;
int list2Size = n - list1Size;
MergeSort(list1, list1Size);
MergeSort(list2, list2Size);
Merge(list1, list1Size, list2, list2Size);
}
// 快速排序
// 快速排序的核心思想也是分治法，分而治之。它的实现方式是每次从序列中选出一个基准值，其他数依次和基准值做比较，比基准值大的放右边，
// 比基准值小的放左边，然后再对左边和右边的两组数分别选出一个基准值，进行同样的比较移动，重复步骤，直到最后都变成单个元素，整个数组就成了有序的序列。
void QSort(int nums[], int s, int t)
{ int i = s;
int j = t;
int temp = 0;
if (s < t) {
temp = nums[s];
while(i != j) {
while (j > i && nums[j] > temp) {
j--;
}
nums[i] = nums[j];
while (i < j && nums[i] < temp) {
i++;
}
nums[j] = nums[i];
}
nums[i] = temp;
QSort(nums, s, i - 1);
QSort(nums, i + 1, t);
}
}
void QuickSort(int nums[], int n)
{
QSort(nums, 0, n - 1);
}
// 堆排序
// 堆这种数据结构来进行排序的算法
// 两种实现，最大堆和最小堆
// 堆（以下全都默认为最大堆）看成一棵完全二叉树，但是位于堆顶的元素总是整棵树的最大值，
// 每个子节点的值都比父节点小，由于堆要时刻保持这样的规则特性，所以一旦堆里面的数据发生变化，我们必须对堆重新进行一次构建。
void HeapAdjust(int nums[], int index, int length)
{
int leftChild = 2 * index + 1;
int rightChild = leftChild + 1;
int present = index;//要调整的节点下标
//下沉左边
if (leftChild < length && nums[leftChild] > nums[present]) {
present = leftChild;
}
//下沉右边
if (rightChild < length && nums[rightChild] > nums[present]) {
present = rightChild;
}
//如果下标不相等 证明调换过了
if (present != index) {
//交换值
int temp = nums[index];
nums[index] = nums[present];
nums[present] = temp;
//继续下沉
HeapAdjust(nums, present, length);
}
}
void HeapSort(int nums[], int n)
{
for (int i = n / 2; i >= 0; i--) {
HeapAdjust(nums, i, n);
}
int temp = 0;
for (int i = n - 1; i >= 0; i--) {
temp = nums[0];
nums[0] = nums[i];
nums[i] = temp;
HeapAdjust(nums, 0, i - 1);
}
}
// 计数排序
void CountSort(int nums[], int n)
{
// 找最大元素
int max = nums[0];
for (int i = 1; i < n; i++) {
if (max < nums[i]) {
max = nums[i];
}
}
// 统计数据出现次数
int aCountNums[max + 1] = { 0 };
for (int i = 0; i < n; i++) {
aCountNums[nums[i]]++;
nums[i] = 0;
}
int j = 0;
for (int i = 0; i <= max; i++) {
if (aCountNums[i] > 0) {
nums[j++] = i;
}
}
}
// 桶排序
void BucketSort(int nums[], int n)
{
}
// 基数排序
void RadixSort(int nums[], int n)
{
}
int main()
{
cout << __DATE__ << " " << __TIME__ << endl;
cout << "===== mian start =======" << endl;
int n = sizeof(nums) / sizeof(nums[0]);
Show(nums, n, "Original:");
//BubbleSort(nums, n); // 冒泡法
//SelectionSort(nums, n); // 选择排序
//InsertionSort(nums, n); // 插入排序
//ShellSort(nums, n); // 希尔排序
//MergeSort(nums, n); // 归并排序
//QuickSort(nums, n); // 快速排序
//HeapSort(nums, n); // 堆排序
CountSort(nums, n); // 计数排序
//BubbleSort(nums, n); // 桶排序
//RadixSort(nums, n); // 基数排序
// 输出排序结果
Show(nums, n, "Sort:");
cout << "===== main end =======" << endl;
return 0;
}
1945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
