排序算法总结面试(二)

最新推荐文章于 2020-01-14 18:21:08 发布

浩世轩宇

最新推荐文章于 2020-01-14 18:21:08 发布

阅读量603

点赞数

分类专栏：解惑文章标签：排序算法希尔排序归并排序冒泡排序 c语言

本文链接：https://blog.csdn.net/luguifang2011/article/details/39995567

版权

解惑专栏收录该内容

21 篇文章 0 订阅

订阅专栏

一、插入排序(InsertionSort)
1. 基本思想：
每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。
2. 排序过程：　
【示例】：
[初始关键字] [49] 38 65 97 76 13 27 49
J=2(38) [38 49] 65 97 76 13 27 49
J=3(65) [38 49 65] 97 76 13 27 49
J=4(97) [38 49 65 97] 76 13 27 49
J=5(76) [38 49 65 76 97] 13 27 49
J=6(13) [13 38 49 65 76 97] 27 49
J=7(27) [13 27 38 49 65 76 97] 49
J=8(49) [13 27 38 49 49 65 76 97]

代码:

Procedure InsertSort(Var R : FileType);
//对R[1..N]按递增序进行插入排序, R[0]是监视哨//
  Begin
for I := 2 To N Do //依次插入R[2],...,R[n]//
begin
   R[0] := R; J := I - 1;
   While R[0] < R[J] Do //查找R的插入位置//
   begin
      R[J+1] := R[J]; //将大于R的元素后移//
      J := J - 1
   end
   R[J + 1] := R[0] ; //插入R //
end
  End; //InsertSort //

二、选择排序
1. 基本思想：
　　每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
2. 排序过程：
【示例】：
初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 ［38 65 97 76 49 2749]
第二趟排序后 13 27 ［65 97 76 49 3849]
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [49 97 65 76]
第五趟排序后 13 27 38 49 49 [97 97 76]
第六趟排序后 13 27 38 49 49 76 [76 97]
第七趟排序后 13 27 38 49 49 76 76 [ 97]
最后排序结果 13 27 38 49 49 76 76 97

代码:

Procedure SelectSort(Var R : FileType); //对R[1..N]进行直接选择排序 //
  Begin
for I := 1 To N - 1 Do //做N - 1趟选择排序//
   begin
   K := I;
   For J := I + 1 To N Do //在当前无序区R[I..N]中选最小的元素R[K]//
   begin
      If R[J] < R[K] Then K := J
   end;
   If K <> I Then //交换R和R[K] //
      begin Temp := R; R := R[K]; R[K] := Temp;end;
   end
  End; //SelectSort //

三、冒泡排序(BubbleSort)
1. 基本思想：
　　两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。
2. 排序过程：
　　设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。
【示例】：
49 13 13 13 13 13 13 13
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97

代码:

Procedure BubbleSort(Var R : FileType) //从下往上扫描的起泡排序//
Begin
  For I := 1 To N-1 Do //做N-1趟排序//
begin
   NoSwap := True; //置未排序的标志//
   For J := N - 1 DownTo 1 Do //从底部往上扫描//
   begin
   If R[J+1]< R[J] Then //交换元素//
      begin
      Temp := R[J+1]; R[J+1 := R[J]; R[J] :=Temp;
      NoSwap := False
      end;
   end;
   If NoSwap Then Return//本趟排序中未发生交换，则终止算法//
end
End; //BubbleSort//

四、快速排序（QuickSort）
1. 基本思想：
　　在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和R[I+1..H]，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准X则位于最终排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当R[1..I-1]和R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。
2. 排序过程：
【示例】：
初始关键字 [49 38 65 97 76 13 27 49］
第一次交换后
［27 38 65 97 76 13 49 49］
第二次交换后
［27 38 49 97 76 13 65 49］
J向左扫描，位置不变，第三次交换后
［27 38 13 97 76 49 65 49］
I向右扫描，位置不变，第四次交换后
［27 38 13 49 76 97 65 49］
J向左扫描
［27 38 13 49 76 97 65 49］
（一次划分过程）

初始关键字
［49 38 65 97 76 13 27 49］
一趟排序之后
［27 38 13］ 49 ［76 97 65 49］
二趟排序之后
［13］ 27 ［38］ 49 ［49 65］76 ［97］
三趟排序之后 13 27 38 49 49 ［65］76 97
最后的排序结果 13 27 38 49 49 65 76 97
各趟排序之后的状态

代码:

Procedure Parttion(Var R : FileType; L, H : Integer; Var I : Integer);
//对无序区R[1,H]做划分，I给以出本次划分后已被定位的基准元素的位置 //
Begin
  I := 1; J := H; X := R ;//初始化，X为基准//
  Repeat
While (R[J] >= X) And (I < J) Do
   begin
   J := J - 1 //从右向左扫描，查找第1个小于 X的元素//
   If I < J Then //已找到R[J] 〈X//
      begin
      R := R[J]; //相当于交换R和R[J]//
      I := I + 1
      end;
   While (R <= X) And (I < J) Do
      I := I + 1 //从左向右扫描，查找第1个大于 X的元素///
   end;
   If I < J Then //已找到R > X //
   begin       R[J] :=R; //相当于交换R和R[J]//
      J := J - 1
   end
  Until I = J;
  R := X //基准X已被最终定位//
End; //Parttion //

代码:

Procedure QuickSort(Var R :FileType; S,T: Integer); //对R[S..T]快速排序//
Begin
  If S < T Then //当R[S..T]为空或只有一个元素是无需排序//
begin
   Partion(R, S, T, I); //对R[S..T]做划分//
   QuickSort(R, S, I-1);//递归处理左区间R[S,I-1]//
   QuickSort(R, I+1,T);//递归处理右区间R[I+1..T] //
end;
End; //QuickSort//

五、堆排序(HeapSort)
1. 基本思想：
堆排序是一树形选择排序，在排序过程中，将R[1..N]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。
2. 堆的定义: N个元素的序列K1,K2,K3,...,Kn.称为堆，当且仅当该序列满足特性：
Ki≤K2i Ki ≤K2i+1(1≤ I≤ [N/2])

堆实质上是满足如下性质的完全二叉树：树中任一非叶子结点的关键字均大于等于其孩子结点的关键字。例如序列10,15,56,25,30,70就是一个堆，它对应的完全二叉树如上图所示。这种堆中根结点（称为堆顶）的关键字最小，我们把它称为小根堆。反之，若完全二叉树中任一非叶子结点的关键字均大于等于其孩子的关键字，则称之为大根堆。
3. 排序过程：
堆排序正是利用小根堆（或大根堆）来选取当前无序区中关键字小（或最大）的记录实现排序的。我们不妨利用大根堆来排序。每一趟排序的基本操作是：将当前无序区调整为一个大根堆，选取关键字最大的堆顶记录，将它和无序区中的最后一个记录交换。这样，正好和直接选择排序相反，有序区是在原记录区的尾部形成并逐步向前扩大到整个记录区。
【示例】：对关键字序列42，13，91，23，24，16，05，88建堆

代码:

Procedure Sift(Var R :FileType; I, M : Integer);
//在数组R[I..M]中调用R，使得以它为完全二叉树构成堆。事先已知其左、右子树(2I+1 <=M时)均是堆//
Begin
  X := R; J := 2*I; //若J <=M, R[J]是R的左孩子//
  While J <= M Do //若当前被调整结点R有左孩子R[J]//
begin
If (J < M) And R[J].Key < R[J+1].Key Then
   J := J + 1 //令J指向关键字较大的右孩子//
      //J指向R的左、右孩子中关键字较大者//
If X.Key < R[J].Key Then //孩子结点关键字较大//
   begin
      R := R[J]; //将R[J]换到双亲位置上//
      I := J ; J := 2*I //继续以R[J]为当前被调整结点往下层调整//
   end;
   Else
   Exit//调整完毕，退出循环//
end
  R := X;//将最初被调整的结点放入正确位置//
End;//Sift//

代码:

Procedure HeapSort(Var R : FileType); //对R[1..N]进行堆排序//
　Begin
　　For I := N Div Downto 1 Do //建立初始堆//
　　　Sift(R, I , N)
　　For I := N Downto 2 do //进行N-1趟排序//
　　　begin
　　　　T := R[1]; R[1] := R; R:= T;//将当前堆顶记录和堆中最后一个记录交换//
　　　　Sift(R, 1, I-1) //将R[1..I-1]重成堆//
　　　end
End; //HeapSort//

六、几种排序算法的比较和选择
1. 选取排序方法需要考虑的因素：
(1) 待排序的元素数目n；
(2) 元素本身信息量的大小；
(3) 关键字的结构及其分布情况；
(4) 语言工具的条件，辅助空间的大小等。
2. 小结：
(1) 若n较小(n <= 50)，则可以采用直接插入排序或直接选择排序。由于直接插入排序所需的记录移动操作较直接选择排序多，因而当记录本身信息量较大时，用直接选择排序较好。
(2) 若文件的初始状态已按关键字基本有序，则选用直接插入或冒泡排序为宜。
(3) 若n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。
快速排序是目前基于比较的内部排序法中被认为是最好的方法。
(4) 在基于比较排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程，由此可以证明：当文件的n个关键字随机分布时，任何借助于"比较"的排序算法，至少需要O(nlog2n)的时间。

这句话很重要它告诉我们自己写的算法是有改进到最优当然没有必要一直追求最优
(5) 当记录本身信息量较大时，为避免耗费大量时间移动记录，可以用链表作为存储结构。

bbs.kaoyan.com,

C语言排序算法总结

相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）：
1、稳定排序和非稳定排序
简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。反之，就是非稳定的。
比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，
则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。

2、内排序和外排序
在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；
在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。

3、算法的时间复杂度和空间复杂度
所谓算法的时间复杂度，是指执行算法所需要的计算工作量。一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。
===============================================
功能：选择排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。选择排序是不稳定的。算法复杂度O(n2)--[n的平方]
===============================================
void select_sort(int *x, int n)
{

    int i, j, min, t;

     for (i=0; i<n-1; i++) /*要选择的次数：0~n-2共n-1次*/
    {
        min = i; /*假设当前下标为i的数最小，比较后再调整*/
        for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/
        {
            if (*(x+j) < *(x+min))
            {
                min = j; /*如果后面的数比前面的小，则记下它的下标*/
            }
        }

        if (min != i) /*如果min在循环中改变了，就需要交换数据*/
        {
             t = *(x+i);
            *(x+i) = *(x+min);
             *(x+min) = t;
         }
    }
}

================================================
功能：直接插入排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
    在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循，直到全部排好顺序。直接插入排序是稳定的。算法时间复杂度O(n2)--[n的平方]
=====================================================
void insert_sort(int *x, int n)
{
    int i, j, t;
    for (i=1; i<n; i++) /*要选择的次数：1~n-1共n-1次*/
    {
        /*
           暂存下标为i的数。注意：下标从1开始，原因就是开始时
           第一个数即下标为0的数，前面没有任何数，单单一个，认为
           它是排好顺序的。
        */
        t=*(x+i);
        for (j=i-1; j>=0 && t<*(x+j); j--) /*注意：j=i-1，j--，这里就是下标为i的数，在它前面有序列中找插入位置。*/
        {
               *(x+j+1) = *(x+j); /*如果满足条件就往后挪。最坏的情况就是t比下标为0的数都小，它要放在最前面，j==-1，退出循环*/
        }
        *(x+j+1) = t; /*找到下标为i的数的放置位置*/
    }
}

================================================
功能：冒泡排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
   在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。下面是一种改进的冒泡算法，它记录了每一遍扫描后最后下沉数的位置k，这样可以减少外层循环扫描的次数。冒泡排序是稳定的。算法时间复杂度O(n2)--[n的平方]
=====================================================
void bubble_sort(int *x, int n)
{
    int j, k, h, t;

    for (h=n-1; h>0; h=k) /*循环到没有比较范围*/
    {
        for (j=0, k=0; j<h; j++) /*每次预置k=0，循环扫描后更新k*/
        {
            if (*(x+j) > *(x+j+1)) /*大的放在后面，小的放到前面*/
            {
                t = *(x+j);
                *(x+j) = *(x+j+1);
                *(x+j+1) = t; /*完成交换*/
                k = j; /*保存最后下沉的位置。这样k后面的都是排序排好了的。*/
           }
        }
    }
}

================================================
功能：希尔排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
    在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，以后每次减半，直到增量为1。希尔排序是不稳定的。时间复杂度O(n3/2)
=====================================================
void shell_sort(int *x, int n)
{
    int h, j, k, t;
    for (h=n/2; h>0; h=h/2) /*控制增量*/
    {
        for (j=h; j<n; j++) /*这个实际上就是上面的直接插入排序*/
        {
           t = *(x+j);
           for (k=j-h; (k>=0 && t<*(x+k)); k-=h)
           {
                *(x+k+h) = *(x+k);
           }
           *(x+k+h) = t;
        }
    }
}

================================================
功能：快速排序
输入：数组名称（也就是数组首地址）、数组中起止元素的下标
算法思想简单描述：
     快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。它是由 C.A.R.Hoare于1962年提出的。显然快速排序可以用递归实现，当然也可以用栈化解递归实现。下面的函数是用递归实现的，有兴趣的朋友可以改成非递归的。快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n2)
=====================================================
void quick_sort(int *x, int low, int high)
{
    int i, j, t;
    if (low < high) /*要排序的元素起止下标，保证小的放在左边，大的放在右边。这里以下标为low的元素为基准点*/
    {
        i = low;
        j = high;
        t = *(x+low); /*暂存基准点的数*/
        while (i<j) /*循环扫描*/
        {
            while (i<j && *(x+j)>t) /*在右边的只要比基准点大仍放在右边*/
           {
                j--; /*前移一个位置*/
           }
           if (i<j)
           {
                *(x+i) = *(x+j); /*上面的循环退出：即出现比基准点小的数，替换基准点的数*/
                i++; /*后移一个位置，并以此为基准点*/
            }
           while (i<j && *(x+i)<=t) /*在左边的只要小于等于基准点仍放在左边*/
           {
                i++; /*后移一个位置*/
           }
           if (i<j)
           {
                *(x+j) = *(x+i); /*上面的循环退出：即出现比基准点大的数，放到右边*/
                 j--; /*前移一个位置*/
           }
        }
        *(x+i) = t; /*一遍扫描完后，放到适当位置*/
        quick_sort(x,low,i-1); /*对基准点左边的数再执行快速排序*/
        quick_sort(x,i+1,high); /*对基准点右边的数再执行快速排序*/
    }
}

================================================
功能：堆排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
     堆排序是一种树形选择排序，是对直接选择排序的有效改进。堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储顺序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
堆排序是不稳定的。算法时间复杂度O(nlog2n)。
/*
功能：渗透建堆
输入：数组名称（也就是数组首地址）、参与建堆元素的个数、从第几个元素开始
*/
void sift(int *x, int n, int s)
{
    int t, k, j;
    t = *(x+s); /*暂存开始元素*/
    k = s; /*开始元素下标*/
    j = 2*k + 1; /*右子树元素下标*/
    while (j<n)
    {
        if (j<n-1 && *(x+j) < *(x+j+1))/*判断是否满足堆的条件：满足就继续下一轮比较，否则调整。*/
        {
            j++;
        }
        if (t<*(x+j)) /*调整*/
        {
           *(x+k) = *(x+j);
           k = j; /*调整后，开始元素也随之调整*/
           j = 2*k + 1;
        }
        else /*没有需要调整了，已经是个堆了，退出循环。*/
        {
             break;
        }
    }

    *(x+k) = t; /*开始元素放到它正确位置*/
}

/*
功能：堆排序
输入：数组名称（也就是数组首地址）、数组中元素个数
*/
void heap_sort(int *x, int n)
{
    int i, k, t;
    int *p;
    for (i=n/2-1; i>=0; i--)
    {
        sift(x,n,i); /*初始建堆*/
    }

    for (k=n-1; k>=1; k--)
    {
        t = *(x+0); /*堆顶放到最后*/
        *(x+0) = *(x+k);
        *(x+k) = t;
        sift(x,k,0); /*剩下的数再建堆*/
     }
}

void main()
{
    #define MAX 4
    int *p, i, a[MAX];

    /*录入测试数据*/
    p = a;
    printf("Input %d number for sorting :\n",MAX);
    for (i=0; i<MAX; i++)
    {
        scanf("%d",p++);
    }
    printf("\n");
    /*测试选择排序*/

    p = a;
    select_sort(p,MAX);
    /**/

    /*测试直接插入排序*/
    /*
    p = a;
    insert_sort(p,MAX);
    */

    /*测试冒泡排序*/
    /*
    p = a;
    insert_sort(p,MAX);
    */
    /*测试快速排序*/
    /*
    p = a;
    quick_sort(p,0,MAX-1);
    */
    /*测试堆排序*/
    /*
    p = a;
    heap_sort(p,MAX);
    */
    for (p=a, i=0; i<MAX; i++)
    {
        printf("%d ",*p++);
    }

    printf("\n");
    system("pause");
}

浩世轩宇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序算法总结面试(二)

一、插入排序(InsertionSort)1. 基本思想：每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。2. 排序过程：　【示例】：[初始关键字] [49] 38 65 97 76 13 27 49 J=2(38) [38 49] 65 97 76 13 27 49 J=3(65) [3
复制链接

扫一扫