基本的排序算法

void BubbleSort(int arr[],int size)

{

assert(arr);

int iBeign = 0;

int jBeign = 0;

int flag = 1;

int temp = 0;

for (iBeign = 1; (iBeign < size) && (flag == 1);iBeign++)

{

flag = 0;

for (jBeign = 0; jBeign < size - iBeign; jBeign++)

{

if (arr[jBeign] > arr[jBeign + 1])

{

flag = 1;

temp = arr[jBeign];

arr[jBeign] = arr[jBeign + 1];

arr[jBeign + 1] = temp;

}

}

}

}

void SelectSort(int arr[], int size)

{

assert(arr);

int iBeign = 0;

int jBeign = 0;

int Small= 0;

int temp = 0;

for (iBeign = 0; iBeign < size; iBeign++)

{

Small = iBeign;

for (jBeign = iBeign + 1; jBeign < size; jBeign++)

{

if (arr[jBeign] < arr[Small])

{

Small = jBeign;

}

}

if (Small != iBeign)

{

temp = arr[Small];

arr[Small] = arr[iBeign];

arr[iBeign] = temp;

}

}

}

void InsertSort(int arr[], int size)

{

assert(arr);

int iBeign = 0;

int jBeign = 0;

int key = 0;

for (iBeign = 1; iBeign < size; iBeign++)

{

key = arr[iBeign];

jBeign = iBeign - 1;

while ( (jBeign >= 0 ) && (key < arr[jBeign]) )

{

arr[jBeign + 1] = arr[jBeign];

arr[jBeign] = key;

jBeign--;

}

}

}

void Quick(int arr[], int low,int high)  //一趟快排

{

assert(arr);

int i = low;

int j = high;

int key = arr[low];

while (i < j)

{

while ((i < j) && (key < arr[j]))

{

j--;

}

if (i < j)

{

arr[i] = arr[j];

i++;

}

while ((i < j) && (key > arr[i]))

{

i++;

}

if (i < j)

{

arr[j] = arr[i];

j--;

}

}

arr[i] = key;

if (i > low)

{

Quick(arr, low , i - 1);

}

if (j < high)

{

Quick(arr, j + 1, high);

}

}

void QuickSort(int arr[], int size)

{    

     assert(arr);

Quick(arr, 0, size - 1);

}

int dlta[] = { 5, 3, 2, 1};  //增量序列

void ShellInsert(int arr[] ,int size ,int dk)

{

assert(arr);

int iBegin = 0;

int jBegin = 0;

int key = 0;

for (iBegin = dk; iBegin < size; iBegin++)

{

key = arr[iBegin];

jBegin = iBegin - dk;

while ((jBegin >= 0) && (key < arr[jBegin] ))

{

arr[jBegin + dk] = arr[jBegin];

arr[jBegin] = key;

jBegin -= dk;

}

}

}

void ShellSort(int arr[], int size,int t)

{

int i = 0;

for (i = 0; i < t;i++)

{

ShellInsert(arr, size, dlta[i]);

}

}

void Heapjust(int arr[], int size,int h)

{

assert(arr);

int i = h; 

int j = 2 * i + 1;

int key = arr[i];

int flag = 0;

while ( (j < size) && (flag != 1))

{

if ((j < size - 1) && (arr[j] < arr[j + 1]))   //建立大堆 注意点1

{

j++;

}

if (key > arr[j])     //注意点2

{

flag = 1;

}

else

{

arr[i] = arr[j];

i = j;

j = 2 * i + 1;

}

}

arr[i] = key;

}

void MinHeapInit(int arr[], int size)

{

assert(arr);

int i = 0;

for (i = (size - 2) / 2; i >= 0; i--)

{

Heapjust(arr, size, i);

}

}

void HeapSort(int arr[], int size)

{

assert(arr);

int i = 0;

int temp = 0;

MinHeapInit(arr, size);

for (i = size - 1; i >= 0; i--)

{

temp = arr[0];

arr[0] = arr[i];

arr[i] = temp;

Heapjust(arr, i, 0);

}

}

int TR[size] = { 0 };   //辅助归并排序开辟的空间，， 辅助存储 O(n)

//int arr[]  TR数组的大小要与要排序数组arr的大小一样

//Merging Sort(2- 路归并排序）

//有序的arr[start,...,mid]和arr[mid+1,...,end]归并为有序的TR[i,...,n]

void Merge(int arr[], int TR[],int start,int mid, int end)

{

assert(arr);

assert(TR);

int iBegin = start;

int jBegin = mid + 1;

int data = 0;

int iTR = start;

while ( (iBegin <= mid) && (jBegin <= end) )  //链表合并思想

{

if (arr[iBegin] > arr[jBegin])

{

data = arr[jBegin];

jBegin++;

}

else

{

data = arr[iBegin];

iBegin++;

}

TR[iTR++] = data;

}

while (iBegin <= mid)

{

TR[iTR++] = arr[iBegin++];

}

while (jBegin <= end)

{

TR[iTR++] = arr[jBegin++];

}

while (--iTR >= start)

{

arr[iTR] = TR[iTR];

}

}

//将arr[start,...,t]归并排序到TR[start,...,t]

void MSort(int arr[], int TR[], int start, int end) 

{

assert(arr);

assert(TR);

int mid = 0;

if (start == end)

{

return;

}

else

{

mid = (start + end) / 2;

MSort(arr, TR, start, mid);

MSort(arr, TR, mid + 1, end);

Merge(arr, TR, start, mid, end);

}

}

void MergeSort(int arr[],int TR[], int size)

{

assert(arr);

assert(TR);

MSort(arr, TR, 0, size - 1);

}

本文出自 “埋葬的记忆” 博客，谢绝转载！