常见排序算法总结

为加深排序算法的理解，总结一下常见的排序算法。

排序算法的大致分类：（网上找的图）






具体的实现：

直接插入排序：

基本原理为将待排序的数组分为有序区域和无序区域，每次将无序区域的一个数值插入到有序区域并排好序。最终实现排序。

void InsertSort(int k[],int n)
{
int i, j, temp;
for(i = 1; i < n; i++)
{
if(k[i] < k[i-1])
{
temp = k[i];
for(j = i-1; k[j] > temp; j--)
{
k[j+1] = k[j];
}
k[j+1] = temp;
}
}
}

希尔排序：

又称增量缩小排序。先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插入排序完成排序。

void ShellSort(int k[],int n)
{
int i, j, temp;
int d = n;
do
{
d = d/3 + 1;		//缩小增量设置
for(i = d; i < n; i++)
{
if(k[i] < k[i-d])
{
temp = k[i];
for(j = i-d; k[j] > temp; j -= d)
{
k[j+d] = k[j];
}
k[j+d] = temp;
}
}
}while(d > 1);
}

简单选择排序：

每次选择最小的元素与未排序部分的首部交换，使得序列的前面为有序。

void SelectSort(int k[],int n)
{
int i, j, temp;
for(i = 0; i < n-1; i++)
{
min = i;
for(j = i+1; j < n; j++)
{
if(k[j] < k[min])
{
min = j;
}
}
if(min != i)
{
temp = k[min];
k[min] = k[i];
k[i] = temp;
}
}
}

堆排序：

堆分为大根堆和小根堆，以大根堆为例，除了叶子结点以外每个结点的值都比左右孩子结点的值大，小根堆正好相反。首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。

void swap(int k[],int i,int j)	//交换函数
{
int temp;
temp = k[i];
k[i] = k[j];
k[j] = temp;
}
void HeapAdjust(int k[],int s,int n)
{
int i, temp;
temp = k[s];
for(i = 2*s; i <= n; i*=2)
{
if(i < n && k[i] < k[i+1])
{
i++;			//i指向较大的孩子结点
}
if(temp >= k[i])
{
break;
}
k[s] = k[i];
s = i;
}
k[s] = temp;
}
void HeapSort(int k[],int n)
{
//构造大顶堆
int i;
for(i = n/2; i > 0; i--)
{
HeapAdjust(k,i,n);
}
for(i = n; i > 1; i--)
{
swap(k,1,i);
HeapAdjust(k,1,i-1);
}
}

冒泡排序：

两两数据相互比较，若为逆序则互相交换，直到有序为止。

void BubbleSort(int k[],int n)
{
int i, j, temp, flag = 1;
for(i = 0; i < n-1 && flag; i++)
{
for(j = n-1; j > i; j--)
{
flag = 0;
if(k[j-1] > k[j])
{
temp = k[j-1];
k[j-1] = k[j];
k[j] = temp;
flag = 1;
}
}
}
}

快速排序：

每趟排序指定一个元素为基准点，左边的元素都比基准点的小，右边的元素都比它，然后递归执行，直到有序。

void QSort(int k[],int l,int r)
{
<span style="white-space:pre">	</span>int low = l;
<span style="white-space:pre">	</span>int high = r;
<span style="white-space:pre">	</span>int point = k[low];
<span style="white-space:pre">	</span>if(low < high)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>while(low < high)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>while(low < high && k[high] >= point)
<span style="white-space:pre">				</span>high--;
<span style="white-space:pre">			</span>k[low] = k[high];
<span style="white-space:pre">			</span>while(low < high && k[low] <= point)
<span style="white-space:pre">				</span>low++;
<span style="white-space:pre">			</span>k[high] = k[low];
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>k[low] = point;
<span style="white-space:pre">		</span>QSort(k, l, low-1);
<span style="white-space:pre">		</span>QSort(k, low+1,r);
<span style="white-space:pre">	</span>}
}

归并排序：

将原序列划分为有序的两个序列，然后利用归并算法进行合并，合并之后即为有序序列。

void merging(int *list1,int list1_size,int *list2,int list2_size)
{
int i, j, k;
int temp[MAXSIZE];
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++];
}
for(m = 0; m < (list1_size + list2_size); m++)
{
list1[m] = temp[m];
}
}
void MergeSort(int k[],int n)
{
if(n>1)
{
int *list1 = k;
int list1_size = n/2;
int *list2 = k + n/2;
int list2_size = n - list1_size;
MergeSort(list1,list1_size);
MergeSort(list2,list2_size);
merging(list1,list1_size,list2,list2_size);
}
}

void MergeSort(int *A,int x,int y,int *T)
{
if(y-x>1)
{
int m = x + (y-x)/2;
int p = x, q =  m,i = x;
MergeSort(A,x,m,T);
MergeSort(A,m,y,T);
while(p < m || q < y)
{
if(q >= y || (p < m && A[p] <= A[q]))
T[i++] = A[p++];
else
T[i++] = A[q++];
}
for(i = x; i < y; i++)
A[i] = T[i];
}
}

基数排序:

将数字按位数划分出n个关键字，每次针对一个关键字进行排序，然后针对排序后的序列进行下一个关键字的排序，循环至所有关键字都使用过则排序完成。

总结：如图