十大排序算法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;
}

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;//退出循环排序完成
	}
}

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;
	}
}

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直接赋值给刚刚移动过剩下的空位
	}
}

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;
	}
	
}

/*void MergeSort(int length, int array[])//归并排序O(nlogn)，优化选择排序
{
	if (length < 2) return;
	int mid = length / 2;
	
}*/
/*
 void sort(int arr[], int L, int R) {
    if(L == R) {
        return;
    }
    int mid = L + ((R - L) >> 1);
    sort(arr, L, mid);
    sort(arr, mid + 1, R);
    merge(arr, L, mid, R);
}

 void merge(int arr[], int L, int mid, int R) {
    int *temp= new int[R - L + 1];
    int i = 0;
    int p1 = L;
    int p2 = mid + 1;
    // 比较左右两部分的元素，哪个小，把那个元素填入temp中
    while(p1 <= mid && p2 <= R) {
        temp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    // 上面的循环退出后，把剩余的元素依次填入到temp中
    // 以下两个while只有一个会执行
    while(p1 <= mid) {
        temp[i++] = arr[p1++];
    }
    while(p2 <= R) {
        temp[i++] = arr[p2++];
    }
    // 把最终的排序的结果复制给原数组
    for(i = 0; i < temp.length; i++) {
        arr[L + i] = temp[i];
    }
	delete[]temp;
}*/

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)
}