【Algorithm】c++实现各种排序算法

学习中。。。

#include <iostream>

#define SIZE 10

using namespace std;

void print(int arr[], int n){
    for (int i = 0; i < n; i++)
        cout << arr[i] << ' ';
    cout << endl << endl;
}

void Swap(int &a, int &b){
    a += b;
    b = a - b;
    a -= b;
}
/*
冒泡排序：持续比较相邻两个数最多n趟
最好   最坏     平均     空间   稳定性 复杂性
O(n)   O(n^2)   O(n^2)   O(1)    稳定    简单
*/
void bubbleSort(int arr[], int n){
    for (int i = 0; i < n - 1; i++){
        int exchange = 0;
        for (int j = 0; j < n - 1; j++)
        if (arr[j] > arr[j + 1]){//升序     (arr[j] > arr[j + 1])//降序
            Swap(arr[j], arr[j + 1]);
            exchange++;
        }
        if (exchange == 0)  //如果某一趟一次也没有交换，则说明已经是一个有序序列
            break;
    }
}

/*
堆排序：构造大（降序）/小（升序）顶堆，
最好        最坏        平均        空间    稳定性   复杂性
O(nlog2n)   O(nlog2n)   O(nlog2n)   O(1)    不稳定    较复杂
*/

//该函数用于判断当前节点是否有左右子树，以及有必要的话交换当前节点与左右子节点中较小的那个
void heapSwap(int arr[],int root,int n){
    int left = 2 * root + 1;
    int right = 2 * (root + 1);
    if (right <= n){  //存在右节点，必定有左节点（完全二叉树）
        int min = arr[left] < arr[right] ? left : right;     //选出较小的放到顶上，再插到最后，降序
        if (arr[root] > arr[min]) //根节点较大，交换
            Swap(arr[root], arr[min]);
    }
    else if (left <= n)  //如果右节点大于n，而存在左节点的话
        if (arr[root] > arr[left])
            Swap(arr[root], arr[left]);

}

void heapAdjust(int arr[], int root, int n){/*待排数据，当前根节点索引，数组长度*/
    heapSwap(arr, root, n);  //交换根节点与较小节点
    int left = root * 2 + 1;
    int right = root * 2 + 2;
    if (left <= n)
        heapAdjust(arr, left, n);   //递归调整左子树
    if (right <= n)
        heapAdjust(arr, right, n);   //递归调整右子树，如果有的话
    heapSwap(arr, root, n);    //调整之后再交换根节点与左右子树，因为有可能调整之后左右子树又比根节点小了

}
void heapSort(int arr[], int n){
    for (int i= n-1; i >0; i--){
        heapAdjust(arr, 0, i);//调整为小顶堆
        Swap(arr[i], arr[0]);  //交换顶元素和最后一个元素
    }
}

/*
选择排序：每次从未排序的数组中找出最大（降序）或最小（升序）的元素与未排序数组最前面的元素交换
最好     最坏     平均     空间    稳定性   复杂性
O(n^2)   O(n^2)   O(n^2)   O(1)    不稳定    较简单

*/

void selectionSort(int arr[], int n){
    for (int i = 0; i < n; i++){
        int min = i;
        for (int j = i; j < n-1; j++){
            if (arr[j + 1]<arr[j])     //升序
                min = j + 1;
            if (min != i)
                Swap(arr[min], arr[i]);
        }
    }
}


/*
插入排序：将为排序的数组中下一个数插入到已排序序列的适当位置。
最好     最坏     平均     空间    稳定性   复杂性
O(n)     O(n^2)   O(n^2)   O(1)    稳定      较简单

*/

void insertionSort(int arr[], int n){
    for (int i = 1; i < n; i++){
        int tmp = arr[i];
        int j = 0;
        for (j = i - 1; j >= 0; j--)
            if (arr[j] < tmp)   //降序
                arr[j + 1] = arr[j];
        arr[++j] = tmp;
    }
}

/*
快速排序：挖坑填数
最好         最坏     平均       空间      稳定性     复杂性
O(nlogn)     O(n^2)   O(nlogn)   O(1)      不稳定      较简单

*/
void quickSort(int arr[], int n, int l, int r){
    if (l > r)
        return;
    int i = l, j = r, key = arr[i];
    while (i < j){
        while (i<j&&arr[j]>=key)
            j--;
        if (i < j){
            arr[i] = arr[j];
            i++;
        }
        while (i < j&&arr[i] < key)
            i++;
        if (i < j){
            arr[j] = arr[i];
            j--;
        }
        arr[i] = key;
        quickSort(arr, n, l,i-1);
        quickSort(arr, n, i+1, r);
    }
}





int main(){
    int arr1[SIZE] = { 1, 2, 3, 5, 6, 4, 7, 9, 8, 0 };
    int arr2[SIZE] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    cout << "源数组：" << endl;
    print(arr1, SIZE);
    //冒泡排序：升序
    bubbleSort(arr1, SIZE);
    cout << "冒泡排序：升序" << endl;
    print(arr1, SIZE);
    //堆排序：降序
    cout << "堆排序：降序" << endl;
    heapSort(arr1, SIZE);
    print(arr1, SIZE);
    //选择排序：升序
    cout << "选择排序：升序" << endl;
    selectionSort(arr1, SIZE);
    print(arr1, SIZE);
    //插入排序：降序
    cout << "插入排序：降序" << endl;
    insertionSort(arr1, SIZE);
    print(arr1, SIZE);
    //快速排序：升序
    cout << "快速排序：升序" << endl;
    quickSort(arr1, SIZE, 0, SIZE-1);
    print(arr1, SIZE);


    system("pause");
    return 0;
}