常用7种简单排序算法总结（C语言实现）

冒泡排序

插入排序

选择排序：

归并排序：

堆排序：

/*
这是一个常用算法总结的程序
包括
1.冒泡排序（Bubble Sort）
2.选择排序（Selection Sort）
3.插入排序（Insertion Sort）
4.希尔排序（Shell Sort）
5.归并排序（Merge Sort）
6.堆排序（Heap Sort）
7.快速排序（Quick Sort）
以上七种算法对数组int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 ,10}的排序 
 */

#include
#include

//函数声明 
void bubbleSort(int a[],int len);
void selectionSort(int a[],int len);
void insertionSort(int a[],int len);
void shellSort(int a[],int len);
void mergeSort(int a[], int len);
void Merge(int A[], int left, int mid, int right);
void heapSort(int a[],int len);
void quickSort(int a[], int left, int right);

int main(void){
	//A为要排序的数组 
	int A[] = { 6, 5, 3, 1, 8, 7, 2, 4,10 };
	printf("原始数组为：\n");
	int lengthA = 9;
	for(int i = 0 ; ii;j--){
			if(a[j]= 0&&a[j]>temp){//遍历有序序列，与要插入的元素比较 
			a[j+1] = a[j];//将元素后移，满足条件后移一个位置
			j--; 
		}
		a[j+1] = temp; //插入  
	}
	printf("插入排序的结果：\n");
	for(int i = 0 ; i< len; i++){
		printf("%d ",a[i]);
	}
	printf("\n\n");
	
}

/*
希尔排序：
将无序数组分割为若干个子序列，子序列不是逐段分割的，
而是相隔特定的增量的子序列，对各个子序列进行插入排序；
然后再选择一个更小的增量，再将数组分割为多个子序列进行排序
......最后选择增量为1，即使用直接插入排序，使最终数组成为有序。
增量的选择：在每趟的排序过程都有一个增量，
至少满足一个规则 增量关系 d[1] > d[2] > d[3] >..> d[t] = 1 (t趟排序)；
本文采用首选增量为n/2,以此递推，每次增量为原先的1/2，直到增量为1； 
希尔排序类似于分组插入排序
example：
49，38，65，97，76，13，27，49，55，04。
增量序列的取值依次为：
5，3，1
第一趟排序后：
|                    | 
--------------------- 
    |                   |
	-------------------- 
。。。。。 
13，27，49，55，04，49，38，65，97，76
第二趟排序后：
|           |           |           | 
-------------------------------------
    |           |           |
	------------------------
。。。。。。
13，04，49，38，27，49，55，65，97，76 
*/
void shellSort(int a[],int len){
	int incre=len;//设置增量
	int temp;
	while(true){
		incre /=2;
		for(int k=0;kk;j-=incre){
					if(a[j] A[max])
        max = left_child;
    if (right_child < size && A[right_child] > A[max])
        max = right_child;
    if (max != i)
    {
        Swap(A, i, max);                // 把当前结点和它的最大(直接)子节点进行交换
        Heapify(A, max, size);          // 递归调用，继续从当前结点向下进行堆调整
    }
}

int BuildHeap(int A[], int n)           // 建堆，时间复杂度O(n)
{
    int heap_size = n;
    for (int i = heap_size / 2 - 1; i >= 0; i--) // 从每一个非叶结点开始向下进行堆调整
        Heapify(A, i, heap_size);
    return heap_size;
}


void heapSort(int a[],int len){
	int heap_size = BuildHeap(a, len);    // 建立一个最大堆
	while (heap_size > 1) // 堆（无序区）元素个数大于1，未完成排序
    {
        // 将堆顶元素与堆的最后一个元素互换，并从堆中去掉最后一个元素
        // 此处交换操作很有可能把后面元素的稳定性打乱，所以堆排序是不稳定的排序算法
        Swap(a, 0, --heap_size);
        Heapify(a, 0, heap_size);     // 从新的堆顶元素开始向下进行堆调整，时间复杂度O(logn)
    }
    printf("堆排序的结果：\n");
	for(int i = 0 ; i< len; i++){
		printf("%d ",a[i]);
	}
	printf("\n\n");	
}

/*
快速排序
使用分治策略来把一个序列分为两个子序列。
步骤为：
从序列中挑出一个元素，作为"基准"(pivot).
把所有比基准值小的元素放在基准前面，
所有比基准值大的元素放在基准的后面（相同的数可以到任一边），
这个称为分区(partition)操作。
对每个分区递归地进行步骤1~2，递归的结束条件是序列的大小是0或1，
这时整体已经被排好序了。
*/
int Partition(int A[], int left, int right)  // 划分函数
{
    int pivot = A[right];               // 这里每次都选择最后一个元素作为基准
    int tail = left - 1;                // tail为小于基准的子数组最后一个元素的索引
    for (int i = left; i < right; i++)  // 遍历基准以外的其他元素
    {
        if (A[i] <= pivot)              // 把小于等于基准的元素放到前一个子数组末尾
        {
            Swap(A, ++tail, i);
        }
    }
    Swap(A, tail + 1, right);           // 最后把基准放到前一个子数组的后边，剩下的子数组既是大于基准的子数组
                                        // 该操作很有可能把后面元素的稳定性打乱，所以快速排序是不稳定的排序算法
    return tail + 1;                    // 返回基准的索引
}

void quickSort(int a[],int left,int right){
	if (left >= right)
		return;
    int pivot_index = Partition(a, left, right); // 基准的索引
    quickSort(a, left, pivot_index - 1);
    quickSort(a, pivot_index + 1, right);
}