复习----常见的排序算法

到目前为止，学习过的排序算法已经有很多了。它们因为时间复杂度以及空间复杂度的差异适用于不同的场合，所以现在来整理一下。

（注：此处的swap()是一个交换函数，只给出具体的实现函数）

待排序数组如下图：

一、交换排序

交换排序，就是相邻数的两两交换。

经过一趟排序之后（即i=0时），数组变为如图：

由上面我们可以看出，经过一趟交换排序之后，最小的数已经被放在数组的开始。

void exchange_sort(int *arr,int len)
{
	for (int i=0; i<len-1; i++)
	{
		for(int j=i+1; j<len;j++)
		{
			if(arr[i] > arr[j])
			{
				swap(&arr[i],&arr[j]);
			}
		}
	}
}

二、冒泡排序

冒泡排序，顾名思义就是数字像泡泡一样，轻（小）的往上飘，重（大）的往下沉。同样一趟排序之后数组为：

同样我们可以观察得到经过一趟排序后最大的已经排到了数组的最后一个，即是有序的。

void bubble_sort(int *arr,int len)
{
	for (int i=0; i<len-1; i++)
	{
		for(int j=0; j<len-i-1; j++)
		{
			if(arr[j] > arr[j+1])
			{
				swap(&arr[j],&arr[j+1]);
			}
		}
	}
}

//加强版的冒泡排序

void bubble_sort_ex(int *arr,int len)
{
	bool flag = true;
	for (int i=0; i<len-1; i++)
	{
		flag = false;
		for(int j=0; j<len-i-1; j++)
		{
			if(arr[j] > arr[j+1])
			{
				swap(&arr[j],&arr[j+1]);
				flag = true;
			}
		}
		if(flag)
		{
			break;
		}
	}
}

优化版的冒泡排序，减少了不必要的交换，可以自己测试一下，交换次序大大减少。

三、插入排序

插入排序就是每一步都将一个待排序的数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。

插入排序方法分为直接插入排序和折半插入排序，这里只说了直接插入排序。

void insert_sort(int *arr,int len)
{
	int j = 0;.
	for(int i=1; i<len; i++)
	{
		int tmp = arr[i];
		for(j=i-1; j>=0; j--)
		{
			if (tmp > arr[j])
			{
				break;
			}
			arr[j+1] = arr[j];
		}
		arr[j+1] = tmp;
	}
}

四、希尔排序

希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序

static void shell(int *arr,int len,int gap)

{
	int j = 0;
	for(int i=gap; i<len; i++)
	{
		int tmp = arr[i];
		for(j=i-gap; j>=0; j-=gap)
		{
			if(tmp > arr[j])
			{
				break;
			}
			arr[j+gap] = arr[j];
		}
		arr[j+gap] = tmp;
	}
}

void shell_sort(int *arr,int len)
{
	shell(arr,len,3);
	shell(arr,len,1);
}

五、归并排序

static void meger(int *arr,int len,int gap)
{
	int L1 = 0;
	int H1 = L1+gap-1;

	int L2 = H1+1;
	int H2 = L2+gap-1 < len ? L2+gap-1 : len-1;

	int *buff = (int *)malloc(sizeof(int) * len);
	assert(buff != NULL);

	int k = 0;

	while(L2 < len)
	{
		while (L1 <= H1 && L2 <= H2)
		{
			if(arr[L1] <= arr[L2])
			{
				buff[k++] = arr[L1++];
			}

			else if(arr[L1] > arr[L2])
			{
				buff[k++] = arr[L2++];
			}
		}
		while(L1 <= H1)
		{
			buff[k++] = arr[L1++];
		}

		while (L2 <= H2)
		{
			buff[k++] = arr[L2++];
		}

		L1 = H2+1;
		H1 = L1+gap-1;

		L2 = H1+1;
		H2 = L2+gap-1 < len ? L2+gap-1 : len-1;
	}
	while(L1 < len) //归并段1不完全，只有部分
	{
		buff[k++] = arr[L1++];
	}

	for(int i=0; i<len; i++)
	{
		arr[i] = buff[i];
	}

	free(buff);
}

void meger_sort(int *arr,int len)
{
	for(int gap=1; gap<len; gap=gap*2)
	{
		meger(arr,len,gap);
	}
}

六、快速排序

static int partition(int *arr,int left,int right)
{
	int L = left;
	int R = right;
	int tmp = arr[L];

	while(L < R)
	{
		while(arr[R] >= tmp && L < R)
		{
			R--;
		}
		arr[L] = arr[R];

		while (arr[L] <= tmp && L < R)
		{
			L++;
		}
		arr[R] = arr[L];
	}
	arr[L] = tmp;

	return L;
}

static void quick_sort_m(int *arr,int left,int right)
{
	if(left < right)
	{
		int base = partition(arr,left,right);
		quick_sort_m(arr,left,base-1);
		quick_sort_m(arr,base+1,right);
	}

}

void quick_sort(int *arr,int len)
{
	quick_sort_m(arr,0,len-1);
}

七、堆排序

static void heap_adjust(int *arr,int start,int end)
{
	int i = 0;
	int tmp = arr[start];

	for(i=2*start+1; i<end; i=2*i+1)
	{
		//判断是否有有孩子，并让i停在较大数的下标处
		if(i+1 < end && arr[i] < arr[i+1])
		{
			i++;
		}

		if(tmp > arr[i])
		{
			break;
		}
		else if(tmp < arr[i])
		{
			arr[start] = arr[i];
		}
		start = i;
	}
	arr[start] = tmp;
}

void heap_sort(int *arr,int len)
{
	for(int i=len/2-1; i>=0; i--)
	{
		heap_adjust(arr,i,len);
	}

	for(int j=len-1; j>0; j--)
	{
		swap(&arr[0],&arr[j]);
		heap_adjust(arr,0,j-1);
	}
}

排序算法的优良评判主要是看是时间复杂度以及空间复杂度，以下是几种排序算法的时间复杂度以及空间复杂度。

，

虽然以上各种排序都有自己的优点和缺点，但是对于程序员来说应该熟悉什么样的情况下使用什么样的排序算法能使算法的时间复杂度和空间复杂度都能够达到最好的状态，发挥它们最大的作用。