一篇文章快速搞懂十大排序算法(C++实现源码)

十大排序算法函数声明

时间复杂度表

主函数

#include<iostream>
using namespace std;

void BubbleSort(int length, int array[]);//冒泡排序
void SelectSort(int length, int array[]);//选择排序
void InsertSort(int length, int array[]);//插入排序
void ShellSort(int length, int array[]);//希尔排序
void MergeSort(int length, int array[]);//归并排序
void QuickSort( int begin,int end,int array[]);//快速排序
void Swap(int i, int j, int array[]);//交换数组内的两个元素
int Partition(int begin, int end, int array[]);//快排中分割函数，结果返回中间项
void CountSort(int length, int array[]);//计数排序
void BucketSort(int length, int array[]);//桶排序
void RadixSort(int length, int array[]);//基数排序


int main() {
	int array[6] = { 2,9,1,5,3,6 };
	cout << "排序前";
	for (int i = 0; i < 6; i++)
	{
		cout << array[i]<<",";
	}
	cout << endl;
	//BubbleSort(6, array);
	//SelectSort(6, array);
	//InsertSort(6, array);
	//ShellSort(6, array);
	QuickSort(0, 5, array);
	cout << "排序后";
	for (int i = 0; i < 6; i++)
	{
		cout << array[i] << ",";
	}
	system("pause");
	return 0;
}

1冒泡排序(加入flag标记简单优化)

void BubbleSort(int length, int array[])//冒泡排序，注意flag的位置
{
	for (int i = 0; i < length; i++)
	{
		bool flag = true;//初始flag,一趟排序刚开始
		for (int j = 0; j < length-i-1; j++)
		{
			if (array[j] > array[j + 1])
			{
				int temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
				flag = false;//只要完成过一次交换flag就为false
			}
		}

		if (flag)//如果flag一次冒泡后仍为true说明不需要交换，排序已经完成，不必要继续浪费资源
			return;//退出循环排序完成
	}
}

2插入排序

void InsertSort(int length, int array[])//插入排序
{
	int current;
	for (int i = 0; i < length-1; i++)//a[i+1]项限制，第一项默认排好序，
	{
		current = array[i + 1];//将需要操作位置的值保存在current中，可以理解为腾出空位，从第二项开始向后
		int preindex = i;//current的前一项下标
		while (preindex>=0 && array[preindex]> current)//如果前面项每次都大于固定current值 ，最终前项为a[0]项
		{
			array[preindex + 1] = array[preindex];//前项值覆盖后项，不同于冒泡的交换，二是直接覆盖，
			preindex--;//每次向前遍历
		}
		array[preindex+1] = current;//覆盖到前项比后项小，current直接赋值给刚刚移动过剩下的空位
	}
}

3希尔排序(优化插排)

void ShellSort(int length,int array[])//希尔排序O(nlog2n),优化插排
{
	int temp, gap = length / 2;//初始定义gap为整个数组长度的一半
	while (gap>0)
	{
		for (int i = gap; i < length; i++)
		{
			temp = array[i];//i=gap,gap+1....
			int preIndex = i - gap;
			while (preIndex>=0&& array[preIndex]>temp)
			{
				array[preIndex + gap] = array[preIndex];
				preIndex -= gap;
			}
			array[preIndex + gap] = temp;
		}
		gap /= 2;
	}
	
}

4选择排序(选择最小元素下标)

void SelectSort(int length,int array[]) {//选择排序，选择最小值下标，注意比较双方
	for (int i = 0; i < length-1; i++) {
		int minindex =i;//初始指定i为最小元素下标
		for (int j = minindex; j < length - 1; j++) {
			if (array[minindex] > array[j + 1]) {//下一个与最小值下标对应的元素比较
				minindex = j + 1;//选出最小值下标
			}//比较条件下标j/j+1： j+1与length-1一组，j和length一组
		}
		int temp = array[i];//最小值与当前最小值下标位置的元素交换
		array[i] = array[minindex];
		array[minindex] = temp;
	}
}

5归并排序（优化选择排序）

 void Mergesort( int L, int R,int array[])//归并排序O(nlogn)，优化选择排序
 
 {
	 if (L < R)
	 {
		 int mid = L + ((R - L) >> 1);//>>1右移1位，等价于/2但是余数直接舍去
		 Mergesort( L, mid,array);//左边归并排序，使左子序列有序
		 Mergesort( mid + 1, R,array);//右边归并排序，使得右子序列有序
		 Merge( L, mid, R,array);//合并左右两个有序子序列
	 }
}

 void Merge( int L, int mid, int R,int array[])//归并函数
 {
	 
    int *temp= new int[R - L + 1];//新建一个原数组一样大的临时数组temp
    int i = 0;//临时数组的下标
    int p1 = L;//左侧指针
    int p2 = mid + 1;//右侧指针
    // 比较左右两部分的元素，哪个小，把那个元素填入temp中
    while(p1 <= mid && p2 <= R) {
        temp[i++] = array[p1] < array[p2] ? array[p1++] : array[p2++];
    }

    // 上面的循环退出后，把剩余的元素依次填入到temp中
    // 以下两个while只有一个会执行
    while(p1 <= mid) {//1左侧剩余元素,依次全部移入
        temp[i++] = array[p1++];
    }
    while(p2 <= R) {//2右侧剩余元素
        temp[i++] = array[p2++];
    }
    // 把最终的排序的结果复制给原数组
	for (i = 0; i < R - L +1; i++) {//R-L+1是当前动态数组temp的大小
		array[L + i] = temp[i];
	}
	/*或者用下面的方法赋值
	i = 0;
	while (L <= R)
	{
		array[L++] = temp[i++];
	}*/
	delete[]temp;//别忘了释放内存空间
}

6.1快速排序(单向扫描)

void Swap(int i, int j, int array[])//交换数组内两个元素
 {
	 int temp;
	 temp = array[i];
	 array[i] = array[j];
	 array[j] = temp;
 }
void QuickSort(int begin, int end, int array[])//快速排序
{
	 if (begin<end)
	 {
		 int mid = Partition(begin, end, array);//mid返回中间项
		 QuickSort(begin, mid-1, array);//递归调用，对mid左边的进行快排
		 QuickSort(mid + 1,end, array);//递归调用，对mid右边的进行快排
	 }

}


int Partition(int begin, int end, int array[])//快排中分割函数，结果返回中间项
{
	int pivot = array[begin];//初始中间项值=首元素
	int sp = begin + 1;//扫描指针下标
	int bigger = end;//bigger指针初始在尾部
	while (sp<=bigger)//当扫描指针位于bigger左边或者重合，
	{
		if (array[sp] > pivot)//如果扫描到的值大于中间项值
		{
			Swap(sp,bigger,array);//交换两者
			bigger--;//左移1位
		}
		else//<=中间项
		{
			sp++;//继续向后扫描
		}
	}//此时sp指向最后一个比中间项（首元素）大的值，bigger指向最后一个<=中间项的元素
	Swap(begin, bigger, array);//交换，此时新的bigger位置为中间项（值是初始的中间项值）。左边都是小的，右边都是大的
	return bigger;//返回中间项bigger(即pivot)
}

6.2快速排序(双向扫描法)

int DoubblePartition(int begin,int end,int array[])//双向扫描法左右指针left，right
{
	int pivot = array[begin];
	int left = begin + 1;//左侧指针指向pivot后1个元素
	int right = end;//右侧指针指向尾元素
	while (left<=right)
	{
		if (array[left]<=pivot && left <= right)//左指针扫描元素都小于pivot
		{//最终arrayleft肯定是大于pivot
			left++;//继续往右
		}
		if (array[right] > pivot&&left <= right)//右指针都大于pivot
		{//最终array[right]肯定是小于pivot
			right--;//继续向左
		}
		//注意！：上面2个加上left <= right条件防止，排序完成后left和right再次移动，因为最后一次left会一直往后跑，外层循环不一定控制的住内层循环
		//虽然我测试很多次并没有遇到这个情况。。
		else if(left<right)//以上两者都不满足,左右指针停止，条件left！=right等于时候交换，没有意义的
		{
			Swap(left, right,array);//先交换二者值，再继续扫描
			
		}
	}
	Swap(begin, right, array);
	return right;
}

void DoubbleQuickSort(int begin, int end, int array[])//双向扫描快排
{
	if (begin < end)
	{
		int mid = DoubblePartition(begin, end, array);//mid返回中间项
		DoubbleQuickSort(begin, mid - 1, array);//递归调用，对mid左边的进行快排
		DoubbleQuickSort(mid + 1, end, array);//递归调用，对mid右边的进行快排
	}
}

7堆排序

8计数排序

9桶排序

10基数排序