八大经典排序(C++实现)
排序分类：
各类排序算法复杂度：
一、冒泡排序
1、实现逻辑
所谓“冒泡排序”，可以从名称上理解：
以从小到大来举例，“冒泡”实际上就是指把值更大的元素放到数列的后面（如果是从大到小排列，则反之），通过交换来实现。
2、动态图演示
我们先来大致地看下面的动图，感受一下冒泡排序的运行过程：
3、代码实现
//冒泡排序
#include
using namespace std;
void BubbleSort(int* arr, int n)
{
int i , j , temp =0;
for (i=0; i < n - 1; i++)
{
for (j=0; j < n - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
int main()
{
int array[] = { 1, 34, 654, -1, 3242, 0, 2, 1, -1, 20 };
int num = sizeof(array) / sizeof(array[0]);
BubbleSort(array, num);
//范围for循环打印数组
for (auto e: array)
{
cout << e << " ";
}
cout << endl;
return 0;
}
二、快速排序
1.快排的实现逻辑：
- 先从数列中取出一个数作为基准数(通常取第一个数)。
- 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
- 再对左右区间重复第二步，直到各区间只有一个数。
2、动态图演示
3、代码实现
//双向快速排序
#include
using namespace std;
void QuickSort(int* arr,int left, int right)
{
if (left > right)
{
return;
}
int i = left;
int j = right;
//最左边的为准基数
int flag = arr[left];
while (i != j)
{
//从右侧找到一个比标记小的值
while (arr[j] > flag && i < j)
{
j--;
}
//从左侧找到一个比标记大的值
while (arr[i] <= flag && i < j)
{
i++;
}
//交换找到的值,使左边小,右边大
int temp = 0;
if (i 三、直接插入排序
1、实现逻辑
从第一个元素开始,该元素已经排好序,继续取元素与排好序的元素依次进行比较,升序的话插入到比前一个大比后一个小的位置,然后重复上述步骤,直到插完元素为止.
2、动态图演示
3、代码实现
#include
using namespace std;
//元素集合接近有序时,直接插入排序效率较高.
//直接插入排序,顺序查找
void Insertion_Sort(int* arr, int n)
{
int i = 0, flag = 0, step = 0;
for (i = 1; i < n; i++)
{
flag = arr[i];
step = i - 1;
while (step >= 0 && flag> 1;// >>1 相当于 /2
if (key= left)
{
arr[right + 1] = arr[right];
right--;
}
//插入元素
arr[left] = key;
}
}
int main()
{
int array[] = { 0, -1, 3, 12, 12, -2, 1, 0, 5345, -2 };
int size = sizeof(array) / sizeof(array[0]);
//Insertion_Sort(array, size);
Insert_Sort_Second(array,size);
//范围for循环打印数组
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
return 0;
} 四、希尔排序
1、实现逻辑
对整个待排序序列进行分组,然后对每一组进行直接插入排序.
2、动态图演示
3、代码实现
#include
using namespace std;
void ShellSort(int* arr, int size)
{
int i = 0;
int key = 0;
int end = 0;
int gap = 3;
while (gap > 0)
{
for (i = gap; i < size; i++)
{
key = arr[i];
end = i - gap;
while (end >= 0 && key 五、直接选择排序
1、实现逻辑
在未排序的序列中找到最小的元素,存放到序列的首位置,找到最大的元素存放到序列的末尾.然后抛开首位和末尾,继续重复该步骤,直到排完为止。
2、动态图演示
3、代码实现
//直接选择排序
#include
using namespace std;
void swap(int *a, int *b){
int ret = 0;
ret = *a;
*a = *b;
*b = ret;
}
void SelectionSort(int* arr, int size)
{
int left = 0;
int right = size - 1;
int i = 0;
while (leftarr[i])
MinIndex = i;
if (arr[MaxIndex] 六、堆排序
1、实现逻辑：
若升序的话,就将堆调成一个大堆,若降序的话,就将堆调成一个小堆.
从倒数第一个非叶子节点开始往根遍历,若当前节点的值都大于左右孩子,则不用动,若是小于,就将左右孩子当中最大的节点与当前节点交换,交换后就需要进行向下调整(因为交换会影响大堆结构).
重复上述步骤,直到根节点为止.
2、动态图演示：
3、代码实现：
//堆排序
#include
using namespace std;
//交换
void Swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
//建堆
void Heap_build(int array[], int root, int length)
{
int lchild = root * 2 + 1;
if (lchild < length)
{
int flag = lchild;
int rchild = lchild + 1;
if (rchild < length)
{
if (array[rchild] > array[flag])
{
flag = rchild;
}
}
if (array[root] < array[flag])
{
Swap(array[root], array[flag]);
Heap_build(array, flag, length);
}
}
}
//堆排序
void HeapSort(int array[], int len)
{
for (int i = len / 2; i >= 0; i--)
{
Heap_build(array, i, len);
}
for (int j = len - 1; j > 0; --j)
{
Swap(array[0], array[j]);
Heap_build(array, 0, j);
}
}
int main()
{
int array[] = { 1, 34, 34, 0, 121, 1, -1, -5, 13123, 0 };
int size = sizeof(array) / sizeof(array[0]);
HeapSort(array, size);
//范围for循环遍历打印数组
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
return 0;
} 七、归并排序
1、算法描述：
将待排序的元素序列分为两个长度相等的子序列,对每个子序列进行排序,然后将他们合并成一个序列,合并两个子序列的过程称为二路归并.
2、动态图演示：
3、代码实现：
//归并排序
#include
#include
using namespace std;
//归并
void MergeData(int *arr, int left, int mid, int right, int *temp){
int temp_index = left;
int left_L = left;
int left_R = mid;
int right_L = mid;
int right_R = right;
while (left_L1)
{
int mid = left + ((right - left) >> 1);
_MergeSort(arr, left, mid, temp);
_MergeSort(arr, mid, right, temp);
MergeData(arr, left, mid, right, temp);
memcpy(arr + left, temp + left, sizeof(int)*(right - left));
}
}
//递归
void MergeSort(int *arr, int size){
int *temp = (int *)malloc(size*sizeof(arr[0]));
if (temp == NULL)
{
assert(0);
return;
}
_MergeSort(arr, 0, size, temp);
free(temp);
}
//非递归
void MergeSort_Nor(int *arr, int size){
int *temp = (int *)malloc(size*sizeof(arr[0]));
if (temp == NULL)
{
assert(0);
return;
}
int i = 0;
int gap = 1;
while (gapsize)
{
mid = size;
}
if (right>size)
{
right = size;
}
MergeData(arr, left, mid, right, temp);
}
memcpy(arr, temp, size*sizeof(arr[0]));
gap = gap * 2;
}
free(temp);
}
int main(){
int array[] = { 2, 0, -4, 9234, 0, 2, 8, 1, 1, -5 };
int size = sizeof(array) / sizeof(array[0]);
MergeSort(array, size); //递归
//MergeSort_Nor(array, size); //非递归
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
return 0;
}
八、计数排序
1、算法描述：
找到待排序列中最大最小的元素,然后以此确定临时空间的大小,在临时空间中,以待排序列组中元素的大小为下标,该元素出现的次数为该下标对应的元素,根据临时空间的统计结果,重新对元素进行回收.
2、动态图演示：
3、代码实现：
#include
#include
using namespace std;
int GetMaxValue(int *arr, int size){
int i = 0;
int max = arr[0];
for (i = 1; i < size; i++)
{
if (arr[i]>max)
max = arr[i];
}
return max;
}
int GetMinValue(int *arr, int size){
int i = 0;
int min = arr[0];
for (i = 1; i < size; i++)
{
if (arr[i]