数据结构（选择排序）

选择排序

基本思路

无序区选出最小记录放到全局有序区。
常见方法：简单选择排序、堆排序。

简单选择排序

选择最小值

int Min(int a[],int n,int i)
{   int k=i,j;
    for(j=i;j<n;j++)
        if(a[j]<a[k])k=j;
        return a[k];
 }

void SelectSort(RecType R[],int n)
{    int i,j,k;RecType tmp;
for(i=0;i<n-1;i++)//做第i趟排序
{    k=i;
for(j=i;j<n;j++)
    if(R[j].key<R[k].key)
    k=j;
    if(k!=i)
    {tmp=R[i];R[i]=R[k];R[k]=tmp;}
    }
 }

比较次数：n(n-1)/2
移动记录的次数，正序为最小值0，反序为最大值3(n-1)

堆排序

堆的定义：
一个序列R[1…n]，关键字分别为k1、k2、…、kn
该序列满足：
ki<=k2i且ki<=k2i+1（小根堆）
或ki>=k2i且ki>=k2i+1（大根堆）
将序列可看成一颗完全二叉树。
大根堆中，对应的完全二叉树中，任意一个节点的关键字都大于或等于它的孩子节点的关键字。
最小关键字的记录一定是某个叶子节点。
n个节点的完全二叉树高度为log2（n+1）
所有筛选的时间复杂度为O（log2n）

void sift(RecType R[],int low,int high)//调整堆的算法
{    int i=low,j=2*i;//R[j]是R[i]的左孩子
     RecType tmp=R[i];
     while(j<=high)
     {    if(j<high&&R[j].key<R[j+1].key)j++;
     if(tmp.key<R[j].key)//双亲小
     {    R[i]=R[j];
          i=j;
          j=2*i;
     }
     else break;
     }
     R[i]=tmp;
 }
         

for(i=n/2;i>=1;i--)//循环建立初始堆
sift(R,i,n);

堆排序算法

void HeapSort(RecType R[],int n)
{    int i;RecType tmp;
    for(i=n/2;i>=1;i--)//循环建立初始堆
    sift(R,i,n);
    for(i=n;i>=2;i--)//进行n-1次循环，完成堆排序
    {
    tmp=R[1];
    R[1]=R[i];R[i]=tmp;
    sift(R,1,i-1);
    }//筛选R[1]节点，得到i-1个节点的堆
 } 

对高度为h的堆，一次筛选所需进行的关键字比较的次数至多为2（h-1）
对n个 关键字，建成高度为h=[log2n]+1的堆，所需进行的关键字比较次数不超过4n。
调整堆顶n-1次，总共进行的关键字比较次数不超过2n([log2n])。
堆排序时间复杂度为O(nlogn)。
空间复杂度为O(1)。
但是是不稳定的算法。
在操作系统中，将多个进程放在一个队列中，每个进程有一个优先级，总是出队优先级最高的进程执行。