数据结构中的排序算法

概述

排序分为内存排序和外部排序，内部排序在内存中进行，外部排序因数据量较大，在外存中进行。一般我们常说的八大排序为内部排序。



   复杂度为O（nlog2n）的排序算法：快速排序、堆排序和归并排序。

1.插入排序--直接插入排序

1.1 算法思想

每趟将一个待排序的元素作为关键字，按照其关键字值的大小插入到已经排好的部分序列的适当位置上，插入时从后向前查找合适位置，直到插入完成。



1.2 代码

void insertSort(int R[],int n)
{
int i,j,temp;
for(i=1;i<n;i++)
{
temp = R[i];
j = i-1;
while(j>=0&&temp<R[j])
{
R[j+1] = R[j];
j--;
}
R[j+1] = temp;
}
}

时间复杂度O(n²)，空间复杂度O（1）。

2.折半查找

2.1 算法思想

前提数组有序，设置数组最小、最大、中间元素下标分别为low、high、middle。将待查找元素与数组中间位置元素比较，若小于中间元素，high=middle-1；若大于中间元素，low = middle+1；其中，middle=(low+high)/2.

注：循环条件：while(low<=high)

2.2 代码

int binarySearch(int a[],int n,int key)
{
int low = 0;
int high = n-1;
int middle;
while(low<=high)
{
middle = (low+high)/2;
if(key==a[middle])
return middle;
else if(key>a[middle])
low = middle + 1;
else
high = middle - 1;
}
return -1;
}

3.希尔排序

又叫做缩小增量排序，其本质还是插入排序。此外，希尔排序不稳定。

4.冒泡排序

4.1 算法思想

首先第一个记录和第二个记录比较，若前者较大，则两者互换；否则，不交换。如此循环一次，则最大元素位于最后。第二次循环，第二大元素位于数组倒数第二的位置。步骤如下。

注：在第二层循环中设置标志位监视是否有元素发生交换，若无，直接返回。

4.2 代码

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

5.快速排序

5.1 算法思想

一趟快速排序是以一个“枢轴”为中心，将序列分成两部分，一边全是比它小的，另一边全是比它大的。

注：用到了while循环与递归。

5.2 代码

void quickSort(int a[],int l,int r)
{
int temp,i,j;
i = l;
j = r;
if(l<r)
{
temp = a[i];
while(i!=j)
{
while(j>i&&temp<a[j]) j--;//自右向左扫描
if(i<j)
{
a[i] = a[j];
i++;
}
while(j>i&&temp>a[i]) i++;//自左向右扫描
if(i<j)
{
a[j] = a[i];
j--;
}
}
a[i] = temp;
quickSort(a,l,i-1);
quickSort(a,i+1,r);
}
}

时间复杂度O（nlog2n），空间复杂度O（log2n）。

6.选择排序--简单选择排序

6.1 算法思想

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。示例如下：



6.2 代码

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

7.选择排序--堆排序

堆排序是一种树形选择排序，是对简单选择排序的一种改进。

7.1 算法思想

任何一个非叶节点的值都不大于（或不小于）其左右孩子结点的值。若父亲大孩子小，则这样的堆叫做大顶堆；若父亲小孩子大，称为小顶堆。

由定义可知，代表堆的这棵完全二叉树的根节点的值是最大（或最小）的，最后一个元素与堆顶交换，替换后，有序序列元素增加1，无序序列元素减少1.



因此，堆排序需要解决两个问题：

①如何将n个待排序的数建成堆。

②输出堆顶元素后，如何调整剩余n-1个元素，成为新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。

调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。
2）将根结点与左、右子树中较小元素的进行交换。
3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.
4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.
5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。
称这个自根结点到叶子结点的调整过程为筛选。如图：


再讨论对n 个元素初始建堆的过程。

建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第

个结点的子树。
2）筛选从第

个结点为根的子树开始，该子树成为堆。
3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。
如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）



7.2 代码

void sift(int R[],int low,int high)
{
int i = low,j = 2*i;//R[j]是R[i]的左孩子结点
int temp = R[i];
while(j<=high)
{
if(j<high&&R[j]<R[j+1])//若右孩子较大，则把j指向右孩子
j++;               //j变为2*i+1
if(temp<R[j])
{
R[i] = R[j];//把R[j]调整到双亲结点的位置上
i = j;      //修改i和j的值，以便继续向下调整
j = 2*i;
}
else
break;//调整结束
}
R[i] = temp;//被调整结点的值放入最终位置
}
/*堆排序函数*/
void heapSort(int R[],int n)
{
int i,temp;
for(i=n/2;i>=1;--i)//建立初始堆
{
sift(R,i,n);
}
for(i=n;i>=2;--i)//进行n-1次循环完成堆排序
{
//以下3句换出了根节点中元素，将其放入最终位置
temp = R[1];
R[1] = R[i];
R[i] = temp;
sift(R,1,i-1);//在减少了1个元素的无序序列中进行调整
}
}

8.归并排序

算法思想

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序示例：