排序大综合

排序大综合

//排序 大综合 测试 我记住了没！！
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

void BubbleSort(int a[], int n)
{
    if(NULL == a || n == 0)
    {
        return ;
    }

    for(int i = n - 1; i > 0; i--)
    {
        for(int j = 0; j < i; j++)
        {
            if(a[j] > a[j + 1])
            {
                swap(a[j], a[j+ 1]);
            } 
        }
    }
}

void InsertSort(int a[], int n)
{
    if(NULL == a || n == 0)
    {
        return ;
    }

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

void Merge(int a[], int l, int mid, int r)
{
    int leftsize = mid - l + 1;
    int rightsize = r - mid;

    int *left = new int[leftsize];  
    int *right = new int[rightsize];

    for(int i = 0; i < leftsize; i++)
    {
        left[i] = a[l + i];
    }
    for(int i = 0; i < rightsize; i++)
    {
        right[i] = a[mid + i + 1];
    }

    int i = 0, j = 0, k = l;
    while(i < leftsize && j < rightsize)
    {
        if(left[i] < right[j])
        {
            a[k++] = left[i++];
        }
        if(left[i] > right[j])
        {
            a[k++] = right[j++];
        }
    }

    while(i < leftsize)
    {
        a[k++] = left[i++];
    }
    while(j < rightsize)
    {
        a[k++] = right[j++];
    }

    free(left);
    free(right);
}

void MergeSort(int a[], int l, int r)
{
    if(l < r)
    {
        int mid = (l + r)/2;
        MergeSort(a, l, mid) ;
        MergeSort(a, mid + 1, r);
        Merge(a, l, mid, r); 
    }
}

void QuickSort(int a[], int left, int right)
{
    if(left < right)
    {
        int i = left, j = right, key = a[left];
        while(i < j && a[j] > key)
        {
            j--;
        }
        if(i < j)
        {
            a[i++] = a[j];
        }

        while(i < j && a[i] < key)
        {
            i++;
        }
        if(i < j)
        {
            a[j--] = a[i];
        }

        a[i] = key;
        QuickSort(a, left, i);
        QuickSort(a, i + 1, j);
    }
} 

void ChooseSort(int a[], int n)
{
    int min , index;
    for(int i = 0; i < n; i++)
    {
        min = a[i];
        for(int j = i + 1; j < n; j++)
        {
            if(a[j] < min)
            {
                min = a[j];
                index = j;
            }
        }
        swap(a[i], a[index]);
    }
}

void ShellSort(int a[], int n)
{
    int d = n;

    while(d)
    {
        d = d/2;
        for(int i = 0; i < n - d; i++)
        {
            if(a[i] > a[i + d])
            {
                swap(a[i], a[i+d]);
            }
        }   
    }
}


void  AdjustHeap(int a[], int start, int end)
{
    int value = a[start];

    for(int i = 2*start + 1; i <= end; i *= 2)
    {
        if(i < end && a[i] > a[i + 1])
        {
            i++;
        }

        if(value > a[i])
        {
            a[start] = a[i];
            start = i;
        }
        else
        {
            break;
        }

    }
    a[start] = value;
}

void HeapSort(int a[], int n)
{
    //建一个大顶堆 
    for(int i = n/2 -1; i >= 0; i--)
    {
        AdjustHeap(a, i, n);
    }   
    //堆排序 
    for(int i = n - 1; i > 0; i--)
    {
        swap(a[0], a[i]);
        AdjustHeap(a, 0, i - 1);
    }
}

int main()
{
    int *arr = new int;
    int n = 0;

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

    //BubbleSort(arr, n);
    //InsertSort(arr, n);
    //MergeSort(arr, 0, n-1);
    //QuickSort(arr, 0, n - 1);
    //ChooseSort(arr, n);
    //ShellSort(arr, n);
    //BinaryInsertSort

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


    system("pause");
    return 0;   
}

ps:稳定性可以根据 两个相同的数字相对位置是否会改变来判断