数据结构中的排序算法

概述

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

   复杂度为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）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序示例：