常用排序算法总结(三)

3.1 选择排序

    ① 简单选择排序

     简单选择排序的的实现比较容易。多次遍历序列，找出当前序列的最小的元素放在第一位即可。

     时间复杂度为：O(n)。

     排序稳定。

c语言：

void SelectSort(int *array,int length,int index)
{
	if(array==NULL||length<1||index>=length-1)
		return;     //参数不合法
	int min=index;
	for(int i=index+1;i<length;i++)
	{
		if(array[i]<array[min])
			min=i;
	}
	if(min!=index)
	{
		array[index]+=array[min];
		array[min]=array[index]-array[min];
		array[index]-=array[min];
	}
	SelectSort(array,length,index+1);
}

c语言(非递归)：

void SelectSort(int *array,int length)
{
	if(array==NULL||length<1)
		return;     //参数不合法
	int min=0,temp=0;
	for(int i=0;i<length;i++)
	{
		min=i;
		temp=i+1;
		while(temp<length)
			if(array[temp++]<array[min])
				min=temp-1;
		if(min!=i)
		{
			array[i]+=array[min];
			array[min]=array[i]-array[min];
			array[i]-=array[min];
		}
	}
}

Java语言：

public class SelectSort {
	
public final static void sort(int array[]){
		int min,save,point;
		for (int i = 0; i < array.length; i++) {
			min=i;
			point=i+1;
			save=array[i];
			while(point<array.length){
				if(array[min]>array[point]){
					min=point;
				}
				point++;
			}
			array[i]=array[min];
			array[min]=save;
		}
	}
}

    ② 堆排序

   堆是一种的二叉树结构，它的根结点大于两个子结点（大根堆）或者小于两个子结点（小根堆）。一个序列可以按广度优先来构造堆。然后自下往上调整堆，最顶部的堆的根节点就是当前序列的最大元素。将当前堆顶元素与最后的元素交换，将剩余的N-1个序列

再次调整堆。直到排好序列。

  在一个序列中，位置为n的元素的左子结点位置就是2*n，右子结点位置就是2*n+1。当前堆的数量就是序列长度的一半。

  堆排序的时间复杂度：O(nlogn)。

  在调整堆的时候可能打乱相同元素的位置，因此排序不稳定。

 C语言：

void Swap(int &x,int &y)
{
	x+=y;
	y=x-y;
	x=x-y;
}

void HeapSort(int *array,int length)
{
	if(array==NULL||length<1)
		return; 
	for(int i=0;i<length-1;i++)
	{
		for(int j=(length-i)/2;j>0;j--)
		{
			if(array[j-1]<array[2*j-1])
				Swap(array[j-1],array[2*j-1]);
			if(2*j<length-i&&array[j-1]<array[2*j])
				Swap(array[j-1],array[2*j]);
		}
		Swap(array[length-i-1],array[0]);
	}
}

Java语言

public class HeapSort {
	public static void sort(int array[])
	{
		int index = array.length;
		for (int i = 0; i < array.length-1; i++) {
			MaxHeap(array,index);
			int temp = array[0];
			array[0] = array[index-1];
			array[index-1] =  temp;
			index--;
		}
		
	}
	
	public static void MaxHeap(int array[],int index){
		int rightChild =0,leftChild=0;
		for (int i = index/2; i > 0 ; i--) {
			leftChild = 2*i-1;
			rightChild = 2*i;
			if(array[i-1]<array[leftChild])
			{
				int temp=array[i-1];
				array[i-1]=array[leftChild];
				array[leftChild]=temp;
			}
			
			if((rightChild<=index-1)&&array[i-1]<array[rightChild])
			{
				int temp=array[i-1];
				array[i-1]=array[rightChild];
				array[rightChild]=temp;
			}
		}
	}
	
}