C语言排序算法集锦：选择排序，冒泡排序，插入排序，希尔排序，归并排序，堆排序，快排序

选择排序：第一层遍历每一个数，第二层从当前位置直到末尾，一直寻找比当前数更大（更小）的值，找到则交换对应位置上的数，未找到则退出第二层，继续第一层的遍历。时间复杂度O(N*N)

#include<stdio.h>    
void swap(int *a, int *b)
{
	*a = *a + *b;
	*b = *a - *b;
	*a = *a - *b;
}
void SelectSort(int a[], int n)
{
	int i, j, k, temp;
	for (i = 0; i < n - 1; i++)
	{
		k = i;

		for (j = i + 1; j < n; j++)
			if (a[k] > a[j])  k = j;
		
		if (k != i)
		{
			swap(&a[k],&a[i]);
		}
	}

}
int main(void)
{
	int a[10], i;
	for (i = 0; i<10; i++)
		scanf_s("%d", &a[i]);
	SelectSort(a, 10);
	printf("排序后的数组：\n");
	for (i = 0; i<10; i++)
		printf(" %d", a[i]);
	getchar();
	getchar();
	return 0;
}

冒泡排序：第一层从0开始遍历每一个数，第二层从底部开始往上遍历，每次遍历都与前数比较，大（小）则交换，则大（小）的数就像气泡一样不断地向上翻起，由于每次比较完的数相对位置不会再像选择排序经历多次变化，因此计算量减小。但是时间复杂度为O(0.5NN)，即O(N*N)

#include<stdio.h>
void swap(int *a, int *b)
{
	*a = *a + *b;
	*b = *a - *b;
	*a = *a - *b;
}
void BubbleSort(int a[], int n)
{
	int i, j;
	for (i = 0; i < n - 1; i++)
		for ( j = n - 1; j > i; j--)
		{
			if (a[j] > a[j - 1])
				swap(&a[j],&a[j-1]);
		}
}
int main(void)
{
	int a[10], i;
	for (i = 0; i<10; i++)
		scanf_s("%d", &a[i]);
	BubbleSort(a, 10);
	printf("排序后的数组：\n");
	for (i = 0; i<10; i++)
		printf(" %d", a[i]);
	getchar();
	getchar();
	return 0;
}

插入排序：以直接插入排序为例（折半插入排序，希尔排序道理类似），第一层循环遍历每一个要向前插入的数，第二层用于向前遍历应该插入的位置，新建的链表头结点不存数据。时间复杂度O(0.5NN)即O(NN)。插入排序可以不定长排序，预先并不需要获得所有的数据，可以来一个数据插入一个数据，从而实现外排序

#include <stdlib.h>
#include <stdio.h>

typedef struct node{
	int num;
	struct node *next;
}node,*linklist;

linklist CreateList(int n)
{
	node *p, *q, *head;
	int i = 0;
	head = (linklist)malloc(sizeof(node));		//头结点不存数据
	p = head;

	for ( i = 0;  i < n;  i++)
	{
		q = (linklist)malloc(sizeof(node));
		scanf_s("%d",&(q->num));
		p->next = q;
		p = q;
	}
	p->next = NULL;
	return head;
}

void PrintList(node *head)
{
	node *p = head->next;
	printf("sorted list is :\n"); 
	while (p != NULL)
	{
		printf("%d ", p->num);
		p = p->next;
	}
	printf("\n");
}

void InsertSort(node *head)
{
	node *p, *q, *ppre = head->next, *qpre = head;
	p = ppre->next;
	q = qpre->next;

	while (p != NULL)
	{
		do
		{
			if (p->num > q->num)
			{
				ppre->next = p->next;
				qpre->next = p;
				p->next = q;
				break;
			}
			else
			{
				qpre = q;
				q = q->next;
			}
		} while (q != p);
		
		PrintList(head);

		if (q == p)
			ppre = ppre->next;
		
		p = ppre->next;
		qpre = head;
		q = head->next;
	}
}

int main(void)
{
	node *head;
	head = CreateList(10);
	
	InsertSort(head);
	getchar();
	getchar();
	return 0;
}

插入排序数组实现

#include <stdio.h>

void InsertSort(int* arrayin, unsigned int len)
{
	unsigned int arraysize = len;
	int i = 0, j = 0, k = 0, valuetemp = 0;

	for (i = 1; i < arraysize; i++)
	{
		if (arrayin[i - 1] > arrayin[i])
		{
			j = i - 1;
			while (arrayin[j] > arrayin[i])
			{
				j--;
			}
			
			k = i - 1;
			valuetemp = arrayin[i];
			for (; k > j; k--)
				arrayin[k + 1] = arrayin[k];

			arrayin[k + 1] = valuetemp;
		}
	}
}

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

int main(void)
{
	int a[12] = { 1,3,3,5,6,1,20,55,2,33 };
	InsertSort(a,sizeof(a)/sizeof(int));
	PrintArray(a,sizeof(a)/sizeof(int));
}

归并排序待整理
快排：挖坑填数，左边全小于，右边全大于，嵌套调用

#include<stdio.h>
void PrintArray(int a[])
{
	int i;
	printf("NEW array:\n");
	for ( i = 0; i < 11; i++)
	{
		printf("%4d ",a[i]);
	}
	printf("\n");
}

void QuickSort(int a[], int left, int right)
{
	if (left < right)
	{
		int i = left,j = right,temp = a[left];
		while (i < j)
		{
			while ((i < j) && (temp < a[j]))
				j--;
			if (i < j)
				a[i++] = a[j];

			while ((i < j) && (temp > a[i]))
				i++;
			if (i < j)
				a[j--] = a[i];
		}
		a[i] = temp;
		PrintArray(a);
		QuickSort(a, left, i - 1);
		QuickSort(a, i + 1, right);
	}
}

int main(void)
{
	int a[11] = { 10,11,12,13,14,0,1,2,3,4,5 };
	PrintArray(a);
	QuickSort(a, 0, 10);
	PrintArray(a);
	getchar();
	return 0;
}

今天回头看，再补充一下：

#include "stdio.h"
#include "string.h"
#include "malloc.h"

void Swap(int* a, int* b)
{
	*a = *a + *b;
	*b = *a - *b;
	*a = *a - *b;
}

void PrintArray(int* a)
{
	int i = 0;
	for ( i = 0; i < 10; i++)
	{
		printf("%d ",*(a+i));
	}
	printf("\n");
}

void MergeArray(int* a, int begin1, int end1, int begin2, int end2, int *temp)
{
	int index = begin1;
	int i = begin1, j = begin2;

	while ((i <= end1)&&(j <= end2))
	{
		if (a[i] < a[j])
			temp[index++] = a[i++];
		else
			temp[index++] = a[j++];
	}

	while (i <= end1)
	{
		temp[index++] = a[i++];
	}
	while (j <= end2)
	{
		temp[index++] = a[j++];
	}
	
	memcpy(a + begin1, temp + begin1, sizeof(int) * (end2 - begin1 + 1));
}
//Nlog2N
void MergeSort(int* a,int left,int right,int *temp)
{
	int i = 0, j = 0;
	int mid = (left + ((right - left) >> 1));
	if (left >= right)
		return;

	MergeSort(a, left, mid, temp);
	MergeSort(a, mid+1, right, temp);

	MergeArray(a,left,mid,mid+1,right,temp);

	PrintArray(a);
}

int AdjustQS(int* a, int left, int right)
{
	int i = left, j = right;
	int x = a[i];

	while (i < j)
	{
		if (a[j] <= x)
		{
			a[i] = a[j];
			while (i < j)
			{
				i++;
				if (a[i] > x)
				{
					a[j] = a[i];
					break;
				}
			}
		}
		j--;
	}
	a[i] = x;

	return i;
}
//Nlog2N
void QuickSort(int* a,int start,int end)
{
	int i = 0;
	if (start < end)
	{
		i = AdjustQS(a, start, end);
		PrintArray(a);
		QuickSort(a, start, i-1);
		QuickSort(a, i+1, end);
	}
	else
		return;
}

//N*N
int* InsertSort(int* a)
{
	int i = 0, j = 0, k = 0;
	int temp;
	for (i = 1; i < 10; i++)
	{
		for (j = 0; j < i; j++)
		{
			if (a[i] < a[j])
			{
				temp = a[i];
				for (k = i; k > j; k--)
					a[k] = a[k - 1];
				a[j] = temp;
			}
		}
		PrintArray(a);
	}
	return a;
}

//N*N
int* PuppleSort(int* a)
{
	int i = 0, j = 0;
	for (j = 10; j > 0; j--)
	{
		for (i = 0; i < (j-1); i++)
		{
			if (a[i] > a[i + 1])
			{
				Swap(&a[i], &a[i + 1]);
			}
		}
		PrintArray(a);
	}
	return a;
}
//N*N
int* SelectSort(int* a)
{
	int i = 0, j = 0;
	for (i = 0; i < 10; i++)
	{
		for (j = i+1; j < 10; j++)
		{
			if (a[i] > a[j])
			{
				Swap(&a[i], &a[j]);
			}
		}
		PrintArray(a);
	}
	return a;
}

int main()
{
	int a[10] = { 2,10,1,15,12,20,8,3,7,0 };
	int* temp = (int*)malloc(sizeof(a) / sizeof(a[0]));

	PrintArray(a);
	printf("sort start\n");
	//SelectSort(a);
	//PuppleSort(a);
	//InsertSort(a);
	//MergeSort(a, 0, 9, temp);
	QuickSort(a, 0, 9);
	printf("sort end\n");
	PrintArray(a);
	getchar();
}