排序算法

冒泡排序

1. C++实现

/*

排序名称：冒泡排序
稳定性：稳定
时间复杂度：O（n*n）

*/

#include<iostream>
using namespace std;

void BubbleSort(int a[], int n)
{
    for (int i=0; i<n-1; ++i) {
        int flag = 1;
        for (int j=0; j<=n-i-2; ++j) {
            int temp;
            if (a[j] > a[j+1]) {
                flag = 0;
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
        if (flag) {
            break;          
        }
    }
}

int main()
{
    int n;
    cin >> n;
    int arr[n];
    for (int i=0; i<n; ++i) {
        cin>>arr[i];
    }

    BubbleSort(arr, n);

    cout << endl;
    for (int i=0; i<n; ++i) {
        cout << arr[i] << " ";
    }

    return 0;
}

直接插入排序

1. C++实现

/*

排序名称：直接插入排序
稳定性：稳定
时间复杂度：O（n*n）

*/

#include<iostream>
using namespace std;

void DirectInsertionSort(int a[], int n)
{
    for (int i=1; i<n; ++i) {
        int temp = a[i];
        int j;
        for (j=i-1; (j>=0) && (a[j]>temp); --j) {
            a[j+1] = a[j];
        }

        a[j+1] = temp;
    }
}

int main()
{
    int n;
    cin >> n;
    int arr[n];
    for(int i=0; i<n; ++i) {
        cin >> arr[i];
    }

    DirectInsertionSort(arr, n);

    cout << endl;
    for(int i=0; i<n; ++i) {
        cout << arr[i] << " ";
    }

    return 0;
}

折半插入排序

1. C++实现

/*

排序名称：折半插入排序
稳定性：稳定
时间复杂度：O（nlogn）

*/

#include<iostream>
using namespace std;

void MidInsertionSort(int a[], int n)
{
    for (int i=1; i<n; ++i) {
        int low = 0;
        int high = i-1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (a[mid] > a[i]) {
                high = mid -1;
            } else {
                low = mid + 1;
            }
        }

        int temp = a[i];
        int j;
        for (j=i-1; j>=low; --j) {
            a[j+1] = a[j];      
        } 

        a[j+1] = temp;
    } 
}

int main()
{
    int n;
    cin >> n;
    int arr[n];
    for (int i=0; i<n; ++i) {
        cin >> arr[i];
    }

    MidInsertionSort(arr, n);

    cout << endl;
    for (int i=0; i<n; ++i) {
        cout << arr[i] << " ";
    }

    return 0;
}

简单选择排序

1. C++实现

/*

排序名称：简单选择排序 
稳定性：不稳定
时间复杂度：O（n*n） 

*/

#include<iostream>
using namespace std;

void DirectSelectSort(int a[], int n)
{
    for (int i=0; i<n-1; ++i) {
        int k = i;

        for (int j=i+1; j<n; j++){
            if (a[k] > a[j])
                k = j;
        }

        if (i != k) {
            int temp;
            temp = a[i];
            a[i] = a[k];
            a[k] = temp;
        }
    }
}

int main()
{
    int n;
    cin >> n;
    int arr[n];
    for (int i=0; i<n; ++i) {
        cin >> arr[i];
    }

    DirectSelectSort(arr, n);

    cout << endl;
    for (int i=0; i<n; ++i) {
        cout << arr[i] << " ";
    }

    return 0;
}

希尔排序

1. C++实现

/*

排序名称：希尔排序 
稳定性：不稳定
时间复杂度：时间复杂度与所选定的 “增量序列 ”有关 

*/

#include<iostream>
using namespace std;

void ShellInsertionSort(int a[], int n, int dk)
{
    for (int k=dk; k>=1; k=k/2) {

        for (int i=k; i<n; ++i) {
            int temp = a[i];
            int j = i-k;

            while (j>=0 && temp<a[j]) {
                a[j+k] = a[j];
                j = j-k;
            }

            a[j+k] = temp;
        }
    }
}

int main()
{
    int n;
    cin >> n;
    int arr[n];
    for (int i=0; i<n; ++i) {
        cin >> arr[i];
    }

    ShellInsertionSort(arr, n, n/2);

    cout << endl;
    for (int i=0; i<n; ++i) {
        cout << arr[i] << " ";
    }

    return 0;
}

快速排序

1. C++实现

/*

排序名称：快速排序 
稳定性：不稳定
时间复杂度：O（nlogn） 

*/

#include<iostream>
using namespace std;

void QuickSort(int a[], int low, int high)
{
    int i,j,temp;
    i = low;
    j = high;
    temp = a[i];
    while (i<j) {

        while (i<j && a[j]>temp) {
            --j;
        } 

        if (i<j) {
            a[i] = a[j];
            ++i;
        }

        while (i<j && a[i]<temp) {
            ++i;
        } 

        if (i<j) {
            a[j] = a[i];
            --j;
        }
    }

    a[i] = temp;
    if (j>low) {
        QuickSort(a, low, --j);
    } 

    if (i<high) {
        QuickSort(a, ++i, high);
    } 

}

int main()
{
    int n;
    cin >> n;
    int arr[n];
    for (int i=0; i<n; ++i) {
        cin >> arr[i];
    }

    QuickSort(arr, 0, n-1);

    cout << endl;
    for (int i=0; i<n; ++i) {
        cout << arr[i] << " ";
    }

    return 0;
}

堆排序

1. C++实现

/*

排序名称：堆排序 
稳定性：不稳定
时间复杂度：O（nlogn） 

*/

#include<iostream>
using namespace std;

void Heap(int a[], int n)
{
    for (int j=n/2; j>=1; --j) {
        int i = j;
        int k = 2*i;
        int flag = 0;

        while (k<=n && !flag) {
            if (a[i]<a[k] || ((k+1)<=n) && a[i]<a[k+1]) {
                if (k+1 <=n && a[k+1]>a[k]) {
                    int temp = a[i];
                    a[i] = a[k+1];
                    a[k+1] = temp;
                    i = k+1;
                    k = 2*i;
                } else {
                    int temp = a[i];
                    a[i] = a[k];
                    a[k] = temp;
                    i = k;
                    k = 2*i;                    
                }
            } else {
                flag = 1;
            } 

        }
    }
}

int main()
{
    int n;
    cin >> n;
    int arr[n+1];
    for (int i=1; i<=n; ++i) {
        cin >> arr[i];
    }

    for (int i=1; i<n; ++i) {
        Heap(arr, n-i+1);
        int temp = arr[1];
        arr[1] = arr[n-i+1];
        arr[n-i+1] = temp;
    } 

    cout << endl;
    for (int i=1; i<=n; ++i) {
        cout << arr[i] << " ";
    }

    return 0;
}

两有序数组合并成新有序数组

1. C++实现

#include<iostream>
using namespace std;

int* MergeList(int arr1[], int arr2[], int arr1Length, int arr2Length)
{
    int* arr = new int[arr1Length + arr2Length]; 
    int low1 = 0;
    int low2 = 0;

    for (int i=0; i< arr1Length + arr2Length; ++i) {
        if (low1<arr1Length && low2<arr2Length) {
            if (arr1[low1] > arr2[low2]) {
                arr[i] = arr2[low2];
                ++low2;
            } else {
                arr[i] = arr1[low1];
                ++low1;
            }
        } else {
            if (low1 < arr1Length) {
                arr[i] = arr1[low1];
                ++low1;
            }

            if (low2 < arr2Length) {
                arr[i] = arr2[low2];
                ++low2;
            }
        }
    }

    return arr;
}

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

    for (int i=0; i<12; ++i) {
        cout << arr[i] << "  ";
    }

    delete[] arr;
}