数据结构——排序

目录

排序:

一.简单选择排序

二.直接插入排序

三.希尔排序

四.冒泡排序

五.快速排序

六.归并排序

七.堆排序

八.基数排序

九.小结:



排序:

将一组任意顺序的数据元素或记录,按照其关键字排列成递增或递减的新序列的操作过程。

一.简单选择排序

基本思路:每次从待排序的序列中选取关键字最小的记录,与当前排序序列的第一个记录交换位置,直到整个序列有序为止。

例:将582461按升序排序。

排序

趟数

1

2

3

4

5

6

初始

5

8

2

4

6

1

1

1

8

2

4

6

5

2

1

2

8

4

6

5

3

1

2

4

8

6

5

4

1

2

4

5

6

8

5

1

2

4

5

6

8

过程说明

一.排序1趟数过程说明:

首先将关键字一(5)关键字二(8)比较大小,关键字一小,再将关键字一(5)关键字三(2)比较大小,关键字三(2)小,再把关键字三与后面的关键字进行比较,最后把数值最小的关键字与关键字一交换数字,结果如排序趟数1所示。

排序2趟数过程说明:

二.经过趟数1的排序,关键字一的数值已经是最小的,所以从关键字二(8)开始排序;

关键字二(8)与后序的关键字进行比较大小,将后序最小值的关键字与关键字二的数值交换位置。结果如趟数2所示:数值2为最小值,将数值2与数值8进行了交换位置。

三.趟数三的过程说明:

与上面的排序过程相同,前两个关键字的大小已经确定了,将关键字三(8)与后序全部的关键字进行比较大小,将最小值与关键字三(8)的位置进行互换。

四.

后序的排序同上述一样。最后结果如趟数5所示。

五.代码

   void SelectSort(SqList *L)
   {                /*对顺序表L作简单选择排序*/
      RecordType  temp;
      for(i=1; ilength; ++i)
      {                      /*选择第i个小的记录,并交换到位*/
         j=i;   	          	               /* j用于记录最小元素的位置*/
         for(k=i+1; k<=L->length; k++)     /*在L.r[i..L.length]中选择key最小的记录*/
           if(L->r[k].keyr[j].key)     //遍历i后面的所有数,选择最小的数 
		    j=k;                           //用j记录较小的那个数 
           
             if(i!=j)                  /*第i个小的记录L->r[j]与第i个记录交换*/
            {  temp=L->r[j];			//temp此时记录了较小的数 
               L->r[j]=L->r[i];        //把较大的数赋值给后面的那个数 
               L->r[i]=temp;           //较小的赋值给i 
            }  
     } 
  }/*SelectSort

六.算法评价

数据结构——排序_第1张图片


二.直接插入排序

将一条待排序得记录按照其关键字的大小插入到已经有序的记录中,直到所有记录插入完成并且成为一个有序序列为止。

例:将 8594365* 按升序排序。

待插入元素位置序号

排序

趟数

R[0]

R[1]

R[2]

R[3]

R[4]

R[5]

R[6]

R[7]

初始

8

5

9

4

3

6

5*

i=2

1

5

5

8

9

4

3

6

5*

i=3

2

9

5

8

9

4

3

6

5*

i=4

3

4

4

5

8

9

3

6

5*

i=5

4

3

3

4

5

8

9

6

5*

i=6

5

6

3

4

5

6

8

9

5*

i=7

6

5*

3

4

5

5*

6

8

9

过程说明:

第一趟过程:

首先将R[2]赋值给R[0],然后把R[0]的值与R[1]进行比较,R[0]

第二趟排序:

将R[3]的值赋值给R[0],将R[0]的值与前两个值进行比较,R[0]>R[2],所以R[3]>R[2]排列顺序不变。

第三趟排序:

将R[4]的值赋值给R[0],R[0]与前三个值进行,首先从R[1]进行比较,R[0]

第四趟排序:

将R[5]的值赋值给R[0],然后从R[0]开始依次比较大小,R[0]

后序的排序方法重复以上操作。

代码

  void InsertSort(SqList *L)
   {       /*对顺序表L作插入排序*/
     for(i=2; i<=L->length; ++i)  //首先用第二个开始,与第一个数r[1]比较 
       if(L->r[i].keyr[i-1].key)     //小于前一个数 
       {      /*当“<”时,才需将L->r[i]插入有序表*/
          L->r[0]=L->r[i];                  /*将待插入记录复制为哨兵    r[0]此时是较小的那个数*/
          j=i-1;                            //j为i的前一个数 
         while(L->r[0].keyr[j].key)    //哨兵小于j的值 
          {  L->r[j+1]=L->r[j];           /*把大的那个值赋值给后面的位置*/
             j--;                                                  
         }
         //循环后,经j--后,j的位置移动到了j的前一个位置,所以下面需要j++,把j恢复到原来的位置。 
         L->r[j+1]=L->r[0];             /*插入到正确位置*/
      } /* if */
  } /* InsertPass */
 

算法分析

数据结构——排序_第2张图片


三.希尔排序

基本思路

将整个待排序记录序列分割成若干子序列,对每个子序列进行直接插入排序,待整个序列中纪录“基本有序”时,再对全体记录进行一次直接插入排序。

具体操作:

选择一个增量序列T1......Tn,增序列是一个递减序列,且最后一个增量一定是1,即Tn=1;

按照增量序列个数n,进行n趟排序。

例:对关键字序列 T=(49386597, 76, 13, 27, 49*55,  04)对应的记录进行希尔排序。

表格
r[i] 0 1 2 3 4 5 6 7 8 9 10
初态: 49 38 65 97 76 13 27 49* 55 04
第一趟(t=5) 13 27 49* 55 04 49 38 65 97 76
第二趟(t=3) 13 04 49* 38 27 49 55 65 97 76
第三趟(t=1) 04 13 27 38 49* 49 55 65 76 97

过程说明

增量序列t=5时,具体分组情况为:49,13;38,27;65,49*;97,55;76,04;

将上述每个小组的数据进行直接插入排序,结果得到第一趟的排序结果。

增量序列t=3时,具体分组情况为:13,38;04,27;49*,49;38,55;27,65;49,97;55,76;

将上述每个小组中的数据进行直接插入排序,结果得到第二趟的排序结果。

第三趟的分组结果:13,04;04,49*;49*,38;38,27;27,49;49,55;55,65;

65,76;76,97;各个小组的直接插入排序同步进行,然后把各个小组的排序结果整合在一起。结果就得出第三趟的排序结果。

代码

   void  ShellInsert(SqList *L, int  delta)
   {     /*对L->r[ ]做一趟希尔插入排序,delta为增量*/
       for(i=1+delta; i <= L->length; i++)         /* 1+delta为第一个子序列的第二个元素的下标*/
        if(L->r[i].key < L->r[i-delta].key)
        {   L->r[0] = L->r[i];        	             /*备份r[i] */
            for(j = i-delta; j > 0&&L->r[0].key < L->r[j].key; j-=delta)
                L->r[j+delta] = L->r[j]; 
                L->r[j+delta] = L->r[0]; 
        }
        
  }
      void  ShellSort(SqList *L)
      /*对记录数组r做希尔排序,delta[0..t-1]为增量序列数组*/
     {      for(i=0; i

算法分析

数据结构——排序_第3张图片


四.冒泡排序

基本思路

依次将待排序的记录相邻的关键字两两进行比较,如果后面的关键字小于前面的关键字的值,则进行交换记录的位置,没趟排序结束都会确定一个最大值在最后的位置。

例:使用冒泡排序方法将9524按升序排序。

第一趟:

数据结构——排序_第4张图片

第二趟:

数据结构——排序_第5张图片

第三趟:

数据结构——排序_第6张图片

代码

   void BubbleSort(SqList  *L)
   {        /*对记录数组L->r做冒泡排序*/
     RecordType temp;
     n=L->length;   
     change=TRUE;              	/*设置交换标识为TRUE,便于进入循环*/
     for(i=1; i<=n-1&&change; ++i) 
    {  change=FALSE;    	/*在第i趟中先设置记录交换标识为FALSE */  
        for(j=1; j<=n-i; ++j)
          if(L->r[j].key > L->r[j+1].key)     /*若相邻两记录逆序,交换 大的数字与下面小的数字互换位置*/
         {     temp = L->r[j];                //依次执行冒泡原则,先是12比较 ;再23 ;之后34比较。。。。 ; 如此循环     ;把大的那个数,向下排序 ; 
                L->r[j] = L->r[j+1];
                L->r[j+1] = temp;
                change = TRUE; 				//第一次循环结束,true进入下一次循环 
         }
     }
  } /* BubbleSort */
//当i=1;进入第一次循环嵌套,j=1;对顶部的数进行冒泡排序,第一个数到达底部;
//当i=2;进入第二次循环嵌套,j=1; 同时i=2;(第一次循环后,已经有一个数排序完成,所以只需要比较n-i次)继续对顶部的数进行冒泡排序。。。; 
//剩下最后一个数,不需要进行排序,已经是有序的; 

算法分析

数据结构——排序_第7张图片


五.快速排序

基本思路:

先从数列中选取一个数作为基数(该记录称为枢轴)。

2.将比基准大的数全部放到它的右边,小于或等于基准数的全放到它的左边。

3.再对左右两部分分重复第二步,直到各个区间只有一个数,达到整个序列有序。

轴元素的选取:

通常选取序列中的第一个元素,

选取原则:

1.首元素R[s]或者尾元素R[t]。

2.中值元素,取的是首元素,尾元素,中间位置元素三者中“中间大小”的元素。

3.随机元素R[i],i是s~t之间的一个随机整数。

例题:

数据结构——排序_第8张图片

数据结构——排序_第9张图片

数据结构——排序_第10张图片

数据结构——排序_第11张图片

数据结构——排序_第12张图片

数据结构——排序_第13张图片

数据结构——排序_第14张图片

数据结构——排序_第15张图片

数据结构——排序_第16张图片

数据结构——排序_第17张图片

数据结构——排序_第18张图片

数据结构——排序_第19张图片

第一趟排序结束

数据结构——排序_第20张图片

 第一趟排序详解

                这里统一选取最左边的数为枢轴元素,以把49取出作为基准,左边low位置为空,所以这里先从high位置开始排序,49*=49,所以49*位置不动,默认如果当前位置未移动,则当前下标继续移动,所以high移动到27的位置,27<49,移动到low的位置。low与high交替移动,所以此时移动low的位置,low移动到38的位置,38<49,不需要移动,此时继续移动low的位置,low移动到65的位置,65>49,所以把65移动到high的位置。这时,移动high的位置,high移动到13的位置,13<49所以把13移动到low的位置,(交替移动位置)所以移动low的位置到97,97>49,所以移动到high的位置,接下来移动high的位置到76,76>49,所以不移动。此时再移动high位置,high位置与low位置重合,此时把基准数填入当前位置。

第一趟排序结束。


数据结构——排序_第21张图片

数据结构——排序_第22张图片

数据结构——排序_第23张图片

数据结构——排序_第24张图片

数据结构——排序_第25张图片

第二趟排序结束

数据结构——排序_第26张图片

第二趟排序详解

经过第一趟排序,数组被分为两部分;49左边为都小于49的数,49右边为都大于49的数。

再分别对这两部分数进行快速排序。

首先对左部分进行排序。

选取左部分数组中,最左边的数作为基准,high位于13的位置,13<27,所以移动到low的位置,此时移动low的位置,38大于27,把38移动到high的位置。再移动high的位置,此时high的位置与low的位置重合,把27填入此时的位置。 

这时,27左右两边的数组分别只有一个数(默认为有序),所以左部分数组排序结束。


数据结构——排序_第27张图片

数据结构——排序_第28张图片

数据结构——排序_第29张图片

数据结构——排序_第30张图片

数据结构——排序_第31张图片

数据结构——排序_第32张图片

数据结构——排序_第33张图片

第三趟排序结束

数据结构——排序_第34张图片

第三趟排序详解

同样选取最左边的数作为基准数,然后按照以上原理进行移动。


数据结构——排序_第35张图片

数据结构——排序_第36张图片

第四趟排序结束

数据结构——排序_第37张图片

第四趟排序详解:

第三趟排序后,76把右部分数组分为两部分,做部分有两个数,所以还需要进行排序,选取最左边的数作为基准,high位于65的位置,65大于49,所以不需要进行排序,此时继续移动high的位置,high与low重合,所以填入基准数,排序结束。

代码

   void QSort(RecordType R[], int s, int t)
   {     /*对记录序列R[s..t]进行快速排序*/
      if(s

算法分析

数据结构——排序_第38张图片


六.归并排序

七.堆排序

八.基数排序

九.小结:

数据结构——排序_第39张图片


后序内容持续完善更新。。。。。。。。

你可能感兴趣的:(学习记录,数据结构,数据结构,算法,排序算法)