冒泡法、选择法、快速、归并、堆排序算法实现

#include <iostream>
#include <string.h>

using namespace std;

#define ARRAY_SIZE 10

int g_bubble_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
int g_selection_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
int g_quick_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
int g_merge_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
int g_heap_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
int g_binary_search[ARRAY_SIZE] = {1, 2, 3, 4, 5, 7, 8, 9, 12, 13};

int binary_search(int arr[], int startIdx, int endIdx, int ele);
void bubble_sort(int arr[], int startIdx, int endIdx);
void selection_sort(int arr[], int startIdx, int endIdx);
int partion(int arr[], int startIdx, int endIdx);
int partion2(int arr[], int startIdx, int endIdx);
void quick_sort(int arr[], int startIdx, int endIdx);
void merge_sort(int arr[], int startIdx, int endIdx);
void merge(int arr[], int startIdx, int mid, int endIdx);
void heap_sort(int arr[], int startIdx, int endIdx);
void build_max_heap(int arr[], int len);
void max_heapify(int arr[], int len, int root);


int main()
{
    cout << "bubble_sort: \t";
    bubble_sort(g_bubble_sort, 0, ARRAY_SIZE - 1);
    for(int i=0; i<ARRAY_SIZE; i++)
    {
        cout<<g_bubble_sort[i] << "\t";
    }
    cout << "\n";

    cout << "selction_sort: \t";
    selection_sort(g_selection_sort, 0, ARRAY_SIZE - 1);
    for(int i=0; i<ARRAY_SIZE; i++)
    {
        cout<<g_selection_sort[i] << "\t";
    }
    cout << "\n";

    cout << "quick_sort: \t";
    quick_sort(g_quick_sort, 0, ARRAY_SIZE - 1);
    for(int i=0; i<ARRAY_SIZE; i++)
    {
        cout<<g_quick_sort[i] << "\t";
    }
    cout << "\n";

    cout << "merge_sort: \t";
    merge_sort(g_merge_sort, 0, ARRAY_SIZE - 1);
    for(int i=0; i<ARRAY_SIZE; i++)
    {
        cout<<g_merge_sort[i] << "\t";
    }
    cout << "\n";

    cout << "heap_sort: \t";
    heap_sort(g_heap_sort, 0, ARRAY_SIZE - 1);
    for(int i=0; i<ARRAY_SIZE; i++)
    {
        cout<<g_heap_sort[i] << "\t";
    }

    cout << "\n";
    cout << binary_search(g_bubble_sort, 0, ARRAY_SIZE - 1, 8) << endl;
    cout << binary_search(g_selection_sort, 0, ARRAY_SIZE - 1, 8) << endl;
    cout << binary_search(g_quick_sort, 0, ARRAY_SIZE - 1, 8) << endl;
    cout << binary_search(g_merge_sort, 0, ARRAY_SIZE - 1, 8) << endl;
    cout << binary_search(g_heap_sort, 0, ARRAY_SIZE - 1, 8) << endl;
    return 0;
}


void bubble_sort(int arr[], int startIdx, int endIdx)
{
    int len = endIdx - startIdx + 1;
    int i, j;
    int tmp;
    for(i=1; i<len; ++i)
    {
        for(j=startIdx; j<startIdx + len - i; ++j)
        {
            if(arr[j] > arr[j+1])
            {
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}

void selection_sort(int arr[], int startIdx, int endIdx)
{
    int len = endIdx - startIdx + 1;
    int i, j;
    int max, idx, tmp;

    for(i=1; i<len; ++i)
    {
        idx = startIdx;
        max = arr[idx];
        for (j = startIdx+1; j <= startIdx + len - i; ++j)
        {
              if (arr[j] >= max)
              {
                  max = arr[j];
                 idx = j;
             }
         }
         tmp = arr[startIdx + len - i];
         arr[startIdx + len - i] = max;
         arr[idx] = tmp;
    }
}

int binary_search(int arr[], int startIdx, int endIdx, int ele)
{
    if(startIdx > endIdx)
    {
        return -1;
    }
    int midIdx;
    while(startIdx <= endIdx)
    {
        midIdx = (startIdx + endIdx) / 2;
        if(arr[midIdx] == ele)
        {
            return midIdx;
        }
        else if(arr[midIdx] < ele)
        {
            startIdx = midIdx + 1;
        }
        else
        {
            endIdx = midIdx - 1;
        }
    }
    return -1;
}

void quick_sort(int arr[], int startIdx, int endIdx)
{
    if(startIdx >= endIdx)
    {
        return;
    }
    int pivot = partion2(arr, startIdx, endIdx);
    quick_sort(arr, startIdx, pivot - 1);
    quick_sort(arr, pivot + 1, endIdx);
}


int partion(int arr[], int startIdx, int endIdx)
{
    int i = startIdx;
    int j = endIdx - 1;
    int tmp;
    while(i<=j)
    {
        if(arr[i] < arr[endIdx])
        {
            ++i;
            continue;
        }
        if(arr[j] >= arr[endIdx])
        {
            --j;
            continue;
        }
        tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
        ++i;
        --j;
    }

    tmp = arr[endIdx];
    arr[endIdx] = arr[i];
    arr[i] = tmp;
    return i;
}


int partion2(int arr[], int startIdx, int endIdx)
{
    int i = startIdx + 1;
    int j = endIdx;
    int tmp;
    int pivot;

    while(true)
    {
        while(i<=endIdx && arr[i] <= arr[startIdx])
        {
            ++i;
        }
        while(j>=startIdx+1 && arr[j] > arr[startIdx])
        {
            --j;
        }
        if(i<j)
        {
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            ++i;
            --j;
        }
        else
        {
            tmp = arr[startIdx];
            arr[startIdx] = arr[j];
            arr[j] = tmp;
            pivot = j;
            break;
        }
    }
    return pivot;
}

void merge_sort(int arr[], int startIdx, int endIdx)
{
    if(startIdx == endIdx)
    {
        return;
    }
    int mid = (startIdx + endIdx)/2;
    merge_sort(arr, startIdx, mid);
    merge_sort(arr, mid + 1, endIdx);
    merge(arr, startIdx, mid, endIdx);
}
void merge(int arr[], int startIdx, int mid, int endIdx)
{
    int len = endIdx - startIdx + 1;
    int *arrTmp = new int[len];
    memset(arrTmp, 0, len*sizeof(int));
    int i = startIdx;
    int j = mid + 1;
    int k;
    for(k=0; k<len; ++k)
    {
        if(j > endIdx || (i <= mid && arr[i] <= arr[j]))
        {
            arrTmp[k] = arr[i];
            ++i;
        }
        else
        {
            arrTmp[k] = arr[j];
            ++j;
        }
    }

    for(k=0; k<len; ++k)
    {
        arr[startIdx + k] = arrTmp[k];
    }

    delete[] arrTmp;
}


void heap_sort(int arr[], int startIdx, int endIdx)
{
    int *arrRef = &arr[startIdx];
    int len = endIdx - startIdx + 1;
    build_max_heap(arrRef, len);

    int i, tmp;
    for(i=1; i<len; ++i)
    {
        tmp = arrRef[0];
        arrRef[0] = arrRef[len-i];
        arrRef[len-i] = tmp;
        max_heapify(arrRef, len-i, 0);
    }
}

void build_max_heap(int arr[], int len)
{
    int startIdx = (len - 2) / 2;
    int i;
    for(i=startIdx; i>=0; --i)
    {
        max_heapify(arr, len, i);
    }
}

void max_heapify(int arr[], int len, int root)
{
    int last = (len-2) / 2;
    if(root > last)
        return;

    int left = root*2 + 1;
    int right = root*2 + 2;
    int max = arr[root];
    int idx = root;

    if(left < len && arr[left] > max)
    {
        max = arr[left];
        idx = left;
    }
    if(right < len && arr[right] > max)
    {
        max = arr[right];
        idx = right;
    }

    if(idx != root)
    {
        arr[idx] = arr[root];
        arr[root] = max;
        max_heapify(arr, len, idx);
    }
}