详解选择排序和对其优化

选择排序是每次从未排序的队列中取出最小值，然后插到已排序队列的尾部。

例子： 12, 78, 9，7，25；待排序的数组元素

[7] [78, 9, 12, 25]  进行第一次排序时，min = 7，将它插到已排序队列的尾部，因为是第一次排序所以7 为已排序队列的首部。这里所说的插到已排序队列的尾部，其实是将找到的最小值和已排序的后一位值做交换。

[7, 9] [78,12,25] 

[7,9, 12] [78, 25]

[7,9,12, 25] [78]

[7,9,12, 25 78] 排序完成

void SelectSort(int number[]) 
{	
	int i, j, min;
	for(i = 1; i < MAX; i++)
	{
		min = i;
		for(j = i+1; j <= MAX; j++)
		{
			if(number[min] > number[j]) min = j;
		}
		if(min != i) SWAP(number[i],number[min]);
	}
	printf("sorted           : ");
	for(i = 1; i <= MAX; i++)
		printf("%d ",number[i]);
	printf("\n");
}

代码中每次用一个min 值来记录最小值的下标，为了后面的方便使用，数组从下标 1 开始计数

那么选择排序的算法复杂度就是 n+(n-1)+.......+1 = (1+n)*n/2  =  O(n^2)

从上述选择排序的思想可以看出，这个n^2 主要消耗在寻找最小值上面，那么欲对其进行优化，必须以极快的速度找到未排序数列中的最小值，在这里我使用的是最小堆树的结构，因为堆树搜寻的路径是树根到叶子节点，而不是遍历整个未排序的部分。

最小堆树有2 个叶子节点，根的值是最小值，而2个叶子节点之间无须进行排序

下面是一个最小堆树：

根据二叉树的概念可以得出 root = leaf / 2;

       

假定10 个数字在数组中，且下标是从 零开始

经过交换节点：得到一个最小堆树

将根和最后一个叶子节点做交换， 取出最小值，并且继续调整树，使其满足最小堆的性质

以此循环下去，直到最后一个数

#include <stdio.h>
#include <time.h>
#define MAX 10
#define SWAP(x,y){int t; t = x; x = y; y = t;}

void UltimateSelectSort(int number[])
{
	int i,root,leaf,m;
	int heap[MAX+1];
	for(i = 1; i <= MAX; i++)
	{
		heap[i] = number[i];
		leaf = i;
		root = leaf/2;
		while(leaf >= 2 && heap[root]>heap[leaf])
		{
			SWAP(heap[root], heap[leaf]);
			leaf = root;
			root = leaf/2;
		}
	}
	
	for(i = 1; i <= MAX; i++)
		number[i] = heap[i];

	m = MAX;
	while(m > 1)
	{
		SWAP(number[1],number[m]);
		m--;
		root = 1;
		leaf = root * 2;
		while(leaf <= m)
		{
			if((leaf < m) && (number[leaf]>number[leaf+1]))
				leaf++;
			if(number[root] <= number[leaf]) break;
			SWAP(number[root], number[leaf]);
			
			root = leaf;
			leaf = root * 2;
		}	
	}
	printf("sorted           : ");
    for(i = MAX; i > 0; i--) 
        printf("%d ", number[i]); 
    printf("\n");
}

int main()
{
	int number[MAX+1];
	int i;
	
	srand(time(NULL));
	printf("Previous of sort : ");
	for(i = 1; i <= MAX; i++)
	{
		number[i] = rand() % 100;
		printf("%d ",number[i]);
	}
	printf("\n");
	
	UltimateSelectSort(number);	
	
	return 0;
}

经过优化之后的算法复杂度为O（n*log2n） 以2为底，可以看出，优化之后的效率明显上升了一个档次