排序算法小結：C++實現

#include<vector>
#include<iostream>

//排序算法的穩定性：對於相同的關鍵字，排序以前的位置和排序以後的位置相同，則稱爲穩定排序，不然不穩定排序。

//歸併排序:基本思想爲:先分解再合併，在合併的過程當中進行排序;
//穩定排序；平均時間複雜度爲:O(nlogn);  最好時間複雜度O(nlogn);最好時間複雜度O(nlogn)；空間複雜度O(n); 
void Meger(std::vector<int> &data, int begin, int mid,int end) {
    if (begin == end) {
        return;
    }

    int length = end - begin+1;

    std::vector<int> temp(length);

    int i = begin;
    int j = mid+1;
    int k = 0;
    while (i <= mid&&j <= end) {
        if (data[i] <= data[j]) {
            temp[k++] = data[i++];
        }
        else {
            temp[k++] = data[j++];
        }
    }

    while (i <= mid) {
        temp[k++] = data[i++];
    }

    while (j <= end) {
        temp[k++] = data[j++];
    }

    for (i = 0; i < k; i++) {
        data[begin + i] = temp[i];
    }
}

void Divide(std::vector<int> &data, int begin, int end) {

    if (begin>=end) {
        return;
    }

    int mid = (begin + end) / 2;

    Divide(data, begin, mid);
    Divide(data, mid+1, end);

    Meger(data, begin,mid, end);
}

void Meger_Sort(std::vector<int> &data) {
    if (data.empty()) {
        return;
    }

    Divide(data, 0, data.size()-1);

    for (auto each : data) {
        std::cout << each << "\n";
    }
}


//Quick Sort:  找到中間分割點，根據中間分割點進行排序，再遞歸。
//不穩定；平均時間複雜度O(nlogn); 最好時間複雜度O(nlogn);最壞時間複雜度O(n^2);空間複雜度O(logn)
int Partition(std::vector<int> &vec, int left, int right) {
    int X = vec[left];
    while (left < right) {
        while (vec[right] > X) {
            right--;
        }
        if (left < right) {
            vec[left] = vec[right];
            left++;
        }

        while (vec[left] <= X) {
            left++;
        }
        if (left < right) {
            vec[right] = vec[left];
            right--;
        }
    }
    vec[right] = X;
    return right;
}

void Quick_Sort(std::vector<int> &vec,int left,int right) {
    if (vec.empty()) {
        return;
    }

    if (left < right) {
        int p = Partition(vec, left, right);
        Quick_Sort(vec, left, p - 1);
        Quick_Sort(vec, p + 1, right);
    }
}

//選擇排序
//不穩定；平均時間複雜度O(n^2); 最好時間複雜度O(n^2);最壞時間複雜度O(n^2);空間複雜度O(1)
void Select_Sort(std::vector<int> &vec) {
    for (int i = 0; i < vec.size()-1; i++) {
        int mini_index = i;
        for (int j = i+1; j < vec.size(); j++) {
            if (vec[j] < vec[mini_index]) {
                mini_index = j;
            }
        }
        std::swap(vec[i], vec[mini_index]);
    }
}

//冒泡排序
//穩定；平均時間複雜度O(n^2); 最好時間複雜度O(n);最壞時間複雜度O(n^2);空間複雜度O(1)
void Bubble_Sort(std::vector<int> &vec) {
    //普通版本；
    for (int i = 0; i < vec.size(); ++i) {
        for (int j = 1; j < vec.size() - i; ++j) {
            if (vec[j-1] > vec[j]) {
                std::swap(vec[j-1], vec[j]);
            }
        }
    }
}

void fast_Bubble_Sort(std::vector<int> &vec) {
    //fast 版本；
    int flag = vec.size();
    int len = flag;
    while (flag) {
        flag = 0;
        for (int i = 1; i < len; ++i) {
            if (vec[i - 1] > vec[i]) {
                std::swap(vec[i - 1], vec[i]);
            }
            flag = i;
        }
        len = flag;
    }

}

//插入排序
//穩定；平均時間複雜度O(n^2); 最好時間複雜度O(n);最壞時間複雜度O(n^2);空間複雜度O(1)
void Insert_Sort(std::vector<int> &vec) {
    for (int i = 1; i < vec.size(); ++i) {
        int temp = vec.at(i);
        int j = i - 1;
        while (j >= 0&&vec.at(j) > temp) {
            vec[j + 1] = vec[j];
            j--;
        }
        vec[j+1] = temp;
    }
}

//堆排序：先創建一個大根堆，而後將堆頂元素和隊列尾的元素進行交換，這樣就等於大元素放到隊尾了每次交換，
//       須要對堆進行調整。
//不穩定；平均時間複雜度O(nlogn); 最好時間複雜度O(nlogn);最壞時間複雜度O(nlogn);空間複雜度O(1)
void adjustHeap(std::vector<int> &vec, int index,int length) {
    
    int temp = vec[index];

    //首先將該元素與其左子節點元素進行比較
    for (int k = 2 * index + 1; k < length; k = 2 * k + 1) {

        //對左右節點進行比較，若是右節點比較大，更換成右節點
        if (k + 1 < length&&vec[k] < vec[k + 1]) {
            k++;
        }

        if (vec[k] >temp) {
            vec[index] = vec[k];
            index = k;
        }
        else
        {
            break;
        }
    }

    vec[index] = temp;
}

void HeapSort(std::vector<int> &vec) {

    int length = vec.size();
    if (length == 0) {
        return;
    }

    //構建最大堆；
    for (int i = length / 2 - 1; i >= 0; i--) {
        adjustHeap(vec, i, length);
    }

    //大堆頂元素逐個與末尾元素進行交換。
    for (int i = length - 1; i > 0; i--) {
        std::swap(vec[i], vec[0]);
        adjustHeap(vec, 0,i);
    }
}


//Main 函數測試部門；
int main() {

    std::vector<int> vec = { 10,6,1,9,3,11,7,2,12,8,5,4,13 };
    HeapSort(vec);
    for (auto each : vec) {
        std::cout << each << "\n";
    }
    return 0;
}