细讲排序算法之选择排序

概述

内部排序：全部数据可同时放入内存进行的排序。    

外部排序：文件中数据太多，无法全部调入内存进行的排序。

定义：设有记录序列：{R1、R2   ……….. Rn}

       其相应的关键字序列为：{K1、K2   ………..  Kn};

  若存在一种确定的关系：Kx<= Ky<=… <=Kz

    则将记录序列 { R1、R2   ………..  Rn} 排成按关键字有序的序列 { Rx、Ry   ………..  Rz}的操作，称之为排序。

    关系是任意的，通常使用小于（递增）、大于（递减）等关系。

   稳定与不稳定：若记录序列中的任意两个记录 Rx、Ry  的关键字 Kx = Ky  ；如果在排序之前和排序之后，它们的相对位置保持不变，则这种排序方法是稳定的，否则是不稳定的。

• 简单选择排序

      选择排序的基本思想：每一趟在n-i+1(i=1,2,3,…,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。

      一轮下来，找到最小的关键字的位置，与第i个记录交换。最后一个元素无需比较。从这里可以看出，该算法是不稳定的。

           48    62     35     77    55     14     35    98

           14   {62     35     77    55     48      35   98}

           14     35    {62    77    55     48      35     98}

           14     35     35    {77    55     48     62   98}

           14     35      35     48    {55      77    62     98}

            14    35     35     48      55     {77     62     98}

            14    35     35      48     55      62     {77    98}

            14    35    35      48      55      62      77      98

void SelectSort(int *r,int length)
/*对记录数组r做简单选择排序，length为数组的长度*/
{
   int n = length; 
   int i,j,k,x;
   for(i=0;i<n-1;i++)  //控制趟数
   {
	  
	   k = i;
	   /*选取最小值，记下其下标*/
	   for(j=i;j<n;j++)
		   if(r[j]<r[k])
			   k = j;
	   if(k!=j)
	   {
		   x = r[i];
		   r[i] = r[k];
		   r[k] = x;
	   }
   }
}

• 堆排序

     堆排序是一种树形选择排序方法，它的特点是：在排序过程中，将L[1...n]视为一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字最大(或最小)的元素。

      定义如下：n个关键字序列L[1...n]称为堆，当且仅当该序列满足：

            1)L(i)<=L(2i) 且 L(i)<=L(2i+1) 或 2)L(i)>=L(2i) 且 L(i) >= L(2i+1)  

    例如： { 96,83,27,11,9}  最大化堆

               { 12，36，24，85，47，30，53，91}  最小化堆

    

堆可以利用一维数组存储

    1）调整堆

    算法思想：

        a.首先将于堆相应的完全二叉树根结点中的记录移出，该记录称为待调整记录。此时根结点相当于空结点，从空结点的左右孩子中选出一个关键字较大的记录，如果该记录的关键字大于待调整记录的关键字，则将该记录上移至空结点中。

        b.此时，原来那个关键字较大的子结点相当于空结点，从空结点的左右孩子中选出一个关键字较大的记录，如果该记录的关键字仍大于待调整记录的关键字，则将该记录上移至空结点中。

        c.重复上述移动过程，直到空结点左右孩子的关键字均小于待调整记录的关键字。此时，将待调整记录放入空结点即可。

    例：

                                     

                

    2）

建立初始堆：从标号最大的有孩子的点i开始筛选，（i=n整除2）,然后i减1，直到i为1为止。

    

性能分析：

     堆排序在最坏情况下，其时间复杂度为O(nlog2n)。

     不稳定排序，不适用于待排序记录个数n较少的情况。

//建初堆
void CreateHeap(int *r,int n)
{      int i;
        for(i=n/2;i>=1;i--)
         Adjust(r,i,n);
}

void Adjust(int *r,int k,int n)  //调整下标为k的结点
{        int x,i,j;
          x = r[k];   //记录“根”结点
          i = k;    
          j = 2*k;  //“根”结点的左孩子
          bool finished = false;
          while(j<=n && !finished)
         {
	   /*在左右子树中选出最大的*/
                 if(j<n && r[j]<r[j+1])
                         j = j+1;
                 if(x>=r[j])
                         finished = true;   /*筛选结束*/
                 else                   /*继续筛选*/
                 {
                          r[i]  = r[j];
                          i = j;
                          j = 2*i;
	   }
        }
         r[i] = x;
}

//堆排
void HeapSort(int *r,int n)
{
  int i,b,j;
  CreateHeap(r,n);
  for(i=n;i>1;i--)
  {
	  b = r[1];  /*将堆顶记录和堆中最后一个记录交换*/
	  r[1] = r[i];
	  r[i] = b;
      Adjust(r,1,i-1);	 
  }
}