排序分析 及使用情况

选择排序

void SelectSort(Typename a[])
{
      int N=a.length;
      for(int i=0;i<N;i++)
     {
         int min =i;
         for(j=i+1;j<N;j++)
         {
            if(less(a[j],a[min]))
                min=j
          }
          exch(a,i,min);
      }
}

插入排序

void InsertSort(Typename a[])

{

int N=a.length;

for(int i=1;i<N;i++)

{

for(int j=i;j<0&&less(a[j],a[j-1]);j--)

exch(a,j,j-1);

}

} //适合部分有序的 小型数组   --数组中每个元素距离它最终位置不远 --一个有序的大数组接一个小数组 --数组中只有几个元素不确定

希尔排序

void ShellSort（int a[]）

{

int N=a.length;

int h=1;

while(h<N/3) h=3*h+1;

while(h>=1)

{

for(int i=h;i<N;h++)

for(int j=i;j>=h&&less(a[j],a[j-h]);j=j-h)    //步长之间 插入排序

exch(a,j,j-h);

h=h/3;

}

}//算法性能不仅取决于h 还跟h之间的数学性质相关，将插入排序移动元素的距离由1改为h ，代码量小  不需要额外内存空间

归并排序

分治法代表，递归在merge操作之前,原地归并时已经左右有序

void merge(int a[],int low,int mid ,int high)

{

int i= low,j=mid+1;

for(int k=low ;k<=high;k++)

aux[k]=a[k];

for(int k=low;k<=high;k++)

{

if(i>mid)               a[k]=aux[j++];

else if (j>high) a[k]=aux[i++];

esle if(less(a[i]),a[j]) a[k]= aux[i++];

esle  a[k]=aux[j++];

}

}

自顶向下归并

int aux[a.length];

void MergeSort(int a[],int low,int high)

{

if (low>=high) return ;//可以在小数组时改成插入排序 if(high<=low +M)  InsertSort(a,low,high);

int mid=low+(high-low)/2;

MergeSort(a,low ,mid); //左半边排序

MergeSort(a,mid+1,high); //右半边排序

merge(a,low,mid,high); //合并结果

}//可以添加判断是否已经有序调节，如果a[mid]<=a[mid+1]，就可以认为数组已经有序并跳过merge（）方法操作，还可以不将元素赋值到辅助数组，交换数组使用。

自底向上归并 略

快速排序

分治法，递归调用在处理操作之后

void QuickSort(int a[],int low ,int high)

{

if(high<=low) return; //同样可以在小部分数组时 使用插入排序

int j =partion(a,low,high);

QuickSort(a,low,j-1);

QuickSort(a.j+1,high);

}//改进方法：---小数组部分切换为插入排序  ----三取样切分，去前三个数的中位数  ------熵最优的排序 三向切分快速排序

int partion(int a[],int low,int high)

{

int i=low,j=hi+1;

int temp=a[low];

while(true)

{

while(less(a[++i],temp)&&(i<hi))     ;

while(less(temp,a[--j))     ;//切分元素就是a[low]不会比自己小，去掉测试条件 if（j==low）break

if(i>=j) break;

exch(a,i,j);

  }

exch(a,low,j);

return j;

}

堆排序

void HeapSort(int a)

{

int N=a.length;

for(int k=N/2;k>=1;k--)

sink(a,k,N);//从最后一个非叶子节点开始使用下沉方法有序化堆，建立优先队列

while（N>1）

{

exch(a,1,N--);

sink(a,1,N);//直接对根有序化就行

}

}

void sink(int a[],int k,int N)

{

while(2k<=N)

{

int  j=2k;

if (j<N&&less(a[j],a[j+1])) j++;//取较大的孩子

if(!less(a[k],a[j]))  break;

exch(a,k,j);

k=j;

}

}

void swim(int a[],int k,int N)

{

while(k>1&&less(a[k/2]),a[k])

{

exch(a,k/2,k);

k=k/2

}

}//采用插入方法建立有序堆时 可以用（由下至上有序化）