数据结构常见八大排序算法

八大排序算法

算法性能比较

1、直接插入排序

• 算法思想
  

• 核心思想
  将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。
  因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成：
  （1）第一层循环：遍历待比较的所有数组元素
  （2）第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。
  如果：selected > ordered，那么将二者交换

• 代码实现：

//直接插入排序
void Insertsort(int array[],int length)
{
	int i,j,temp;
	for(i=1;i<length;i++)
	{
		temp=array[i];
		for(j=i-1;j>=0;j--)
		{
			if(temp<array[j])
			{
				array[j+1]=array[j];
			}
			else
				break;
		}
		array[j+1]=temp;
	}
}

直接插入排序算法示实例

2、希尔排序

• 算法思想
  将待排序数组按照步长gap进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次将gap折半减小，循环上述操作；当gap=1时，利用直接插入，完成排序。
  同样的：从上面的描述中我们可以发现：希尔排序的总体实现应该由三个循环完成：
  （1）第一层循环：将gap依次折半，对序列进行分组，直到gap=1
  （2）第二、三层循环：也即直接插入排序所需要的两次循环。具体描述见上。
  
• 代码实现：

//希尔排序
void Shellsort(int array[],int length)
{
	int gap=length/2;
	int i,temp;
	while(gap>0)
	{
		for(i=0;i<length-gap;i++)
		{
			if(array[i]>array[i+gap])
			{
				temp=array[i];
				array[i]=array[i+gap];
				array[i+gap]=temp;
			}
		}
		gap=gap/2;
	}
}

3、简单选择排序

• 基本思想：比较+交换。
  1、从待排序序列中，找到关键字最小的元素；
  2、如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
  3、从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。
  因此我们可以发现，简单选择排序也是通过两层循环实现。
  （1）第一层循环：依次遍历序列当中的每一个元素
  （2）第二层循环：将遍历得到的当前元素依次与余下的元素进行比较，符合最小元素的条件，则交换。
  
• 代码实现：

//简单选择排序
void Selectsort(int array[],int length)
{
	int i,j,temp,min;
	for(i=0;i<length-1;i++)
	{
		min=i;
		for(j=i+1;j<length;j++)
		{
			if(array[j]<array[min])
				min=j;
		}
		if(min!=i)
		{
			temp=array[i];
			array[i]=array[min];
			array[min]=temp;
		}
	}
}

4、堆排序

• 堆的概念
  堆：本质是一种数组对象。特别重要的一点性质：任意的叶子节点小于（或大于）它所有的父节点。对此，又分为大顶堆和小顶堆，大顶堆要求节点的元素都要大于其孩子，小顶堆要求节点元素都小于其左右孩子，两者对左右孩子的大小关系不做任何要求。利用堆排序，就是基于大顶堆或者小顶堆的一种排序方法。下面，我们通过大顶堆来实现。
• 基本思想
  堆排序可以按照以下步骤来完成：
  1、首先将序列构建称为大顶堆；
  （这样满足了大顶堆那条性质：位于根节点的元素一定是当前序列的最大值）
  
  2、取出当前大顶堆的根节点，将其与序列末尾元素进行交换；
  （此时：序列末尾的元素为已排序的最大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质）
  3、对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质
  
  4、重复2.3步骤，直至堆中只有1个元素为止
• 代码实现

//堆排序
void AdjustMinHeap(int array[],int pos,int length)
{
	int temp,child;
	for(temp=array[pos];2*pos+1<=length;pos=child)
	{
		child=2*pos+1;
		if(child<length&&array[child]>array[child+1])
			child++;
		if(array[child]<temp)
			array[pos]=array[child];
		else
			break;
	}
	array[pos]=temp;
}

void Swap(int *a,int *b )
{
	int temp;
	temp=*a;
	*a=*b;
	*b=temp;
}

void HeapSort(int *array,int length)
{
	int i;
	for(i=length/2-1;i<=0;i--)
	{
		AdjustMinHeap(array,i,length-1);
	}
	for(i=length-1;i>=0;i--)
	{
		Swap(&array[0],&array[i]);
		AdjustMinHeap(array,0,i-1);
	}
}

5、冒泡排序

• 基本思想
  1、将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；
  （ 第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
  2、对序列当中剩下的n-1个元素再次执行步骤1。
  3、对于长度为n的序列，一共需要执行n-1轮比较
  （利用while循环可以减少执行次数）
  
• 代码实现

//冒泡排序
void BubbleSort(int array[],int length)
{
	int i,j,temp;
	for(i=1;i<length;i++)
	{
		for(j=0;j<length-i;j++)
		{
			if(array[j]>array[j+1])
			{
				temp=array[j+1];
				array[j+1]=array[j];
				array[j]=temp;
			}
		}
	}
}

6、快速排序

• 基本思想：挖坑填数+分治法
  1、从序列当中选择一个基准数(pivot)，在这里我们选择序列当中第一个数最为基准数
  2、将序列当中的所有数依次遍历，比基准数大的位于其右侧，比基准数小的位于其左侧
  3、重复步骤1.2，直到所有子集当中只有一个元素为止。
  用伪代码描述如下：
  1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
  2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
  3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
  4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。
  
  

7、归并排序

• 基本思想
  首先把一个数组中的元素，按照某一方法，先拆分了之后，按照一定的顺序各自排列，然后再归并到一起，使得归并后依然是有一定顺序的 。
  
  

void MergeSort(int numbers[], int length, int temp[], int begin, int end)
{
	//1. 同样判断传入的参数是否有效
	if (numbers == nullptr || length <= 0 || begin < 0 || end >= length)
		throw new exception("Invalid input.");

	//2. 作为递归的结束条件，开始下标和结束下标相等时，说明子序列中只有一个元素，看作有序的
	if (end - begin == 0)
		return;

	//3. 定义中间变量，将数组分半【如果有7个元素，下标0-6，则middle=3，数组分为长度为4和3的两段】
	int middle = ((end - begin) / 2) + begin;
	//4. 递归，先递归左半边，再递归右半边，将左右子序列不断分为长度为1的子序列才停止递归
	MergeSort(numbers, length, temp, begin, middle);
	MergeSort(numbers, length, temp, middle + 1, end);
	//5. 再慢慢归并
	Merge(numbers, length, temp, begin, end, middle);
}
//归并函数
//参数：
//		numbers[]：原数组
//		length：数组元素的个数（数组长度）
//		temp[]：辅助数组
//		begin：数组开头的下标
//		end：数组结尾的下标
//		middle：数组中间的下标
void Merge(int numbers[], int length, int temp[], int begin, int end, int middle)
{
	//1. 判断是否有不符合要求的参数传入，有则抛出错误
	if (numbers == nullptr || length <= 0 || begin < 0 || end >= length)
		throw new exception("Invalid input.");

	//2. 将原序列从中分开
	int leftIndex = begin;		//左边序列的开始（左边序列的结尾是middle）
	int rightIndex = middle + 1;//右边序列的开始（右边序列的结尾是end）
	int tempIndex = begin;		//辅助数组的下标
	//3. 当左右子序列尚未到头时，循环
	while (leftIndex <= middle && rightIndex <= end)
	{
		//4. 两两对比判断，谁大谁就放入辅助数组，同时指针后移
		if (numbers[leftIndex] < numbers[rightIndex])
			temp[tempIndex] = numbers[leftIndex++];
		else
			temp[tempIndex] = numbers[rightIndex++];
		//5. 辅助数组下标++
		++tempIndex;
	}

	//6. 当左边或右边子序列尚未到头时，直接放入辅助数组
	while (leftIndex <= middle)
		temp[tempIndex++] = numbers[leftIndex++];

	while (rightIndex <= end)
		temp[tempIndex++] = numbers[rightIndex++];

	//7. 再将辅助数组中已经有序的元素覆盖掉原数组中无序的元素，使原数组变成部分有序
	for (int i = begin; i <= end; ++i)
		numbers[i] = temp[i];
}

8、基数排序

• 基本思想
  基数是按照低位先排序，然后收集；再按高位排序，然后再收集，依次类推，直到最高位。