选择排序:每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
选择排序是不稳定的排序方法。
/************************************************************
* 选择排序
* 参数:array为需要排序数的数组, num为数组的长度
************************************************************/
int select(int array[], int num)
{
int i;
int j;
int temp;
for(i = 0;i < num;i++){
for(j = i+1;j < num; j++){
if(array[i] > array[j]){
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
return 0;
}
冒泡排序(BubbleSort):依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。
然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最后。
在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),将小数放前,大数放后,
一直比较到倒数第二个数(倒数第一的位置上已经是最大的),第二趟结束,
在倒数第二的位置上得到一个新的最大数(其实在整个数列中是第二大的数)。如此下去,重复以上过程,直至最终完成排序。
是一种稳定的排序。
/************************************************************
* 冒泡排序
* 参数:array为需要排序数的数组, num为数组的长度
************************************************************/
int bubble(int array[], int num)
{
int i;
int j;
int temp;
for(i = 0; i < num; i++){
for(j = 1; j < num-i; j++){
if(array[j] < array[j-1]){
temp = array[j];
array[j] = array[j-1];
array[j-1] = temp;
}
}
}
return 0;
}
快速排序:
1)设置两个变量I、J,排序开始的时候:I=0,J=N-1;
2)以第一个数组元素作为关键数据,赋值给key,即 key=A[0];
/****************************************************************
* 快速排序的排序函数
* 参数:array为需要排序数的数组, low为需要排序的数组的下限坐标,
* high为需要排序的数组的上限坐标
****************************************************************/
int q_sort(int array[], int low, int high)
{
int temp;
int key = array[low];
while(low < high){
while(low < high && array[high] >= key){
high--;
}
temp = array[high];
array[high] = array[low];
array[low] = temp;
while(low < high && array[low] < key){
low++;
}
temp = array[high];
array[high] = array[low];
array[low] = temp;
}
return low;
}
/****************************************************************
* 快速排序的递归函数
* 参数:array为需要排序数的数组, low为需要排序的数组的下限坐标,
* high为需要排序的数组的上限坐标
****************************************************************/
int quick_sort(int array[], int low, int high)
{
int n;
if(low < high){
n = q_sort(array, low, high);
quick_sort(array, low, n);
quick_sort(array, n+1, high);
}
return 0;
}
归并排序:
申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
/****************************************************************
* 归并排序的排序函数
* 参数:array为需要排序数的数组, low为需要排序的数组的下限坐标,
* high为需要排序的数组的上限坐标
****************************************************************/
int merge(int array[], int low, int high)
{
int mid = (low+high)/2;
int i;
int l_start = low;
int m_start = mid +1;
int l_end = mid;
int m_end = high;
int *temp = (int*)malloc(sizeof(int) * (high - low + 1));
for(i = 0;l_start <= l_end && m_start <= m_end; i++){
if(array[l_start] <= array[m_start]){
temp[i] = array[l_start++];
}else{
temp[i] = array[m_start++];
}
}
if(l_start <= l_end){ /*把剩余部分拷贝到temp缓存中*/
memcpy(temp + i, array + l_start, sizeof(int) * (l_end - l_start + 1));
}
if(m_start <= m_end){ /*把剩余部分拷贝到temp缓存中*/
memcpy(temp + i, array + m_start, sizeof(int) * (m_end - m_start + 1));
}
memcpy(array + low, temp, (high - low + 1) * sizeof(int));
free(temp);
return 0;
}
/****************************************************************
* 归并排序的递归函数
* 参数:array为需要排序数的数组, low为需要排序的数组的下限坐标,
* high为需要排序的数组的上限坐标
****************************************************************/
int *merge_sort(int array[], int low, int high)
{
int mid = (low + high)/2;
if(low < high){
merge_sort(array, low, mid);
merge_sort(array, mid + 1, high);
merge(array, low, high);
}
return array;
}
希尔排序:
/************************************************************
* 希尔排序
* 参数:array为需要排序数的数组, num为数组的长度
************************************************************/
int shell_sort(int array[], int num)
{
int i;
int j;
int temp;
int k = num - 1;
while(k > 0){
k/=2;
for(i = k; i < num; i++){
temp = array[i];
j = i - k;
while(j >= 0 && temp < array[j]){
array[j + k]=array[j];
j = j - k;
}
array[j + k] = temp;
}
}
return 0;
}