数据结构-第七章 排序

最新推荐文章于 2023-01-26 17:24:50 发布
最新推荐文章于 2023-01-26 17:24:50 发布
阅读量524 收藏 2
点赞数
分类专栏： 数据结构课程笔记 文章标签： 数据结构 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44202160/article/details/122996183
版权

排序

1. 概述

  1. 排序：n个对象的序列R[0],R[1],R[2],…R[n-1] 按其关键码的大小，进行由小到大(非递减)或由大到小(非递增)的次序重新排序的。
  2. 关键码(key)：进行排序的根据
  3. 两大类：
    1. 内排序：对内存中的n个对象进行排序。
    2. 外排序：内存放不下，还要使用外存的排序。(在本节中暂不考虑)
  4. 排序算法的稳定性：如果待排序的对象序列中，含有多个关键码值相等的对象，用某种方法排序后，这些对象的相对次序不变的，则是稳定的，否则为不稳定的。例： 35 81 20 15 82 28 81 82 15 20 28 35 稳定的
  5. 排序种类
    1. 内排序
      • 插入排序，交换排序，选择排序，归并排序，基数排序
    2. 外排序:本章暂不讨论外排序
  6. 排序的算法分析
    1. 时间开销 — 比较次数，移动次数
    2. 所需的附加空间 - 空间开销
  7. 下面是静态排序过程中所用到的数据表类定义：

1.1. 排序算法类定义

const int DefaultSize=100;
template<class Type>class datalist;
template<class Type>class Element{ 
    private:
        Type key;
        field otherdata;
    public:
        Type getkey( ){return key;}
        void setKey(const Type x){key=x;} 
        Element<Type>&operator=(Element<Type> &x ){ this = x; } 
        int operator ==(Type & x){return !(this < x||x < this);}
        int operator !=(Type & x){return this < x||x < this;}
        int operator <= (Type & x){return !(this > x);}
        int operator >=(Type & x){return!(this < x);}
        int operator < (Type & x){return  this > x;}
};
template<class Type> class datalist {
    public:
        datalist(int MaxSz=DefaultSize):MaxSize(MaxSz),CurrentSize(0){
            vector=new Element<Type>[MaxSz];
        } 
        void swap (Element <Type> & x, Element<Type> & y){Element <Type> temp=x; x=y; y=temp;}
    private:
        Element <Type> * vector;
        int MaxSize; CurrentSize;
};

2. 插入排序

  1. 排好前面两个，然后在后面的部分进行插入排序。
  2. 思想:思想：Ｖ0，Ｖ1，…，i-1个对象已排好序，现要插入Ｖi到适当位置
    • 例子：体育课迟到的人
  3. 方法：直接插入排序，链表插入排序，折半插入排序，希尔排序

2.1. 直接插入排序

2.1.1. 直接插入排序源码

//java
public static void Insert( int [] a , int n, int x) {
    //Insert x into the sorted array a[0:n-1] 
    int i;
    for(i=n-1; i>=0 && x<a[i]; i--)
        a[i+1]=a[i];
    a[i+1]=x;//注意这句话不在for循环中
}
public static void InsertionSort( int [] a,  int n) {
    for(int i=0; i<n; i++) {
        int t = a[i];
        //a[i]是第i+1个值
        Insert(a,i,t);
    }
}
  1. 比较的时候是从后向前比较的。
  2. 合并后的插入排序
//Another version of insertion sort
public static void InsertionSort(int []a, int n) {
    for(int i=0;i<n;i++){
        //insert a[i] into a[0:n-1]
        int t=a[i];
        int j;
        for(j=i-1; j>=0&&t<a[j]; j--)
            a[j+1]=a[j];
        a[j+1]=t;
        //比前面大后推一格
    }
}

template<class Type> void InsertionSort(datalist<Type> & list) {
    for (int i=1; i<list.CurrentSize; i++)
        Insert(list, i);
}
template<class Type> void Insert(datalist<Type> & list, int i) {
    Element<Type> temp=list.vector[i];
    int  j=i ;
    while(j>0&&temp.getkey()<list.vector[j-1].getkey()){
        list.Vector[j]=list.Vector[j-1];
        j--;
    }
    list.Vector[j]=temp;
}

2.1.2. 算法复杂度分析

  1. 额外的两次移动来自于a[i]的取出和放回，除此以外在最坏的情况下会每一次比较都会进行比较。



2.1.3. 算法稳定性

稳定的

2.2. 折半插入排序(Binary Insert Sort)

  1. 又称为折半查找

2.2.1. 源码

//java
public static int binarySearch( Comparable [] a, Comparable x ) {
    int low = 0, high = a.length - 1;
    while( low <= high ) {
        //计算出中点是哪一个
        int mid = (low+high) / 2;
        //调整两端的值
        if( a[mid].compareTo(x) < 0)
            low = mid + 1; 
        else if(a[mid ].compareTo(x) > 0)
            high = mid – 1;
        else  return mid;
    }
    return "NOT-FOUND";
}

//C++
//可以使用递归，也可以不使用递归
template <class Type> void BinaryInsertSort( datalist<Type> &list) {
    for (int i=1;i<list.currentSize;i++) 
        BinaryInsert(list, i);
}                                         
template <class Type> void BinaryInsert( datalist<Type> &list, int i) {
    int left=0, Right=i-1; 
    Element<Type>temp = list.Vector[i]; 
    while (left<=Right) {
        //调整区间
        int middle=(left+Right)/2;
        if (temp.getkey()<list.Vector[middle].getkey())
            Right=middle-1;
        else
            left=middle+1;
    }
    for(int k=i-1;k>=left;k--)
        list.Vector[k+1]=list.Vector[k];
    list.Vector[left]=temp;
}

2.2.2. 时间复杂度


2.2.3. 折半插入排序稳定性

算法是稳定的

2.3. 希尔排序(Shell Sort)

  1. 又称缩小增量排序(diminishing - increament sort)
  2. 方法:
    1. 取一增量(间隔gap < n)，按增量分组，对每组使用 直接插入排序或其他方法进行排序。
    2. 减少增量(分的组减少，但每组记录增多)。直至增量为1，即为一个组时。
  3. 例子:

  1. 每次完成排序后，gap每次都取一半。

2.3.1. 希尔排序的代码实现

//c++
template <class Type> void Shellsort( datalist <Type> & list) {
    int gap=list.CurrentSize/2;
    while (gap) {
        ShellInsert(list, gap);
        gap=gap= =2? 1 : (int)(gap/2);
    }
}
template<class Type> void ShellInsert( datalist<Type> &list; const int gap) {   
    for (int i=gap; i<list.CurrentSize; i++) {
        Element<Type>temp=list.Vector[i]; 
        int j=i;
        while(j>=gap&&temp.getkey()<list.Vector[j-gap].getkey()) {
            list.Vector[j]=list.Vector[j-gap];
            j-=gap;
        }
    list.Vector[j]=temp;
    }
}         

//java
public static void shellsort( Comparable [ ] a ) {
    for (int gap = a.length/2 ; gap>0 ; gap/=2 )
        for (int i = gap; i < a.length; i++) {
            //遍历一遍
            Comparable tmp = a[i];
            int j = i;
            for (;j >= gap && tmp.compareTo( a[j-gap] )< 0;j -= gap )
                //完成一遍下滤
                a[j] = a[j – gap];
            a[j] = tmp;
    }
}

2.3.2. 希尔排序的稳定性

不稳定的

2.3.3. 希尔排序算法分析

  1. 与选择的缩小增量有关，但到目前还不知如何选择最好结果的缩小增量序列。
  2. 平均比较次数与移动次数大约n1.3左右

3. 交换排序(一类排序算法)

  1. 方法的本质：不断的交换反序的对偶，直到不再有反序的对偶为止。
  2. 两种方法：
    1. 冒泡排序(Bubble sort)
    2. 快速排序(Quick sort)

3.1. 冒泡排序

  1. 每次遍历一次数组，然后仅仅比较相邻的两个数字，最坏的情况时每次只能讲一个数字冒泡上去。
  2. 然后遍历n次

3.1.1. 源码

//java
public static void Bubble( int [ ] a , int n) {
    //Bubble largest element in a[0:n-1] to right 
    for(int i=0; i<n-1; i++) 
        if(a[i] > a[i+1])
            swap(a[i],a[i+1]);
    }
public static void BubbleSort( int [ ] a, int n) {  
    //Sort a[0:n-1] using a bubble sort 
    for(int i=n ;i>1; i--) 
        Bubble(a,i); 
}

//C++
template<class Type> void  BubbleSort( datalist<Type> & list) {
    int pass=1;
    int exchange=1;
    while (pass<list.CurrentSize &&exchange) {
        BubbleExchange(list, pass, exchange);
        pass++;
    }
}
template<class Type>  void  BubbleExchange(datalist<Type> &list, const int i, int & exchange) {
    exchange=0;
    for (int j=list.CurrentSize-1; j>=i; j--)
        if (list.Vector[j-1].getkey()>list.Vector[j].getkey()) {
            swap(list.Vector[j-1],  list.Vector[j]);
            exchange=1;
        }
}

3.1.2. 冒泡排序算法分析

  1. 进行几次元素之间的比较？
    • 从n-1开始往下比较
  2. 进行了几次元素之间的交换
    • 不确定

3.1.3. 冒泡排序算法的稳定性

稳定的

3.1.4. 冒泡排序算法复杂度分析

  1. 最小比较次数
    • 有序：n-1次比较，移动次数为0
  2. 最大比较次数
    • 逆序：(n-1)+(n-2)+…+1=n(n-1)/2 约等于 O(n2) (比较次数)
      移动次数 = 3*(1+2+3+…+n)=(3/2)n(n-1) i=1 (移动次数)

3.2. 快速排序

3.2.1. 算法内容

  1. 在n个对象中，取一个对象(如第一个对象——基准pivot)，按该对象的关键码
    1. 把所有小于等于该关键码的对象分划在它的左边。
    2. 大于该关键码的对象分划在它的右边。
  2. 对左边和右边(子序列)分别再用快速排序。

3.2.2. 例子


3.2.3. 算法实现

//c++
template <class Type> void QuickSort( datalist <Type>& list, const int left,  const int right ) {
    if (left<right) {
        int pivotpos = partition(list, left, right);
        QuickSort(list, left, pivotpos-1);
        QuickSort(list, pivotpos+1, right);
    }
}
//partition
template <class Type> int partition(datalist<Type> &list, const int low, const int high) {
    int i=low,j=high;  Element<Type>pivot=list.Vector[low];
    while (i != j ) {
        while(list.Vector[j].getkey()>pivot.getkey( ) && i<j)
            j--;
        if (i<j) {
            list.Vector[i]=list.Vector[j];
            i++;
        }
        while(list.Vector[i].getkey()<pivot.getkey( ) && i<j)
            i++;
        if (i<j) {
            list.Vector[j]=list.Vector[i];
            j--;
        }
    }
    list.Vector[i]=pivot;
    return i;
}

java实现

public static void quicksort( Comparable [ ] a){
    quicksort(a, 0, a.length – 1);
}
private static Comparable median3(Comparable [ ] a, int left, int right ) {
    int center = ( left + right ) / 2;
    if ( a[center].compareTo( a[left ] < 0 )
        swapReferences( a, left, center );
    if ( a[ right ] . compareTo( a[left ]) < 0 )
        swapReferences( a, left, right );
    if( a[right ].compareTo( a[ center ] ) < 0 ) swapReferences( a, center, right );
    //调整了到最后一个位置上
    swapReferences( a, center, right – 1 );
    return a[ right – 1 ];
}
private static void quicksort( Comparable [ ] a, int left, int right ) {
    if( left + CUTOFF <= right ) {   
        Comparable pivot = median3( a, left, right );
        int i = left, j = right – 1;
        for(;;) {
            while(a[ ++i ].comparaTo( pivot  ) < 0 ){}
            while(a[--j].compareTo( pivot ) > 0 ) { }
            if(i < j)
                swapReferences( a, i, j ); 
            else
                break;
        }
        swapReferences(a,i,right – 1);
        quicksort( a, left, i – 1 );
        quicksort( a, i + 1, right );
    } else
        insertionSort( a, left, right );
}

3.2.4. 快速排序算法的稳定性

不稳定的排序方法

3.2.5. 快速排序的时间复杂度

  1. 最差的情况(当选第一个对象为分划对象时) 如果原对象已按关键码排好序，此时为O(n2)
K1[       ]
  K2[     ]
    K3[   ]
       ...
  1. 最理想的情况：每次分划第一个对象定位在中间

  1. 平均情况:设n=2k,一共做了K趟 K=log2n T(n) <= n+2T(n/2) <= n+2(n/2+2T(n/4))=2n+22T(n/22) <= 2n+22(n/22+2T(n/23))=3n+23T(n/23) <= … <= kn+2kT(n/2k)=nlog2n+nT(1)=O(nlog2n)
    可以证明Quicksort的平均计算时间也是O(nlog2n)

3.2.6. 空间复杂度

  1. 以上讨论的是递归算法，也可用非递归算法来实现。 不管是递归(由编译程序来实现)还是非递归。第一次分划后，左部、右部要分别处理。
  2. 优先使用左侧小端部分，之后就可以释放
  3. 存放什么：左部或右部的上、下界的下标。
  4. 栈要多大：O(log2n)- O(n)(有序情况)

3.2.7. 快速排序避免有序情况

  1. 选取pivot(枢纽元)用第一个元素作pivot是不太好的。
  2. 方法1：随机选取pivot, 但随机数的生成一般是昂贵的。
  3. 方法2：三数中值分割法(Median-of-Three partitioning) N个数，最好选第(N/2)(向上取整)个最大数，这是最好的中值，但这是很困难的。一般选左端、右端和中心位置上的三个元素的中值作为枢纽元。
    • 8, 1, 4, 9, 6, 3, 5, 2, 7, 0 (8, 6, 0)
    • 具体实现时：将 8，6，0 先排序，即 0, 1, 4, 9, 6, 3, 5, 2 , 7, 8, 得到中值pivot为 6
  4. 分割策略:
    1. 将pivot与最后倒数第二个元素交换，使得pivot离开要被分割的数据段。然后，i 指向第一个元素，j 指向倒数第二个元素。
      • 0, 1, 4, 9, 7, 3, 5, 2, 6, 8
    2. 然后进行分划
  5. 三数中值分隔法

3.2.8. 参考

  1. 图解排序算法(五)之快速排序——三数取中法

4. 选择排序

  1. 每次找到数组中的最小值找到然后放到前面，进行重复递归。
  2. 也可以将最大的数字找出来然后当放到后面。

4.1. 直接选择排序

  1. 思想:首先在n个记录中选出关键码最小(最大)的 记录，然后与第一个记录(最后第n个记录)交换位置，再在其余的n-1个记录中选关键码 最小(最大)的记录，然后与第二个记录(第n-1个记录)交换位置，直至选择了n－1个记录。

4.1.1. 源码

//java
public static void SelectionSort(int [] a, int n) {
    //sort the n number in a[0:n-1].
    //找到大数字放置到后面
    for(int size = n; size>1; size--){
        //n-1
        int j = Max(a,size);
        //n-1+n-2+...+1
        swap(a[j],a[size-1]);
    }
} 

//c++
template <class Type> void SelectSort(datalist<Type> &list) {
    for ( int i=0; i<list.CurrentSize-1; i++)
        SelectExchange(list, i);
}
template <class Type> void SelectExchange( datalist<Type> & list, const int i) {
    int k=i;
    for ( int j=i+1; j<list.CurrentSize; j++)
        if (list.Vector[j].getkey( )<list.Vector[k].getkey( ))
            k=j;
    if ( k!=i)
        Swap(list.Vactor[i], list.Vector[k]);
}

4.1.2. 直接排序算法内容分析

  1. 一次swap操作中包含3次子操作。
  2. 以上均是对于元素操作的统计

4.1.3. 直接排序时间复杂度

4.1.4. 直接排序稳定性

不稳定的

4.2. 锦标赛排序

  1. 直接选择排序存在重复做比较的情况，锦标赛 排序克服了这一缺点。
  2. 具体方法:
    1. n个对象的关键码两两比较得到(n/2)(向上取整)个 比较的优胜 者(关键码小者)保留下来, 再对这(n/2)(向上取整)个对象再进行关键码的两两比较, ……直至选出一个最小的关键码为止。如果n不是2的K次幂，则让叶结点数补足到满足 2k < n <= 2k个。
    2. 输出最小关键码。再进行调整：即把叶子结点上，该最小关键码改为最大值后，再进行 由底向上的比较，直至找到一个最小的关键码(即次小关 键码)为止。重复2，直至把关键码排好序。

4.2.1. 锦标赛排序的算法分析

4.3. 堆排序

  1. 参考heap部分
  2. 是固定的算法，从小到大排序，所以一开始建立最大堆，最后调整为最小堆
  3. 不稳定的

4.3.1. 算法思想

  1. 第一步，建堆，根据初始输入数据，利用 堆的调整算法FilterDown()，形成初始堆。(形成最大堆)
  2. 第二步，一系列的对象交换和重新调整堆

4.3.2. 示例


4.3.3. 代码实现

//c++
Template<class  Type>void HeapSort(datalist<Type>&list) {
    for(int i=(list.currentsize-1)/2;i>=0;i--)
        FilterDown(i,list.currentsize-1);
    for(i=list.currentsize-1;i>=1;i--){
        Swap(list.Vector[0],list.vector[i]);
        FilterDown(0,i-1);
    }
}
  1. FilterDown()就是第6章中的，但要改一下：那里是 建最小堆，这里是建最大堆。
//java program
public static void heapsort( Comparable []a) {
    for( int i = a.length / 2; i >= 0; i-- )
        percDown( a, i, a.length );
    for( int i = a.length – 1; i > 0; i-- ) {
        swapReferences( a, 0, i );
        percDown( a, 0, i);
    }
}
private static int leftChild( int i ) {   
    return 2 * i + 1;
}
private static void percDown( Comparable [ ] a, int  i,  int n ) {
    int child;
    Comparable tmp;
    for( tmp = a[i];leftChild(i) < n ; i = child ) {
        child = leftchild( i );
        if( child!=n – 1&& a[child].compareTo( a[ child + 1 ] ) < 0 )
            child ++;
        if( tmp . compareTo( a[ child ] < 0 )
            a[ i ] = a[ child ];
        else
            break;
    }
    a[i] = tmp;
}

4.3.4. 堆排序算法复杂度分析

5. 秩排序(Rank sort)

  1. 重新启用一个数组，用来记录相应的排名

5.1. 源码

public static void Rank( int [] a, int n, int [] r) {
    //Rank the n elements a[0:n-1]
    for(int i=0;i<n;i++){
        r[i]=0;
    }
    //首先将全部的数字重置为0
    for(int i=1;i<n;i++)
        for(int j=0;j<i;j++)
            if(a[j]<=a[i])
                r[i]++;
            else
                r[j]++;
            //胜者排名不需要向后增加，而败者需要增加次序。
}
public static void Rearrange( int [ ]a, int n, int[ ] r) {
    //In-place rearrangement into sorted order
    for(int i=0;i<n;i++)
        while(r[i]!=i) {
            //在数组[n]上的应该是第n+1大的数字
            int t=r[i];
            swap(a[i],a[t]);
            swap(r[i],r[t]);
        }
}

5.2. 秩排序算法性能分析

  1. a中元素的比较次数:1+…+n-1
  2. a中元素的交换次数:2(n-1-i)
    • 由于while的迭代次数不定，所以很难从代码层面确定次数
    • 从问题本身出发，最多调用2n次交换

6. 基数排序(Radix Sort)

  1. 先取个位数，按照个位数来放到十个桶里面。
    • 根据先后次序进图桶
  2. 按照十位数，继续放入桶中，根据个位排序结果
  3. 重复上述操作，直到最高位。
  4. 原理:每次让这一位的从前往后排序。


7. 归并排序

  1. 归并：两个(多个)有序的文件组合成一个有序文件 方法：每次取出两个序列中的小的元素输出之；当一序列完，则输出另一序列的剩余部分

  1. 算法思想:分而治之(分治思想)

7.1. 代码实现

//c++
template<class Type> void merge(datalist<Type> & initList, datalist<Type>& mergedList, const int l, const int m, const int n) {
    int i=l, j=m+1, k= l;
    while ( i<=m && j<=n ) if (initList.Vector[i].getkey( )<initList.Vector[j].getkey( )) {
        mergedList.Vector[k]=initList.Vector[i];
        i++;
        k++;
    }
    else{
        mergedList.Vector[k]=initList.Vector[j];
        j++;
        k++;
    }
    if (i<=m)
        for (int n1=k, n2=i; n1<=n && n2<=m;  n1++, n2++)
            mergedList.Vector[n1]=initList.Vector[n2];
    else
        for(int n1=k, n2=j; n1<=n && n2<=n; n1++, n2++)
            mergedList.Vector[n1]=initList.Vector[n2];
}

7.2. 归并排序

  1. 方法
    • n个长为1的对象两两合并，得n/2个长为2的文件
    • n/2个长为 2………………….得n/4个长为4的文件…
    • 2个长为n/2的对象两两合并,得1个长为n的文件

7.2.1. 例子

7.2.2. 非递归算法c++代码实现

//c++
template <class Type> void MergeSort(datalist <Type> & list) {
    datalist <Type> tempList(list.MaxSize); 
    int len=1;
    while (len<list.CurrentSize) {
        MergePass(list, tempList, len); len *=2 ;
        if (len >= list.CurrentSize) {
            for (int i=0;i< list.CurrentSize; i++)
                list.Vector[i]=tempList.Vector[i];
        }else{
            MergePass(tempList, list, len); len*=2;
        }
    }
    delete[]tempList;
}
  1. 当两段均满len长时调用merge
  2. 当一长一短时也调用merge(但第二段的参数不同)
  3. 当只有一段时，则复抄
  4. 块合并算法实现
//c++
template <class Type> void MergePass( datalist<Type> & initList, datalist <Type> & mergedList, const int len) {
    int i=0;
    while (i+2*len<=initList.CurrentSize-1) {
        merge( initList, mergedList, i, i+len-1, i+2*len-1);
        i+=2*len;
    }
    if(i+len <= initList.CurrentSize-1)
        merge(initList, mergedList, i, i+len-1,initList.CurrentSize-1);//因为有可能有块长度为余数，并不满足结果的，所以要额外处理
    else
        for( int j=i ; j<= initList.CurrentSize; j++)
            mergedList.Vector[j]=initList.Vector[j];
}
  1. 算法分析：合并趟数log2n,每趟比较n次，所以为O(nlog2n)
  2. 稳定性：稳定。

7.2.3. 递归算法java实现

//java
public static void mergeSort( Comparable [ ] a ) {
    Comparable [ ] tmpArray = new Comparable[a.length];
    mergeSort( a, tmpArray, 0, a.length – 1 );
}                            
private static void mergeSort( Comparable [ ] a, Comparable [] tmpArray, int left, int right ) {
    if( left < right ) {
        int center = ( left + right ) / 2;
        mergeSort(a, tmparray, left, center );
        mergeSort(a, tmpArray, center + 1, right );
        merge( a, tmpArray, left, center + 1, right );
    }
}
private static void merge( Comparable [ ] a, Comparable [] tmpArray, int leftPos, int rightPos, int rightEnd ) {
    int leftEnd = rightPos – 1;
    int tmpPos = leftPos;
    int numElements = rightEnd – leftPos + 1;
    while( leftPos <= leftEnd && rightPos <= rightEnd )
        if( a[ leftPos ].compareTo( a[ rightPos ] ) <= 0 )
            tmpArray[ tmpPos++ ] = a[ leftPos++ ];
        else
            tmpArray[ tmpPos++ ] = a[ rightPos++ ];
    while( leftPos <= leftEnd )
        tmpArray[ tmpPos++ ] = a[ leftPos++ ];
    while( rightpos <= rightEnd)
        tmpArray[ tmpPos++] = a[ rightpos++ ];
    for( int i = 0; i < numElements; i++, rightEnd-- )
        a[ rightEnd ] = tmpArray[ rightEnd ];
}

7.2.4. 算法分析

  1. 合并趟数log2n,每趟比较n次，所以为O(nlog2n)

7.2.5. 算法稳定性

  1. 稳定性：稳定。

7.3. 递归的表归并排序

  1. 使用静态链表的方法来实现

7.3.1. 算法实现

  1. 主程序 mergesort(L)
  2. 子程序 divide(L,L1)，将L划分成两个子表 3.合并两有序序列 merge(L,L1)
void MergeSort (List <Type> &L) {
    List <Type> L1;
    if (L.first!=NULL)
        if (L.first->link != NULL)//至少有两个结点
        {
            divide (L, L1);
            MergeSort(L);
            MergeSort(L1);
            L=merge( L, L1);
        }
}

7.3.2. 有序链表的merge算法

//c++
List<Type> & merge (List<Type> &L1, List<Type> & L2) {
    ListNode<Type>*p=L1.first,*q=L2.first,  *r ;
    List<Type> temp;
    if ((p= =NULL) or (q= =NULL)) {
        if (p!=NULL){
            temp.first=p;
            temp.last=L1.last;
        }else{
            temp.first=q;
            temp.last=L2.last;
        }
    }else{
        if (p->data<=q->data) {
            r = p;
            p = p->link;
        }else{
            r = q;
            q = q->link;
        }
        temp.first = r ;
        while((p!=NULL) && (q!=NULL)) {
            if (p->data<=q->data) {
                r->link=p;
                r=p;
                p=p->link;
            }else{
                r->link=q;
                r=q;
                q=q->link;
            }
        }
        if (p= =NULL){
            r->link=q;
            temp.last=L2.last;
        }else {
            r->link=p;
            temp.last=L1.last;
        }
    }
    return temp;
}

7.3.3. 下面讨论divide(List&L1,ListL2)

  1. 将L1表分为两个长度几乎相等的表，L1.first指向前半部分，L2.first指向后半部分，要求被划分的表至少含有两个结点。

  1. 方法：设两个流动指针p,q指向表的结点 一般来讲让p前进一步，q前进二步，最后当q= NULL时，这时p 恰好指向前半张表的最后一个结点。
  2. Eg.如果有10个结点，p走5次，q走10次正好走到表末尾
void divide(List<Type> & L1, List <Type> & L2) {
    ListNode <Type> *p, *q;
    L2.last=L1.last;
    p=L1.first;
    q=p->link;
    q=q->link;
    while (q!=NULL) {
        p=p->link;
        q=q->link;
        if (q!=NULL)
            q=q->link;
    }
    q=p->link;
    p->link=NULL;
    L1.last=p;
    L2.first=q;
}

8. 总结


9. 例题

  1. 若数据元素序列 11, 12, 13, 7, 8, 9, 23, 4, 5 是采用下列排序方法之一得到的第二趟排序后的结果, 则该排序算法只能是 A. 起泡排序 B. 插入排序 C. 选择排序 D. 二路归并排序
  2. 首先不是冒泡排序:最大最小值上下，选择排序也是选择最大最小，答案是B
SpriCoder
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 第七章 排序——选择排序， 堆， 堆排序
qq_40344308的博客
05-11 196
选择排序： void Selection_Sort( ElementType a[], int n ) { int i, j; for( i = 0; i < n - 1; i++ ){ //n个元素共进行n-1趟选择排序 int min = i; //假设当前元素是未排序序列中最小的元素 for( j = i + 1; ...
数据结构 ---- 第七章 排序
AAAAAAAC的博客
10-16 268
框架 排序 基本概念 内部排序 外部排序 稳定性 衡量标准 插入排序 交换排序 选择排序 归并排序 基数排序 多路归并排序 时空复杂度 直接插入排序 折半插入排序 希尔排序 冒泡排序 快速排序 简单选择排序 堆排序 ...
【数据结构】第七章：排序
qq_41514794的博客
04-16 163
冒泡排序： 插入排序： 时间复杂度下界 ■定理:任意N个不同元素组成的序列平均具有N(N-1 )/4个逆序对。 ■定理:任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为Ω(N2)。 ■这意味着:要提高算法效率，我们必须 每次消去不止1个逆序对! 每次交换相隔较远的两个数！ 希尔排序：利用插入排序的简单，克服插入排序每次只交换相邻两个数的缺点。 voi...
数据结构和算法：第七章 排序
Master-TJ的个人博客
10-31 696
7.1 预备知识 我们描述的算法都将是可以互换的。每个算法都将接收包含一些元素的数组；假设所有的数组位置都包含要排序的数据。我们还假设N是传递到排序程序的元素个数。 除（引用）赋值运算外，这是仅有允许对输入数据进行的操作。在这些条件下的排序叫做基于比较的排序 7.2 插入排序 插入排序由N-1趟组成。对于p=1到N-1趟，插入排序保证从位置0到位置p上的元素为已排序状态。插入排序利用了这样的事实：...
《数据结构》第7章 排序（C语言描述）
不问归期的博客
04-03 435
排序(Sort)是将无序的记录序列（或称文件）调整成有序的序列。 为了方便讨论，在此首先要对排序下一个确切的定义： 假设含有n个记录的序列为 { R1、R2、，。。。Rn } 其相应的关键字序列为 {K1、K2，。。。。Kn} 需确定1，2，。。。，n的一种排列 p1,p2,。。。pn，使其相应的关键字满足如下的非递减（或非...
数据结构作业：第10章排序答案.docx
12-18
本资源总结了数据结构中第10章排序的知识点，包括直接插入排序、堆排序、快速排序、冒泡排序、归并排序、希尔排序等多种排序算法的基本概念、操作原理、时间复杂度、稳定性等方面的内容。 1. 直接插入排序： 直接...
数据结构作业：第10章排序题目.docx
12-17
数据结构作业：第10章排序题目 数据结构中的排序算法是指对一组记录按照一定的顺序排列的过程。排序算法是数据结构中的一个基本概念，广泛应用于各种数据处理和分析领域。本篇作业总结了第10章排序题目，涵盖了直接...
数据结构-第7章 查找.ppt
09-17
数据结构第七章查找 查找是数据结构中的一种基本操作，查找表是由同一类型的数据元素或记录构成的集合。查找表可以分为静态查找表和动态查找表两种，静态查找表不允许修改操作，而动态查找表可以进行修改操作。查找...
数据结构教学课件：第7章 排序
05-17
数据结构教学课件：第7章 排序
数据结构课件：14 第七章 排序.ppt
06-05
数据结构课件：14 第七章 排序.ppt
一篇看懂冒泡排序Bubble Sort算法与代码
weixin_45803426的博客
04-06 232
目录原理代码实现性能分析稳定性 原理 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单基础的排序算法。其基本思路是，对于一组要排序的元素列，依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面，如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成。 一趟冒泡结束后，最大的数在最后面，再遍历未排序区间，第二趟结束后，最大的两个数在后面，循环这个步骤，全部排序完成数组有序。 代码实现 基本代码： public static void b
【数据结构与算法】冒泡排序算法（BubbleSort）
深入挖掘，筑基为先；知其然，知其所以然。
01-26 5160
C 语言，Python 语言和 Java 语言描述的冒泡排序算法，来看看它们之间的异同吧 ！
c语言中void bubble,C语言 冒泡排序 Bubble Sort
weixin_34982065的博客
05-18 1413
算法描述：有数组array，其长度为len。第一轮工作从末尾开始往前比较工作。如果末尾数据比他前一位数据大，则交换他们的位置，否则则不交换。无论本次比较的结果是交还是不交换，这两个数据都遵循了前一个数据比后一个数据大的结果。接下里向前移动一个工作位置，重复以上的操作。这样一轮比较结束。大的数据不断往前移动。如果他是最大的，就会一直往前移动。如果不是则说明数组前面中还有比他大的数据，该数据也尝试向前...
数组：冒泡排序
ACE_YOUNG的博客
09-12 732
void bubble_sort(int arr[], int sz) { int i = 0; for (i = 0; i<sz - 1; i++) { int j = 0; for (j = 0; j<sz - i - 1; j++) { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; ...
冒泡算法Bubble sort（最基础的排序算法）
m0_61198445的博客
03-06 699
目录1.初识冒泡排序 参考书籍：《漫画算法：小灰的算法之旅》 1.初识冒泡排序 想要学习排序算法，最好是先从“冒泡排序”开始学起，因为这是最基础的排序算法。 什么是冒泡排序？ 冒泡排序之所以叫冒泡排序，正是因为这种排序算法的每一个元素都可以相小气泡一样，更自身的大小，一点一点地向着数组的一侧移动。 按照冒泡排序的思想，我们要把相邻的元素两两比较，当一个元素大于右侧相邻元素时，交换他们的位置；当一个元素小于或等于右侧相邻元素时，位置不变。 例如有这样的一个无序数列 {5，8，6，3，9，2，1，7}
c语言中void bubble,（C语言）实现冒泡排序的函数
weixin_42188533的博客
05-18 2205
实现冒泡排序的函数题目：写一个函数实现冒泡排序功能，函数原型：void bubbleSort(int data[],int n);待排序数据存储在一维整型数组data中，排序后的结果也存储在该数组中。函数内部不能有任何输入与输出操作。如果函数采用其他方法正确实现了排序操作，而不是冒泡排序，可以得一半的分数，如果有错误，则根据错误情况扣分。你需要先自己写main函数测试您的bubblSort函数是否...
中国大学MOOC-陈越、何钦铭-数据结构-2019秋期末考试
Henry_626的博客
12-18 5090
对不住啦兄弟萌，因为时间关系我先把我的练习总和发出来，总结和解析之后会更新哒~ 一、判断题： 1-1 对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。 【F】 1-2 2N​ 和 NN​ 具有相同的增长速度。 【F】 1-3 若一棵平衡二叉树的所有非叶结点的平衡因子都是0，则其必为完美二叉树【T】 1-4 在任一有向图中，所有顶点的入度之和等于所有顶...
【数据结构】用C++实现单链表的各种操作（包括头删，尾删，插入，逆序，摧毁，清空等等）
韩豆豆的博客
05-22 1183
//头文件 #ifndef _LIST_H #define _LIST_H #include using namespace std; template class List; template class ListNode { friend class List; public: ListNode() :data(Type()), next(NULL) {} ListNod
数据结构最少交换排序
最新发布
09-09
简单选择排序是数据结构中一种常见的交换排序算法。它通过每次选择一个最小（或最大）的元素，并将其与待排序序列的第一个元素交换，从而逐步将最小（或最大）的元素归位。这个过程重复进行，直到所有的数据元素都...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值