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

#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);
}
}