排序算法

排序算法，记录一下，便于下次自己看

#include <iostream>

template<typename Type>
void print(Type arr[], int len) {
    for (auto i{ 0 }; i < len; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

// 插入排序 
void InsertSort(int arr[], int len) {
    for (auto i{ 1 }; i < len; ++i) {
        auto tmp = arr[i];
        auto j{ i - 1 };
        for (; j >= 0; --j) {
            if (tmp >= arr[j]) {
                break;
            }

            arr[j + 1] = arr[j];
        }

        arr[j + 1] = tmp;
    }
}

// 希尔排序实现 
void ShellSortImpl(int arr[], int len,int step) {
    for (auto i{ step }; i < len; i++) {
        auto tmp{arr[i]};
        auto j{i - step};
        for (;j >= 0; j -= step) {
            if (tmp >= arr[j]) {
                break;
            }

            arr[j + step] = arr[j];
        }

        arr[j + step] = tmp;
    }
}

// 希尔排序 
void ShellSort(int arr[], int len) {
    int step = len / 2;
    while (step > 0) {
        ShellSortImpl(arr, len, step);
        step /= 2;
    }
}

// 选择最小的元素 
int SelectMin(int arr[], int len, int start) {
    auto min_pos = start;
    for (auto i{start + 1};i < len; i++) {
        if (arr[min_pos] > arr[i]) {
            min_pos = i;
        }
    }

    return min_pos;
}


// 选择排序 
void SelectSort(int arr[], int len) {
    for (auto i{ 0 }; i < len; i++) {
        auto pos = SelectMin(arr, len, i);
        auto tmp = arr[i];
        arr[i] = arr[pos];
        arr[pos] = tmp;
    }
}

// 快速排序-------partition
int FastSortPartition(int arr[], int start, int end) {
    auto tmp = arr[start];
    while (start < end) {
        while ((start < end) && (arr[end] >= tmp)) {
            end--;
        }
        arr[start] = arr[end];

        while ((start < end) && (arr[start] <= tmp)) {
            start++;
        }
        arr[end] = arr[start];
    }

    arr[start] = tmp;
    return start;
}

// 快速排序实现 
void FastSortImpl(int arr[], int start , int end) {
    if (start < end) {
        int middle = FastSortPartition(arr, start, end);
        FastSortImpl(arr, start, middle - 1);
        FastSortImpl(arr, middle + 1, end);
    }
}

// 快速排序
void FastSort(int arr[], int len) {
    FastSortImpl(arr, 0, len-1);
}

// 合并排序---合并 
void MergeSortMerge(int arr[], int b[], int start, int middle, int end) {
    auto i{ start }, j{middle+1};
    auto idx{start};
    for (;i <= middle && j <= end;idx++) {
        if (arr[i] <= arr[j]) {
            b[idx] = arr[i];
            i++;
        }
        else {
            b[idx] = arr[j];
            j++;
        }
    }

    for (;i <= middle;i++,idx++) {
        b[idx] = arr[i];
    }

    for (;j <= end;j++,idx++) {
        b[idx] = arr[j];
    }

    for (;start <= end; start++) {
        arr[start] = b[start];
    }
}

// 合并排序实现
void MergeSortImpl(int arr[], int b[], int start, int end) {
    if (start < end) {
        auto middle = (start + end) / 2;
        MergeSortImpl(arr, b, start, middle);
        MergeSortImpl(arr, b, middle+1, end);
        MergeSortMerge(arr, b, start, middle, end);
    }
    else {
        b[start] = arr[start];
    }
}

// 合并排序 
void MergeSort(int arr[], int len) {
    int *b = new int[len];
    MergeSortImpl(arr,b, 0, len-1);
    delete[]b;
}

// 堆排序实现 
void HeapSortImpl(int arr[], int start, int len) {
    int son = start * 2 + 1;
    int father = start;
    int value = arr[start];
    while (son < len) {
        if ((son + 1 < len) && (arr[son] < arr[son + 1])) {
            son++;
        }

        if (value >= arr[son]) {
            break;
        }

        arr[father] = arr[son];
        father = son;
        son = son * 2 + 1;
    }

    arr[father] = value;
}

// 堆排序 
void HeapSort(int arr[], int len) {
    for (auto i{ len / 2 - 1 }; i >= 0;i--) {
        HeapSortImpl(arr, i, len);
    }

    for (auto i{ len - 1 }; i > 0; i--) {
        auto tmp = arr[i];
        arr[i] = arr[0];
        arr[0] = tmp;

        HeapSortImpl(arr,0, i);
    }
}

int main()
{
    int arr[] = {3,2,1,10,6,9,5,4,8};
    int len = sizeof(arr) / sizeof(arr[0]);

    print<int>(arr, len);
    HeapSort(arr, len);
    print<int>(arr, len);

    system("pause")；
}