iOS 排序算法总结


查考网址:http://student.zjzk.cn/course_ware/data_structure/web/paixu/paixu8.5.1.1.htm

二叉树

http://blog.csdn.net/walkinginthewind/article/details/7518888



借鉴上面一个地址, 把常用的一些排序算法总结归纳一下, 便于大家和自己的学习


一、插入排序

    1、 直接插入排序

直接插入排序基本思想


1、基本思想

 假设待排序的记录存放在数组R[1..n]中。初始时,R[1]自成1个有序区,无序区为R[2..n]。从i=2起直至i=n为止,依次将R[i]插入当前的有序区R[1..i-1]中,生成含n个记录的有序区。


2、第i-1趟直接插入排序:

 通常将一个记录R[i](i=23n-1)插入到当前的有序区,使得插入后仍保证该区间里的记录是按关键字有序的操作称第i-1趟直接插入排序。

 排序过程的某一中间时刻,R被划分成两个子区间R[1..i-1](已排好序的有序区)和R[i..n](当前未排序的部分,可称无序区)。

 直接插入排序的基本操作是将当前无序区的第1个记录R[i]插人到有序区R[1..i-1]中适当的位置上,使R[1..i]变为新的有序区。因为这种方法每次使有序区增加1个记录,通常称增量法。

 插入排序与打扑克时整理手上的牌非常类似。摸来的第1张牌无须整理,此后每次从桌上的牌(无序区)中摸最上面的1张并插入左手的牌(有序区)中正确的位置上。为了找到这个正确的位置,须自左向右(或自右向左)将摸来的牌与左手中已有的牌逐一比较


     1.算法描述

void lnsertSort(seqList R)

{ //对顺序表R中的记录R[1..n]按递增序进行插入排序

    int i, j;

    for(i=2; i<=n; i++)//依次插入R[2]R[n]

    {

        if(R[i].key1].key){//R[i].key大于等于有序区中所有的keys,则R[i]

            //应在原有位置上

            R[0]=R[i];

            j=i-1;//R[0]是哨兵,且是R[i]的副本

            do {//从右向左在有序区R[1..i-1]中查找R[i]的插入位置

                R[j+1]=R[j]; //将关键字大于R[i].key的记录后移

                j-- ;

            }while(R[0].key//R[i].key≥R[j].key时终止

        R[j+1]=R[0];//R[i]插入到正确的位置上

        }//endif

    }

}


2、希尔(shell)排序

基本思想:

     先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人排序;然后,取第二个增量d2重复上述的分组和排序,直至所取的增量dt=1(dt,即所有记录放在同一组中进行直接插入排序为止。

 该方法实质上是一种分组插入方法。


Shell排序的算法实现


1不设监视哨的算法描述

void ShellPass(SeqList Rint d)

{//希尔排序中的一趟排序,d为当前增量

    for(i=d+1;i<=ni++)//R[d+1..n]分别插入各组当前的有序区

        if(R[i].key

            R[0]=R[i];j=i-d//R[0]只是暂存单元,不是哨兵

            do {//查找R[i]的插入位置

                R[j+d]=R[j]//后移记录

                j=j-d//查找前一记录

            }while(j>0&&R[0].key

                R[j+d]=R[0]//插入R[i]到正确的位置上

                } //endif

} //ShellPass


void  ShellSort(SeqList R)

{

    int increment=n//增量初值,不妨设n>0

    do {

        increment=increment/3+1//求下一增量

        ShellPass(Rincrement)//一趟增量为incrementShell插入排序

    }while(increment>1)

        } //ShellSort

注意:

     当增量d=1时,ShellPassInsertSort基本一致,只是由于没有哨兵而在内循环中增加了一个循环判定条件"j>0",以防下标越界。


二、交换排序

  1、冒泡排序

具体算法

void BubbleSort(SeqList R)

{ //Rl..n)是待排序的文件,采用自下向上扫描,对R做冒泡排序

    int ij

    Boolean exchange //交换标志

    for(i=1;i//最多做n-1趟排序

        exchange=FALSE //本趟排序开始前,交换标志应为假

        for(j=n-1;j>=ij--) //对当前无序区R[i..n]自下向上扫描

            if(R[j+1].key//交换记录

                R[0]=R[j+1] //R[0]不是哨兵,仅做暂存单元

                R[j+1]=R[j]

                R[j]=R[0]

                exchange=TRUE //发生了交换,故将交换标志置为真

            }

        if(!exchange) //本趟排序未发生交换,提前终止算法

            return

            } //endfor(外循环)

} //BubbleSort


2、快速排序

快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后,使得排序序列的长度能大幅度地减少。在冒泡排序中,一次扫描只能确保最大数值的数移到正确位置,而待排序序列的长度可能只减少1。快速排序通过一趟扫描,就能确保以某个数为基准点的左边各数都比它小,右边各数都比它大。然后又用同样的方法处理它左右两边的数,直到基准点的左右只有一个元素为止。

显然快速排序可以用递归实现,当然也可以用栈化解递归实现。

快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n),最坏O(n2)

main()

{

int a[10],i;

quick_sort(a,0,9);

}

quick_sort(int L[],int first,int end)

{

int split;

if(end>first)

{

split=quick(first,end,L);//进行一次希尔排序,返回值为本次排序基准值的下标值 

       quick_sort(L,first,split-1);//上面的排序完成后再对基准点左右的数组进行同样的排序操作

       quick_sort(L,split+1,end);

   }

}

quick(int first,int end,int L[])

{

int left=first,right=end;

int key=L[first];

while(left

{

while((left=key))

right--;

if(left

L[left++]=L[right];

while((left

left++;

if(left

L[right--]=L[left];

}

L[left]=key;

return left;

}




你可能感兴趣的:(ios)