几种基本排序的实现：选择排序，冒泡排序，插入排序，堆排序，快速排序，归并排序

//冒泡排序
#include <stdio.h>

// 交换函数

void swap (int a[], int i, int j)

{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;

}

// 打印数组

void printA (int *a, int len)

{
int i;
for (i = 0; i < len; i++)
{
printf ("%4d", a[i]);
}

printf ("\n");

}

// 冒泡排序

int main1()

{
int a[10] = {9,6,8,0,3,5,2,4,7,1};
int len = sizeof(a) / sizeof(a[0]);

int i,j;
// 外层循环控制轮数，每一轮找出一个最大的树沉底
for (i = 0; i < len -1; i++)
{
// 内层循环控制每一轮比较的次数
for (j = 0; j < len-1-i; j++)
{
if (a[j] > a[j+1])
{
swap (a, j, j+1);
}
}
}

printA (a, len);

return 0;

}

// 鸡尾酒排序

int main()

{
int a[10] = {9,6,8,0,3,5,2,4,7,1};
int len = sizeof(a) / sizeof(a[0]);

int i;
int left  = 0;
int right = len - 1;

while (left < right)
{
// 从左往右找到一个最大的数放到right的位置
for (i = left; i < right; i++)
{
if (a[i] > a[i+1])
{
swap (a, i, i+1);
}
}
right--;     

// 从右往左找到一个最小的数放到left的位置
for (i = right; i > left; i--)
{
if (a[i-1] > a[i])
{
swap (a, i, i-1);
}
}
left++;
}

printA (a, len);

return 0;

}

//选择排序
#include <stdio.h>

// 交换函数

void swap (int a[], int i, int j)

{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;

}

// 打印数组

void printA (int *a, int len)

{
int i;
for (i = 0; i < len; i++)
{
printf ("%4d", a[i]);
}

printf ("\n");

}

int main()

{
int a[10] = {9,6,8,0,3,5,2,4,7,1};
int len = sizeof(a) / sizeof(a[0]);

int i,j;
int min;
// 外层循环控制轮数，每一轮找到一个最小的数
for (i = 0; i < len-1; i++)
{
min = i;    
// 内层循环找每一轮最小数的下标
for (j = i+1; j < len; j++)
{
if (a[min] > a[j])
{
min = j;    // 保存当前最小元素的下标
}
}

// 如果当前顶端元素不是最小的值，将最小的值和顶端元素进行交换
if (min != i)
{
swap (a, i, min);
}
}

printA (a, len);

return 0;

}

//插入排序
#include <stdio.h>

// 交换函数

void swap (int a[], int i, int j)

{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;

}

// 打印数组

void printA (int *a, int len)

{
int i;
for (i = 0; i < len; i++)
{
printf ("%4d", a[i]);
}

printf ("\n");

}

// 插入排序

int main()

{
int a[10] = {9,6,8,0,3,5,2,4,7,1};
int len = sizeof(a) / sizeof(a[0]);

int get;   // 抓牌
int i,j;
for (i = 1; i < len; i++)
{
get = a[i];         // 抓牌
j = i - 1;

// 找到第一个比抓到的牌小的元素，并且进行移位
while (j >= 0 && a[j] > get)
{
a[j+1] = a[j];     // 如果元素比新抓到的元素大，往后移一个位置
j--;
}
a[j+1] = get;          // 将新元素插入第一个比它小的元素的后面
}

printA (a, len);

return 0;

}

//二分法插入排序
#include <stdio.h>

// 交换函数

void swap (int a[], int i, int j)

{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;

}

// 打印数组

void printA (int *a, int len)

{
int i;
for (i = 0; i < len; i++)
{
printf ("%4d", a[i]);
}

printf ("\n");

}

// 二分插入排序

int main()

{
int a[10] = {9,6,8,0,3,5,2,4,7,1};
int len = sizeof(a) / sizeof(a[0]);

int left, right,mid,i,j,get;

for (i = 1; i < len; i++)
{
get = a[i];          // 抓牌
left = 0;            // 确定左边界
right = i - 1;       // 确定右边界

// 找插入位置：查找完后要插入的位置在下标为left的位置
while (left <= right)
{
mid = (left + right)/2;
if (a[mid] > get)     // 要插入的位置在mid的左边
{
right = mid - 1;  // 重新设定右边界
}
else                  // 要插入的位置在mid的右边
{
left = mid + 1;   // 重新设定左边界
}
}

// 移位操作：将left开始右边的所有元素都右移一位
for (j = i-1; j >= left; j--)
{
a[j+1] = a[j];
}

a[left] = get;     // 插入新元素

}

printA (a, len);

return 0;

}



//希尔排序

#include <stdio.h>

void swap(int a[], int i, int j)
{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
void printA(int *a, int len)
{
int i;
for(i=0; i<len; i++)
{
printf("%4d",a[i]);
}
printf("\n");
}
int main()
{
int a[10] = {7,9,6,8,1,4,0,3,2,5};
int len = sizeof(a)/sizeof(a[0]);
int i,j,get;
int d = len;
do
{
d = d/3 + 1;
for(i=d; i<len; i++)
{
get = a[i];
j = i-d;
while(j>=0 && a[j]>get)
{
a[j+d] = a[j];
j -= d;
}
a[j+d] = get;
}
}while(d > 1);
printA(a,len);
return 0;
}

//堆排序
#include <stdio.h>

// 交换函数

void swap (int a[], int i, int j)

{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;

}

// 打印数组

void printA (int *a, int len)

{
int i;
for (i = 0; i < len; i++)
{
printf ("%4d", a[i]);
}

printf ("\n");

}

// a 代表一个数组

// i 代表要调整的结点的下标

// len  数组的长度

void heapify(int *a, int i, int len)

{
int left = 2 * i + 1;     // 左孩子结点下标
int right = 2 * i + 2;    // 右孩子结点下标
int max = i;     // 三个节点中最大元素的下标

if (left < len && a[left] > a[max])
max = left;
if (right < len && a[right] > a[max])
max = right;

if (max != i)   // 当前父节点不是所有结点中最大的元素，需要做调整
{
swap (a, i, max);
heapify (a, max, len);   // 调整被交换的结点
}

}

void heapSort (int *a, int len)

{
// 建堆
int i;
for (i = len/2 - 1; i >= 0; i--)
{
heapify (a, i, len);
}

// 排序
for (i = len-1; i > 0; i--)
{
swap (a, 0, i);       // 拿堆顶元素与队尾元素进行交换
len--;                // 找到一个最大元素以后堆大小减1
heapify (a, 0, len);  // 调整堆顶元素
}

}

int main()

{
int a[10] = {9,6,8,0,3,5,2,4,7,1};
int len = sizeof(a) / sizeof(a[0]);

heapSort(a, len);

printA (a, len);

return 0;

}

//快速排序
#include <stdio.h>

// 交换函数

void swap (int a[], int i, int j)

{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;

}

// 打印数组

void printA (int *a, int len)

{
int i;
for (i = 0; i < len; i++)
{
printf ("%4d", a[i]);
}

printf ("\n");

}

// 分区操作，返回基准值的下标

int partition(int *a, int left, int right)

{
int pivot = a[right];
int index = left;   // 如果找到一个比基准值小的元素，与下标为index的元素交换
int i;
for (i = left; i < right; i++)
{
if (a[i] < pivot)
{
swap (a, i, index);
index++;
}
}
swap (a, index, right);

return index;   // 基准值所在位置下标

}

void qSort(int *a, int left, int right)

{
if (left < right)
{
int pivot = partition(a, left, right);  // 进行分区操作，找基准值下标
qSort (a, left, pivot-1);     // 对左边部分进行快速排序
qSort (a, pivot+1, right);    // 对右边部分进行快速排序

}

}

int main()

{
int a[10] = {9,6,8,0,3,1,2,4,7,5};
int len = sizeof(a) / sizeof(a[0]);

qSort (a, 0, len-1);

printA (a, len);

return 0;

}

//归并排序

#include <stdio.h>

// 交换函数

void swap (int a[], int i, int j)

{
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;

}

// 打印数组

void printA (int *a, int len)

{
int i;
for (i = 0; i < len; i++)
{
printf ("%4d", a[i]);
}

printf ("\n");

}

// a 是数组  tmp  是缓冲区

void merge(int *a, int left, int mid, int right, int *tmp)

{
int i = left;
int j = mid + 1;
int k = 0;

while (i <= mid && j <= right)
{
if (a[i] > a[j])
tmp[k++] = a[j++];
else
tmp[k++] = a[i++];
}

while (i <= mid)
tmp[k++] = a[i++];

while (j <= right)
tmp[k++] = a[j++];

k = 0;
for (i = left; i <= right; i++)
{
a[i] = tmp[k++];
}

}

void mergeSort(int *a, int left, int right, int *tmp)

{
if (left >= right)
return;

int mid = (left + right)/2;
mergeSort (a, left, mid, tmp);    // 对左边部分进行归并排序
mergeSort (a, mid+1, right, tmp); // 对右边部分进行归并排序
merge (a, left, mid, right, tmp); // 将将部分数据进行归并

}

int main()

{
int a[10] = {9,6,8,0,3,1,2,4,7,5};
int len = sizeof(a) / sizeof(a[0]);
int tmp[10];
mergeSort (a, 0, len-1, tmp);
printA (a, len);

return 0;

}