經常使用的排序算法(一)

Date: 2016-02-14 #####排序算法的學習 ####冒泡排序

• 時間複雜度:當順序爲正序的時候，爲最好狀態時間複雜度爲O(N),平均時間複雜的爲O(N^2)
• 由於沒有建立新的存儲結構因此空間複雜度爲O(1)
• 冒泡排序是一種穩定的排序算法

#include <stdio.h>
void Bubble_sort(int A[],int n);

void Bubble_sort(int A[],int n){
    int i,j,temp;
    for(i= 0 ;i < n - 1 ;i++){
        for(j = 0;j< n -1 - i;j++){
            if(A[j] > A[j+1]){
                temp = A[j+1];
                A[j+1] = A[j];
                A[j] = temp;

            }

        }
    }

}

int main(int argc, const char * argv[]) {

    int A[7]={3,1,2,4,6,8,1};

    Bubble_sort(A, 7);

    for(int i =0; i < 7;i++){
        printf("%d",A[i]);

    }

}

####改進的冒泡排序

• 使用冒泡排序對N個數據進行排序，一共須要進行n-1次比較，原本是正常順序的數據也須要進行n-1次排序，因此當判斷全部的數據爲有序的時候不在進行排序直接跳出循環，

void Bubble_sort(int A[],int n){
    int i,j,temp,flag=0;
    for(i= 0 ;i < n - 1 ;i++){
        for(j = 0;j< n -1 - i;j++){
            if(A[j] > A[j+1]){
                temp = A[j+1];
                A[j+1] = A[j];
                A[j] = temp;
                flag = 1;

            }
        }
        if(flag== 0){
            break;
        }else{
            flag = 0;
        }
    }

}

####快速排序法

• 算法時間複雜度:最差時間爲(O(n^2))),平均時間複雜度爲O(n*log2n)
• 算法空間複雜度:O(log2n)~O(n)
• 快速排序法是經過一遍排序將須要排序的數據分爲兩部分，使其中一部分數據比另外一部分數據小，而後在分別對這兩部分數據進行這種排序，直到每一個部分爲空或者只含有一個數的時候，排序結束
• 快速排序是一種分治策略，將大批數據逐步分解，能夠使用遞歸的方式便攜程序

method: 變量left保存數組最小序號0，數組right保存數組最大（序號）長度n，在變量base 中保存A[0]爲基準,從數組右側開始逐個取出元素與base比較，若是小於base的值則將該數保存到A[left]中（A[0]）元素中，接下來從數組左側開始逐個取出元素與base比較知道找到比base大的數據,（left隨着比較的位數自增），將這個比基準大的數存到A[right]中，接下來遞歸進行一樣的操做

int Division(int a[],int left,int right){
    int base = a[left];     //取左側元素爲基準元素
    while(left<right){      //左側元素的序號小於右側
    while (left<right&&a[right]>base)  //當序號小於右側而且數組末尾的值大於基準,則向前挪一位(right-1)
        --right;
        a[left] = a[right];         //當找到了右側比基準小的數的時候令A[LEFT] 爲右側的值
    while(left<right&&a[left]<base)     //當序號小於右側時候，若是左側的數值比基準小則向後挪一位（left+1）
        ++left;
        a[right] = a[left];             //當找到左側比基準大的數字的時候，讓這個數字爲數組的末尾元素()
        }
    a[left] = base;             //保存基準數
    return left;        //返回左側的值
}

void QuickSort(int a[],int left,int right){

    int i, j;
    if(left<right){
        i = Division(a, left, right);
        QuickSort(a,left,i-1);  //左側的數進行遞歸排序
        QuickSort(a,i+1,right);     //右側的數進行遞歸排序
    }
}
int main(int argc, const char * argv[]) {
    // insert code here...
    int A[10]={94,84,54,80,62,83,37,24,67,29};

    QuickSort(A,0,9);

    for(int i = 0;i<10;i++){
        printf("%d",A[i]);
    }
    return 0;
}

####簡單選擇排序算法

• 時間複雜度:O(n2)
• 空間複雜的:O(1) method:對N個記錄進行掃描，選擇最小的記錄，將其輸出,接着在剩下的N-1個記錄中掃描,選擇最小的輸出，不斷重複這個過程,直到只剩一個記錄爲止

void selectSort(int A[],int n );

void selectSort(int A[],int n){
    int i,j,k,t;
    for(i = 0 ;i< n -1 ;i++){   //n-1位開始比較
        k = i;                  //獲取當前位數
        for(j =i+1 ;j< n;j++){
            if(A[k]>A[j]){      //若是當前位數大於數組[K,N]的任何一位則，當前該數爲[K,N]中最小的數
                k = j;
            }
        }
        t = A[i];       //進行交換
        A[i] =  A[k];
        A[k] = t;

    }
}
int main(int argc, const char * argv[]) {
    int A[8]={15,2,8,3,1,9,7,6};
    selectSort(A, 8);
    for(int i =0 ;i<8;i++){
        printf("%d",A[i]);
    }
}

####直接插入排序法

• 時間複雜度：O(N^2)
• 空間複雜度:O(1)
• method:經過構建有序序列，對於未排序的數據，在已排序的序列中從後向前掃描，找到相應的位置並插入該數據，使數據造成有序隊列

void insertSort(int A[],int n){
    int i,t,j;
    for(i = 1 ;i<n;i++){
        t= A[i];        //取出一個未排序的數據
        for(j=i-1;j>=0&&t<A[j];j--)     //在排序序列查找數據
            A[j+1] = A[j];              //向後移動數據
        A[j+1] = t;
    }

}
int main(int argc, const char * argv[]) {
    // insert code here...

    int A[6]={3,1,8,3,2,5};
    insertSort(A, 6);
    for(int i =0 ;i<6;i++){
        printf("%d",A[i]);
    }
    printf("Hello, World!\n");
    return 0;
}