排序

排序

2017年03月17日15:05:14

選擇排序

選擇排序思想：外層遍歷整個待排數組，內層循環尋找 arr [ i, n )區間最小值索引，在外層循環中將其索引位置元素與arr[ i ]交換位置；并擴大有序數組范圍。直至排序完成。

時間復雜度：O(n^2)

穩定性：穩定

/**
 * 選擇排序
 *
 * @param arr
 * @param n
 */
template<typename T>
void selectionSort(T arr[], int n) {
    for (int i = 0; i < n; ++i) {

        //尋找[i, n)區間的最小值
        int minIndex = i;
        for (int j = i + 1; j < n; ++j) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
      swap(arr[minIndex], arr[i]);
      }
}

插入排序

排序思想：外層遍歷整個待排數組，內層循環尋找 arr [ i ] 元素在 arr [ 0, i ）區間內的自己的位置并保證arr [ 0 , i ]有序，擴大有序數組范圍。直至排序完成。

時間復雜度：最差：O(n^2)， 最好: O(n)，因此在多數nlogn的排序末端（小數據量下）會使用插入排序進行優化

穩定性：穩定

    /**
     * 插入排序
     *
     * @param arr
     * @param n
     */
    template<typename T>
    void insertionSort(T arr[], int n) {
        for (int i = 1; i < n; i++) {
        //每次內層循環找到應該arr[j]的位置
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
            
                swap(arr[j], arr[j - 1]);
            }
        }
    }

    /**
     * 插入排序,改進版，利用一個單位空間，將一次交換替換為賦值
     *
     * @param arr
     * @param n
     */
    template<typename T>
    void insertionSortBeat(T arr[], int n) {
        for (int i = 1; i < n; i++) {
            //尋找arr[i]的插入位置
            T nux = arr[i];
            int j;      //保存arr[i]應該的插入位置
            for (j = i; j > 0 && arr[j - 1] > nux; j--) {
                arr[j] = arr[j - 1];
            }
            //將nux 放入其應該存在的位置
            arr[j] = nux;
        }
    }


/**
 * 插入排序,改進版，利用一個單位空間，將一次交換替換為一次賦值.
 * 用途：排序數組部分區間
 *
 * @param arr
 * @param n
 */
template<typename T>
void insertionSortBeat(T arr[], int l, int r) {
    for (int i = l+1; i <= r; i++) {

        //尋找arr[i]的插入位置
        T nux = arr[i];
        int j;      //保存arr[i]應該的插入位置
        for (j = i; j > l && arr[j - 1] > nux; j--) {

            arr[j] = arr[j - 1];
        }
        //將nux 放入其應該存在的位置
        arr[j] = nux;
    }
}

二路歸并排序

排序思想：利用分治算法將大問題削減成小問題并對小問題進行解決。先將數組分為左右兩段，并遞歸的分成n段，每段都是一個元素的時候，該數組段就是有序的，在遞歸返回的時候進行兩個有序數組的合并，將會得到排序好的數組。

時間復雜度：O(nlgn)

穩定性：穩定

優化點：1. 在小數據量是采用插入排序進行效率的提升。 2. 在合并兩個數組的時候當其前后已經有序的時候直接返回，減少合并次數。

template<typename T>
void __mergeSort(T arr[], int l, int r);

template<typename T>
void __merge(T arr[], int l, int mid, int r);

/**
 * 歸并排序
 *
 * @param arr
 * @param n
 */
template<typename T>
void mergeSort(T arr[], int n) {

    __mergeSort(arr, 0, n - 1);
}

//采用arr[l, r]
template<typename T>
void __mergeSort(T arr[], int l, int r) {

    if (l >= r) {
        return;
    }

    int mid = l + (r - l) / 2;

    //遞歸劃左右分子區間
    __mergeSort(arr, l, mid);

    __mergeSort(arr, mid + 1, r);

    //優化點：當要合并的數組前后無序的時候才進行合并，有序直接返回。減少合并次數，提高效率
    if (arr[mid] > arr[mid + 1]) {
        //合并
        __merge(arr, l, mid, r);
    }

}

template<typename T>
//合并兩個有序數組（采用額外的輔助空間進行合并）
void __merge(T arr[], int l, int mid, int r) {

    //采用額外空間輔助排序，也可直接在原數組進行排序
    T aux[r - l + 1];
    for (int i = l; i <= r; i++) {
        aux[i - l] = arr[i];
    }


    int i = l, j = mid + 1;
    for (int k = l; k <= r; k++) {

        if (i > mid) {
            arr[k] = aux[j - l];
            j++;
        } else if (j > r) {
            arr[k] = aux[i - l];
            i++;
        } else if (aux[i - l] < aux[j - l]) {
            arr[k] = aux[i - l];
            i++;
        } else {
            arr[k] = aux[j - l];
            j++;
        }
    }
}

template<typename T>
void __merge(T arr[], int l, int mid, int r);

template<typename T>
void __mergeSortBeat(T arr[], int l, int r);

/**
 * 歸并排序,優化版
 * 當數據量比較小的時候采用插入排序
 *
 * @param arr
 * @param n
 */
template<typename T>
void mergeSortBeat(T arr[], int n) {

    __mergeSortBeat(arr, 0, n - 1);
}

template<typename T>
//合并兩個有序數組（采用額外的輔助空間進行合并）
void __merge(T arr[], int l, int mid, int r) {

    //采用額外空間輔助排序，也可直接在原數組進行排序
    T aux[r - l + 1];
    for (int i = l; i <= r; i++) {
        aux[i - l] = arr[i];
    }


    int i = l, j = mid + 1;
    for (int k = l; k <= r; k++) {

        if (i > mid) {
            arr[k] = aux[j - l];
            j++;
        } else if (j > r) {
            arr[k] = aux[i - l];
            i++;
        } else if (aux[i - l] < aux[j - l]) {
            arr[k] = aux[i - l];
            i++;
        } else {
            arr[k] = aux[j - l];
            j++;
        }
    }
}

//采用arr[l, r]，當排序數據量較小的時候采用插入排序提高效率
template<typename T>
void __mergeSortBeat(T arr[], int l, int r) {

    if (r - l < 15) {
        insertionSortBeat(arr, l, r);
        return;
    }

    int mid = l + (r - l) / 2;

    //遞歸劃左右分子區間
    __mergeSortBeat(arr, l, mid);

    __mergeSortBeat(arr, mid + 1, r);

    //優化點：當要合并的數組前后無序的時候才進行合并，有序直接返回。減少合并次數，提高效率
    if (arr[mid] > arr[mid + 1]) {
        //合并
        __merge(arr, l, mid, r);
    }

}


/**
 * 自低向上的歸并排序
 *
 * @tparam T
 * @param arr
 * @param n
 */
template<typename T>
void mergeSortBU(T arr[], int n) {

    //sz 未每次比較的寬度，每完成一圈底部歸并，比較寬度變為原來的2倍繼續比較，直到寬度超過數組長度
    for (int sz = 1; sz < n; sz += sz) {
        //i 為比較區間的開始位置，每次增加兩個比較寬度，進行下部分的比較，保證有兩個區間可以進行比較，則第二區間必須存在：i+sz<n
        for (int i = 0; i + sz < n; i += sz + sz) {
            //優化點：1. 對于較小的數據集合使用插入排序；2. 對于已經有序的數組不在進行合并

            //歸并操作
            //對arr[i,i+sz-1]和arr[i+sz,i+sz+sz-1]或arr[i+sz,n-1]進行歸并,避免越界
            __merge(arr, i, i + sz - 1, min(i + sz + sz - 1, n - 1));
        }
    }

}

/**
 * 自低向上的歸并排序加強版
 * 優化點：1. 對于較小的數據集合使用插入排序；2. 對于已經有序的數組不在進行合并
 *
 * @tparam T
 * @param arr
 * @param n
 */
template<typename T>
void mergeSortBUBeat(T arr[], int n) {

    //sz 未每次比較的寬度，每完成一圈底部歸并，比較寬度變為原來的2倍繼續比較，直到寬度超過數組長度
    for (int sz = 1; sz < n; sz += sz) {

        //i 為比較區間的開始位置，每次增加兩個比較寬度，進行下部分的比較，保證有兩個區間可以進行比較，則第二區間必須存在：i+sz<n
        for (int i = 0; i + sz < n; i += sz + sz) {

            //優化點：1. 對于較小的數據集合使用插入排序；2. 對于已經有序的數組不在進行合并
            if (sz < 15) {

                //使用插入排序進行優化小數據量排序
                insertionSortBeat(arr, i, min(i + sz + sz - 1, n - 1));
                break;
            }

            //優化點：2. 對于已經有序的數組不在進行合并
            if (arr[i + sz - 1] > arr[i + sz]) {

                //歸并操作
                //對arr[i,i+sz-1]和arr[i+sz,i+sz+sz-1]或arr[i+sz,n-1]進行歸并,避免越界
                __merge(arr, i, i + sz - 1, min(i + sz + sz - 1, n - 1));
            }
        }
    }
}

快速排序

排序思想：選定一個標定元素，尋找其在排好序數組的位置，將數組分為兩部分（三部分），在對剩下的部分進行遞歸尋找標定元素的位置

時間復雜度：最好：O(nlgn), 最壞:O(n^2); 采用隨機化標定選擇使時間復雜度期望為O(nlogn).

穩定性：不穩定

優化點：1. 對于較小的數據集合使用插入排序，2：采用二路快速排序優化使其適應近乎有序的數組，3： 使用3路快速排序使其適應有大量相同元素的數組

template<typename T>
void __quickSort(T arr[], int l, int r);

template<typename T>
int partition(T arr[], int l, int r);

/**
 * 快速排序
 *
 * @tparam T
 * @param arr
 * @param n
 */
template<typename T>
void quickSort(T arr[], int n) {

    __quickSort(arr, 0, n - 1);
}

//對arr[l,r]部分進行快速排序
template<typename T>
void __quickSort(T arr[], int l, int r) {

//    if(l>=r){
//        return;
//    }

    //優化1：對于較小的數據集合使用插入排序
    if (r - l <= 15) {
        insertionSortBeat(arr, l, r);
        return;
    }


    int p = partition(arr, l, r);

    __quickSort(arr, l, p - 1);
    __quickSort(arr, p + 1, r);
}

//對arr[l,r]部分進行partition操作
//返回p,使得arr[l,p-1]<arr[p];arr[p+1]>arr[p]
template<typename T>
int partition(T arr[], int l, int r) {

    //第一個元素標識為基準
    T v = arr[l];

    //p為基準元素應該在的位置
    int j = l;
    for (int i = l + 1; i <= r; i++) {
        if (arr[i] < v) {
            swap(arr[j + 1], arr[i]);
            j++;
        }
    }
    swap(arr[l], arr[j]);

    return j;
}


template<typename T>
void __quickSortRand(T arr[], int l, int r);

template<typename T>
int partitionRand(T arr[], int l, int r);

/**
 * 隨機化快速排序，提高在近乎有序的數組中進行排序的效率
 *
 * @tparam T
 * @param arr
 * @param i
 */
template<typename T>
void quickSortRand(T arr[], int n) {

    srand(time(NULL));
    __quickSortRand(arr, 0, n - 1);
}

//對arr[l,r]部分進行快速排序
template<typename T>
void __quickSortRand(T arr[], int l, int r) {

    //優化1：對于較小的數據集合使用插入排序
    if (r - l <= 15) {
        insertionSortBeat(arr, l, r);
        return;
    }


    int p = partitionRand(arr, l, r);

    __quickSortRand(arr, l, p - 1);
    __quickSortRand(arr, p + 1, r);
}

//對arr[l,r]部分進行partition操作
//返回p,使得arr[l,p-1]<arr[p];arr[p+1]>arr[p]
template<typename T>
int partitionRand(T arr[], int l, int r) {

    swap(arr[l], arr[rand() % (r - l + 1) + l]);

    //第一個元素標識為基準
    T v = arr[l];

    //j為基準元素應該在的位置
    int j = l;
    for (int i = l + 1; i <= r; i++) {
        if (arr[i] < v) {
            swap(arr[j + 1], arr[i]);
            j++;
        }
    }
    swap(arr[l], arr[j]);

    return j;
}


template<typename T>
void __quickSort2(T arr[], int l, int r);

template<typename T>
int partition2(T arr[], int l, int r);

/**
 * 2路快速排序
 *
 * @tparam T
 * @param arr
 * @param n
 */
template<typename T>
void quickSort2(T arr[], int n) {

    srand(time(NULL));
    __quickSort2(arr, 0, n - 1);
}

template<typename T>
void __quickSort2(T arr[], int l, int r) {

    if (r - l <= 15) {
        insertionSortBeat(arr, l, r);
        return;
    }

    int p = partition2(arr, l, r);

    __quickSort2(arr, l, p - 1);
    __quickSort2(arr, p + 1, r);

}

template<typename T>
int partition2(T arr[], int l, int r) {

    swap(arr[l], arr[rand() % (r - l + 1) + l]);

    T v = arr[l];

    int i = l + 1, j = r;

    while (true) {
        while (i <= r && arr[i] < v) {
            i++;
        }

        while (j >= l + 1 && arr[j] > v) {
            j--;
        }

        if (j < i) {
            break;
        }

        swap(arr[i], arr[j]);
        i++;
        j--;
    }

    swap(arr[l], arr[j]);

    return j;
}





template<typename T>
void __quickSort3Ways(T arr[], int l, int r);

/**
 * 3路快速排序
 *
 * @tparam T
 * @param arr
 * @param n
 */
template<typename T>
void quickSort3Ways(T arr[], int n) {

    srand(time(NULL));
    __quickSort3Ways(arr, 0, n - 1);
}

/**
 * 3路快速排序
 *
 * @tparam T
 * @param arr
 * @param l
 * @param r
 */
template<typename T>
void __quickSort3Ways(T arr[], int l, int r) {

    if (r - l <= 15) {
        insertionSortBeat(arr, l, r);
        return;
    }

    //partition3Ways
    swap(arr[l], arr[rand() % (r - l + 1) + l]);

    T v = arr[l];

    int lt = l;         //arr[l+1, lt] < v
    int gt = r + 1;     //arr[gt, r] > v
    int i = l + 1;      //arr[lt+1, i) == v

    while (i < gt) {

        if (arr[i] > v) {
            swap(arr[i], arr[gt - 1]);
            gt--;
        } else if (arr[i] < v) {
            swap(arr[i], arr[lt + 1]);
            lt++;
            i++;
        } else {
            i++;
        }
    }

    //交換標識位置到其應該存在的位置
    swap(arr[l], arr[lt]);

    __quickSort3Ways(arr, l, lt - 1);
    __quickSort3Ways(arr, gt, r);

}

堆排序

排序思想：動態的數組進行排序，將數組轉化為大（小）頂堆，在對頂元素與尾元素交換，并對堆重新轉化為大小頂堆。繼續交換，轉化。

時間復雜度：O(nlgn)

穩定性：不穩定


template<typename T>
void __shiftDown(T arr[], int n, int k)

/**
 * 堆排序
 *
 * @tparam T
 * @param arr
 * @param n
 */
template<typename T>
void heapSort(T arr[], int n) {

    //heapify
    for (int i = (n - 1 - 1) / 2; i >= 0; i--) {
        __shiftDown(arr, n, i);
    }

    //數組元素在減少
    for (int j = n-1; j > 0; j--) {
        swap(arr[0],arr[j]);
        __shiftDown(arr, j, 0);  //j為未排序堆元素個數
    }
}

/**
 * shiftDowm(調整堆)
 *
 * @tparam T
 * @param arr
 * @param n
 * @param k
 */
template<typename T>
void __shiftDown(T arr[], int n, int k) {

    T v = arr[k];
    while (2 * k + 1 < n) {

        int j = k * 2 + 1;
        if (j + 1 < n && arr[j + 1] > arr[j]) {
            j += 1;
        }
        if ( v >= arr[j] ) {
            break;
        }
        arr[k] = arr[j];
        k = j;
    }
    arr[k] = v;
}
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 229,698評論 6贊 539
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 99,202評論 3贊 426
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 177,742評論 0贊 382
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 63,580評論 1贊 316
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 72,297評論 6贊 410
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 55,688評論 1贊 327
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,693評論 3贊 444
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 42,875評論 0贊 289
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 49,438評論 1贊 335
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 41,183評論 3贊 356
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 43,384評論 1贊 372
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 38,931評論 5贊 363
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,612評論 3贊 348
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 35,022評論 0贊 28
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 36,297評論 1贊 292
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 52,093評論 3贊 397
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 48,330評論 2贊 377

推薦閱讀更多精彩內容

  • 總結一下常見的排序算法。 排序分內排序和外排序。內排序:指在排序期間數據對象全部存放在內存的排序。外排序:指在排序...
    jiangliang閱讀 1,365評論 0贊 1
  • 一. 寫在前面 要學習算法，“排序”是一個回避不了的重要話題，在分析完并查集算法和常用數據結構之后，今天我們終于可...
    Leesper閱讀 2,545評論 0贊 40
  • 點我報名 讀書和鍛煉一樣，隔一天看，沒有任何區別；隔一個月看，差異甚微；但是隔五年十年看，身體和精神狀態上就有了巨...
    零食工叁叁閱讀 400評論 0贊 0
  • 中午休息翻群信息，群里炸開了鍋，無非是收了錢求點贊，卻沒有幾個人真正點贊。沒想到的是，群主也很支持這個觀點。無關對...
    霖臨說閱讀 475評論 2贊 49
  • 2017年元旦放假，我們從圣保羅坐了3個小時的飛機，到達了巴西東北部的累西腓朋友家來迎接新年的到來，在累西腓的第三...
    蘑菇公舉閱讀 839評論 11贊 16