排序算法总结

///////////////////////////////////////////////////////////////////
// 插入排序
void insertSort(int arr[], int n)
{
for(int i = 1; i < n; i ++)
{
int key = arr[i];
int j = i - 1;
while(j >= 0 && arr[j] > key)
{
arr[j + 1] = arr[j];
j --;
}
arr[j + 1] = key;
}
}
//////////////////////////////////////////////////////////////////
// 希尔插入
void shellInsert(int arr[], int d, int n)
{
for(int i = d; i < n; i ++)
{
int key = arr[i];
int j = i - d;
while(j >= 0 && arr[j] > key)
{
arr[j + d] = arr[j];
j -= d;
}
arr[j + d] = key;
}

}
void shellSort(int arr[], int n)
{
int d = n / 2;
while(d >= 1)
{
shellInsert(arr, d, n);

d /= 2;
}
}
///////////////////////////////////////////////////////////
// 冒泡排序
void swap(int x, int y, int arr[])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;

}

void bubbleSort1(int arr[], int n)
{
for(int i = 0; i < n; i ++)
{

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

}
}

}

void bubbleSort2(int arr[], int n)
{
int flag = true; // 初始标志， 1
for(int i = 0; i < n && flag; i ++)// 若上一轮存在数据交换，继续执行排序
{

flag = false; // 每一轮初始，交换标志为0
for(int j = 0; j < n - i; j ++)
{
if(arr[j] > arr[j + 1])
{
swap(j, j + 1, arr);
flag = true; // 存在交换，标志位1
}

}
}

}

void bubbleSort3(int arr[], int n)
{
int flag = n;
int k;
while(flag > 0)
{
k = flag;
flag = 0;
for(int j = 0; j < k; j ++)
{
if(arr[j] > arr[j + 1])
{
swap(j, j + 1, arr);
flag = j + 1; // flag记录本轮最后一个发生交换的位置，后面的都排好序了
}
}

}
}

void bubbleSort4(int arr[], int n)
{

for(int i = 0; i < n - 1; i ++)
{
for(int j = n - 1; j > i; j --)
{

if(arr[j] < arr[j - 1])
{

swap(j - 1, j, arr);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
// 快速排序
int partition(int arr[], int start, int end)
{
if(arr == NULL || end < 0 || start < 0 || start > end)
{
throw new exception("Invalid Parameters");
}

int i = start;
int j = end;
int x = arr[start];

while(i < j)
{
while(i < j && arr[j] >= x ) // 从右向左找第一个小于X的数
{
j --;
}
if(i < j)
{
arr[i] = arr[j];
i ++;
}

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

return i;
}

void quickSort(int arr[], int start, int end)
{
if(start < end)
{
int index = partition(arr, start, end);
quickSort(arr, start, index - 1);
quickSort(arr, index + 1, end);
}
}
//快速排序 整理
void quick_sort(int s[], int l, int r)
{
if (l < r)
{
//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
int i = l, j = r, x = s[l];
while (i < j)
{
while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
j--;
if(i < j)
s[i++] = s[j];

while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
i++;
if(i < j)
s[j--] = s[i];
}
s[i] = x;
quick_sort(s, l, i - 1); // 递归调用
quick_sort(s, i + 1, r);
}
}

//////////////////////////////////////////////////////////////////////
// 直接选择排序
void selectSort(int a[], int n)
{
int k; // 记录最小关键字所在的位置
for(int i = 0; i < n; i ++)
{
k = i;
for(int j = i; j < n; j ++)
{
if(a[j] < a[k])
{
k = j;
}
}
if(k != i)
{
swap(i, k, a);
}
}
}

////////////////////////////////////////////////////////////////////////
// 堆排序
void heapSort(int arr[], int n)
{

}

///////////////////////////////////////////////////////////////////////
// 归并排序
/*
** 合并两个子数组序列，以mid为中间点，start，end为前后界限，分割成两个子序列
*/
void merge(int arr[], int start, int mid, int end, int *tempArr)
{
int lStart = start; // 左边序列的起始索引号
int lEnd = mid; // 左边序列的最后索引号
int rStart = mid + 1;//右边序列的起始索引号
int rEnd = end;//右边序列的起始索引号

int k = 0; // 两个子序列元素个数之和
while(lStart <= lEnd && rStart <= rEnd) // 子序列遍历完了退出循环
{
if(arr[lStart] <= arr[rStart])
{
tempArr[k ++] = arr[lStart ++];
}
else
{
tempArr[k ++] = arr[rStart ++];
}
}
while(lStart <= lEnd)
{
tempArr[k ++] = arr[lStart ++];
}
while(rStart <= rEnd)
{
tempArr[k ++] = arr[rStart ++];
}

for(int i = 0; i < k; i ++)
{
arr[start + i] = tempArr[i];
}
}
void mergeSort(int arr[], int start, int end, int *tempArr)
{
if(end > start)
{
int mid = start + (end - start)/ 2;
mergeSort(arr, start, mid, tempArr); // 左边序列排序
mergeSort(arr, mid + 1, end, tempArr); // 右边序列排序
merge(arr, start, mid, end, tempArr);  // 合并两个序列

}
}

////////////////////////////////////////////////////////////////////
// 基数排序
/** 找到num的从低到高的第POS位的数据
*** num: 一个整形数据
*** pos: 表示要获取的整形的第POS位数据，从低位到高位
**/
int getNumInPos(int num, int pos)
{
int temp  = 1;
for(int i = 0; i < pos - 1; i ++)
{
temp *= 10;
}

return (num / temp) % 10;
}

/**
*** 基数排序
*** pDataArry 无序数组
*** iDataNum 无序数组的数据个数
**/
#define RADIX_10 10 // 整形排序
#define KEYNUM_31 10 // 关键字个数，这里为整形为数
void radixSort(int *pDataArray, int iDataNum)
{
int *radixArrays[RADIX_10]; // 分别为0-9的序列空间
for(int i = 0; i < 10; i ++)
{
radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
radixArrays[i][0] = 0;
}

for(int pos = 1; pos < KEYNUM_31; pos ++) // 从个位开始到31位
{
for(int i = 0; i < iDataNum; i++) // 分配过程
{
int num = getNumInPos(pDataArray[i], pos);
int index = ++radixArrays[num][0];
radixArrays[num][index] = pDataArray[i];
}
}

int j;
for(j = 0, i = 0; i < RADIX_10; i ++) // 收集
{
for(int k = 1; k <= radixArrays[i][0]; k ++)
{
pDataArray[j ++] = radixArrays[i][k];
}
radixArrays[i][0] = 0; // 复位
}
}