排序算法

#include <iostream>
using namespace std;
int a[10] = {6,2,4,8,1,5,3,0,7,9};
void quick_sort(int left, int right);
void Merge(int* list1,int list_size,int* list2,int list2_size);
void MergeSort(int arry[10], int list_size);
int main()
{
	int num=10, t;
	/* 选择排序 (每次与第一个比较)
	int min;
	for (int i = 0; i < num - 1; i++)
	{	
		min = i;
		for (int j = i; j < num; j++)
		{
			if (a[min] > a[j])
				min = j;
		}
		t = a[min];
		a[min] = a[i];
		a[i] = t;

	}
	*/
	/*	冒泡	(每次前一个与后一个比较)
	for(int i=0;i<num-1;i++)
		for(int j=0;j<num-i-1;j++)
			if (a[j] > a[j + 1])
			{
				t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
			}
	*/
/*	插入排序法 (每次往前找，直到不小于这个数为止)
	for (int i = 1; i < num; i++)
	{
		t = a[i];	//临时变量，保存待插入的值
		int j = i - 1; // a[j]为a[i]的前一个数，插入的过程就是j不断前移，a[i]不断与a[j]比较的过程
		while (t < a[j] && j >= 0)
		{
			a[j+1] = a[j];
			j--;
		}
		a[j+1] = t;
	}
	*/
	/* 希尔排序法 （根据插入排序法修改而来），实质就是分组进行插入排序，最后gap为1时进行一次整体的插入排序，为了提高效率而生
	6	 2	 4	 8	 1	 5	 3	 0	 7	 9    -----------  初始值
	5	 2	 0	 7	 1	 6	 3	 4	 8	 9    -----------  gap为5，第一轮将(6,5)(2,3)(4,0)(8,7)(1,9)分组排序
	0	 2	 1	 4	 3	 6	 5	 7	 8	 9 	  -----------  gap为2, 第二轮是(5,0,1,3,8)(2,7,6,4,9)排序
	0	 1	 2	 3	 4	 5	 6	 7	 8	 9	  -----------  gap为1，第三轮所有的为一组排序
*/
	
	int gap=10; //分组的跨度，gap初始值应为元素个数，此程序中固定了10，所以直接赋值为10的
	do
	{
		gap = gap / 2; //分组
		for (int m = gap; m < 2 * gap; m++) //设置这个m的含义是为了分组时不仅仅是只包含开头的数字那一组，而是将开头的数字到gap之间都要分别分组
		{
			for (int i = m; i < num; i += gap)//此处的for就是插入排序法的过程，只不过设置了"跨度" 而已。
			{
				t = a[i];
					int j = i - gap;
					while (t < a[j] && j >= 0)
					{
						a[j + gap] = a[j];
							j -= gap;
					}
				a[j + gap] = t;
			}
		}
	} while (gap > 1);
	
	/*	快速排序法
	quick_sort( 0, num - 1);
	*/
	/*	归并排序
	MergeSort(a, 10);
	*/
	
	for (int i = 0; i < num; i++)
		cout << a[i] << ' ';
	system("pause");
	return 0;
}
void quick_sort(int left, int right)
{
	//原理：先从右往左找到一个比基数小的，再从左往右找一个比基数大的，交换两者位置。重复以上动作，直到i ,j 相等
	//		再把基数归位到中间。此时一轮完成，左边的都比基数小，右边的都比基数大，再使用递归调用两边
	int i = left, j = right, temp = a[left], t;
	if (i > j)
		return;
	while (i != j)
	{
		while (a[j] >= temp&&i<j) //从右往左找一个比基数大的
			j--;
		while (a[i] <= temp&&i<j) //从左往右找一个比基数小的
			i++;
		if (i<j)
		{	// 交换位置
			t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
	}
	//基数与中间的数对调
	a[left] = a[i];
	a[i] = temp;

	quick_sort(left, i - 1);
	quick_sort(i + 1, right);
}
void Merge(int* list1, int list1_size, int* list2, int list2_size)
{
	int temp[10];//临时数组用来保存归并后的
	int i, j, k,m;
	i = j = k = 0;
	while (i < list1_size&&j < list2_size)
	{
		if (list1[i] < list2[j])
			temp[k++] = list1[i++];
		else
			temp[k++] = list2[j++];
	}
	//如果里面还有数据的话就要把余下的数据存放进去
	while (i < list1_size)
		temp[k++]= list1[i++];
	while (j < list2_size)
		temp[k++]= list2[j++];

	//最后再把temp中保存的数都返回个list1
	for (m = 0; m < list1_size + list2_size; m++)
		list1[m] = temp[m];
	
}
void MergeSort(int arry[10], int n)
{
	/*执行顺序
	6	 2	 4	 8	 1	 5	  3	  0	  7    9
	  26       48      15      03       79
	     2468             0135          79
		         01234568               79
				           0123456789
	*/
	if (n > 1)//递归的结束条件，到n等于1的时候结束，等于1时就不能再拆分了
	{//分别用list1和list2指向arry的左一半与右一半
		int *list1 = arry;
		int list1_size = n / 2;
		int *list2 = arry + n / 2;
		int list2_size = n - n / 2;

		MergeSort(list1, list1_size);
		MergeSort(list2, list2_size);
		Merge(list1, list1_size, list2, list2_size);
	}
}

算法时间空间复杂度比较：