The basic sorting algorithm

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)//one-trip quick-line

{

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}; Incremental sequence

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])//Build a large pile of attention points 1

{

j + +;

}

if (Key > Arr[j])//Note point 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}; Auxiliary merge sort opens up space, auxiliary storage O (n)

int arr[] The size of the TR array is the same as the size of arr to sort the array

Merging sort (2-way merge sort)

Ordered Arr[start,..., mid] and arr[mid+1,..., end] are merged into an ordered 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))//list Merging ideas

{

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];

}

}

Sort Arr[start,..., T] merge to 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);

}

This article is from "Burial Memory" blog, declined reprint!

The basic sorting algorithm