排序算法_总结与复习

直接插入排序：稳定排序 时间复杂度 O（n²）

void insertSort(int data[], int N){

    

    if(N < 2) return;

    

    for(int i = 1; i< N; ++i)

    {

        int temp = data[i];

        int j = i-1;

        while(j>=0 && data[j] > temp){

            data[j+1] = data[j];

            --j;

        }

        if(j != i-1)

            data[j+1] = temp;

    }

    

}

View Code

二分法插入排序：稳定排序 O（n²）

void binSort(int data[], int N){

    

    if(N < 2) return;

    int left, right, mid;

    for(int i = 1; i< N; ++i)

    {

        int temp = data[i];

        left = 0; right = i-1;

        while(left <= right)

        {

            mid = left>>1 + right>>1 ;

            if(temp < A[mid])

                right = mid - 1;

            else

                left = mid + 1;

        }

        

        for(int j = i-1; j >= left ; --j)

            A[j+1] = A[j];

            

        if(left != i)

            data[left] = temp;

    }

    

}

View Code

 

希尔排序： 不稳定排序 O(n^1.3)

//N data 的大小

//对于希尔排序，数据必须采用顺序存储的方式

void shellSort(int data[], unsigned int N)

{

    if(N < 2) return ;

    int increment = N>>1; //还有一种初始值为（N-1）/ 3

    //多个区段的直接插入排序

    for(; increment > 0; increment = increment >>1)

    {

        for(int i = increment ; i< N; ++i)

        {

            int temp = data[increnment];

            int j = i- increment;

            while(j>= 0 && data[j]>temp){

                data[j+increment] = data[j];

                j -= increment;

            }

            data[j+increment] = temp;

        }

    }



}

 选择排序： 不稳定排序(因为在选择好后的交换过程中可能会打乱相应的顺序)   O(n²)

void selectSort(int data[], int N)

{

    if(N < 2) return ;

    for(int i = 0; i< N-1; ++i)

    {

        int k = i;

        for(int j = i+1; j < N; ++j){

            if(data[j] <data[k])

                k = j;

        if(k != i){

            int temp = data[k];

            data[k] = data[i];

            data[i] = temp;

        }    

    }

}

 堆排序： 不稳定（内部交换略乱 无法保证稳定） O(nlogn) 初始数据的排列对于工作效率没有太大影响 （选择排序大类）

//数据存储为1.。。n 

void BuildMaxHeap(int A[], int n)

{

    for(int i = n>>1 ; i>0; --i)

        adjustDown(A, i,n);

        

}

void adjustDown(int A[], int k, int n)

{

    A[0] = A[k];

    int child = k*2;

    

    while(child <= n)

    {

        if(child < n && A[child+1] > A[child])

            ++child;

            

        if(A[child] > A[0]){

            A[k] = A[child];

            k = child;

            child = k*2;

        }else

            break;

        

    }    

    

    A[k] = A[0];

}



//数据存储为1.。。n 

void HeapSort(int A[], int n)

{

    BuildMaxHeap(A, n);

    for(int i = n; i >0; --i)

    {

        swap(A, 0, i);

        adjustDown(A, 0, i-1);

    }

}

 冒泡排序：稳定排序   稳定

void bubbleSort(int A[], int n)

{

    if(n < 2) break;

    for(int k = 0; k < n-1; k++)

    {

        bool no_swap = true;

        for(int i = 0; i < n-1-k; ++i)

        {

            

            if(A[i] > A[i+1])

            {

                int temp = A[i];

                A[i] = A[i+1];

                A[i+1] = temp;

                no_swap = false;

            }

            

        }

        

        if(no_swap == true) break;

    }

}

 快排：最坏情况 O(n²) 一般 O(nlogn) 不稳定  对于排好序的比较次数为n²/2  

void quickSort(int A[], int left, int right)

{

    if(left == right) return ;

    int i = left;

    int j = right;

    temp = A[i];

    while(i != j)

    {

        while(A[j] >= temp && i<j)--j;

        if(i<j) A[i++] = A[j];

        

        while(A[i] < temp && i<j)++i;

        if(i < j) A[j--] = A[i];

    }

    

    A[i] = temp;

    quick(A, left, i-1);

    quick(A, i+1, right);

}

快排非递归实现

int partion(vector<int> &data, int low, int high){



    int pivot = data[low];

    while(low < high){

    

        while(low<high && data[high] >= pivot) --high;

        if(low < high)

            data[low++] = data[high];

        while(low < high && data[low] < pivot) ++low;

        if(low <high)

            data[high--] = data[low];

    }

    

    data[low] = pivot;

    return low;

}



void qsort(vector<int> &data, int low, int high){



    assert(low < high);

    stack<int> s;

    s.push(low);

    s.push(high);

    

    while(!s.empty()){

         high = s.top();s.pop();

         low = s.top(); s.pop();

         mid = partion(data,low, high);

         if(low < mid -1){

            s.push(low);

            s.push(mid-1);

         }

         if(mid+1 < high){

            s.push(mid+1);

            s.push(high);

         }

    }

}

 

归并排序：稳定排序 辅助空间 O(n) 时间复杂度 O(nlogn) 

void merge(int A[], int AA[], int low, int mid, int high)

{

    int i, j, k;

    i = low; j = mid +1; k = low;

    while(i <= mid && j <=high){

        if(A[i] <= A[j])

            AA[k++] = A[i++];

        else

            AA[k++] = A[j++];

    }

    

    while(i <= mid) AA[k++] = A[i++];

    while(j <= high) AA[k++] = A[j++];

}

void mergePass(int A[], int AA[], int n, int length)

{



    int i = 0;

    while(i < n- length*2)

    {

        merge(A, AA, i, i+length-1, i + 2*length -1);

        i+= 2*length;

    }

    if(i + length -1 < n-1)

        merge(A, AA, i, i+length-1, n-1);

    else{

        for(; i< n; ++i)

            AA[i] = A[i] ;

    }

}



void mergeSort(int A[], int n)

{

    int *AA = new int[n];

    int length = 1;

    while(length < n){

        mergePass(A, AA, n, length);

        length >>= 1;

        mergePass(AA, A, n, length);

        length >>=  1;    

    }

}