《算法导论》学习笔记之一 排序算法1 (插入排序、选择排序、归并排序)实现代码C++

最近在看《算法导论》第三版的书，相信很多同学都看过这本神作。

针对前几章书中出现的排序算法，我个人参照书中的 伪代码 拿 C++代码 重新实现

-------有写的不好的地方，请各位同学见谅--------------------------------------------------------

源码下载：点击我

注意：这里我们是对一个 未排序的数组 进行操作，该数组为 ：

int A[14] ={27, 17, 3, 16, 13, 10, 1, 5, 7, 12, 4, 8, 9, 0};

以下所有排序都是对数组进行 升序排序；

主函数：

//main.cpp
//

#include "sort.h"


int main()
{
        int A[14] =     {27, 17, 3, 16, 13,
                         10, 1, 5, 7, 12,
                         4, 8, 9, 0};
        int* p = &A[0];
        //
        //Insert_Sort_Ascending(p, 14);         //插入排序
        //Selection_Sort_Ascending(p, 14);      //选择排序
        //Bubble_Sort_Ascending(p, 0, 14);      //冒泡排序
        Merge_Sort_Ascending(p, 0, 13);         //归并排序
        //
        for (int i=0; i<14; i++)
        {
                cout<<A[i]<<",";
        }

        //
        int a;
        cin>>a;
        return 0;
}

----------------------------------------------------------------------------------------------------------------------------------------------

1. //插入排序Insert_sort   

bool Insert_Sort_Ascending ( int* pArray , int ArrayLength )
{
             int i ,j ;
             int key ;
             for ( j= 1 ; j <ArrayLength ; j ++)
             {
                         key = pArray [ j]; //将插入的数作为key；
                         i = j - 1 ;                                                 
                         while ((i >= 0)&&( pArray [i ]> key))  //将插入的数与前一个数做比较；
                         {
                                     pArray [i + 1] = pArray [ i];  //如果前一个数大于key，则前一个数后移一位；
                                     i = i - 1;
                         }
                         pArray [i + 1] = key ;
             }
             cout <<"Insert_Sort_Ascending:" ;
             return true ;
} //end Insert_Sort_Ascending

--插入排序具有 最坏情况运行时间O(n^2）

2. //选择排序算法The Selection Sort_Ascending 

 首先找出A中的最小元素并将其与A[1]中的元素进行交换。接着，找出A中的次最小元素将其与A[2}中的元素进行交换。对A中前n-1个元素按该方式继续。称该方法为选择算法。

bool Selection_Sort_Ascending(int* pArray, int ArrayLength)
{
        for(int j=0; j<ArrayLength-1; j++)
        {
                int smallest = j;                  //把j元素作为最小的元素
                for (int i=j+1; i<ArrayLength; i++)
                {
                        if (pArray[i] < pArray[smallest])//如果这个元素比第一个元素小，把这个元素作为最小的
                                smallest = i;
                }
                int key              = pArray[j]; //交换最小的元素与j元素;
                pArray[j]         = pArray[smallest];
                pArray[smallest] = key;
        }
        cout<<"Selection_Sort_Ascending:"
        return true;}//end Selection_Sort_Ascending

--选择排序具有 任何 情况运行时间O(n^2）

3. //The Bubble Sort 冒泡排序

冒泡排序是反复比较、交换相邻的未按次序排列的元素

bool Bubble_Sort_Ascending(int* pArray, int start, int ArrayLength){

        for (int i=0; i<ArrayLength-1; i++)
                for (int j=ArrayLength-1; j>i; j--)
                {
                        if (pArray[j]<pArray[j-1])
                        {
                                int key = pArray[j];
                                pArray[j] = pArray[j-1];
                                pArray[j-1] = key;
                        }
                }
                cout<<"Bubble_Sort_Ascending:";
        return true;}//end Bubble_Sort_Ascending

--冒泡排序具有运行时间O(n^2）

4.//The Merge Sort 归并排序算法

void Merge(int *a, int p, int q, int r){
        int n1 = q-p+1;
        int n2 = r-q;
        int *L = new int[n1+1];
        int *R = new int[n2+1];
        int i, j, k;
 
        for (i=0; i<n1; i++){
                L[i] = a[p+i];
        }
        for (j=0; j<n2; j++){
                R[j] = a[q+j+1];
        }
        L[n1] = 10000000;
        R[n2] = 10000000;
 
        for (i=0, j=0, k=p; k<=r; k++)
        {
                if (L[i]<=R[j])
                {
                        a[k] = L[i];
                        i++;
                }else{
                        a[k] = R[j];
                        j++;
                }
        }
        delete []L;
        delete []R;}
bool Merge_Sort_Ascending(int* pArray, int start, int ArrayLength){
        if (start<ArrayLength)
        {
                int middle = (start+ArrayLength)/2;
                Merge_Sort_Ascending(pArray, start, middle);
                Merge_Sort_Ascending(pArray, middle+1, ArrayLength);
                Merge(pArray, start, middle, ArrayLength);
        }
        return true;}//end Merge_Sort_Ascending

--归并排序在最坏的情况下，运行时间为O(nlog n)