排序算法（一）

代码gitee地址：C_C++: C语言&C++https://gitee.com/han-tieyang/c--c.git

1、直接插入排序算法（稳定）

void main()
{
	int a[] = { 17, 46, 32, 87, 58, 9, 50, 38 };
	int t, i, j, n;
	n = sizeof(a) / sizeof(a[0]);
	printf("直接出入排序前：\n");
	PrintArray(a, n);
	printf("直接插入排序后：\n");
	for (i = 1; i < n; ++i)
	{
		t = a[i];
		for (j = i - 1; j >= 0 && t < a[j]; --j)   //循环比较，将此数移动到使序列排序正确的位置， 
			a[j + 1] = a[j];
		a[j + 1] = t;
		PrintArray(a, n);
	}
}

2、折半插入排序算法（稳定）

void main()
{
	int a[] = { 57, 46, 94, 15, 68, 52, 3, 75, 66 };
	int t, i, j, low, high, mid, n;
	n = sizeof(a) / sizeof(a[0]);
	printf("折半插入排序前：\n");
	PrintArray(a, n);
	printf("折半插入排序：\n");
	for (i = 1; i < n; ++i)
	{
		t = a[i];
		for (low = 0, high = i - 1; high >= low;)
		{
			mid = (low + high) / 2;
			if (t < a[mid])
				high = mid - 1;
			else
				low = mid + 1;
		}
		for (j = i - 1; j >= low; --j)
			a[j + 1] = a[j];
		a[j + 1] = t;
		PrintArray(a, n);
	}
}

3、插入排序的链式实现

头文件：单链表的操作实现

#include<stdio.h>

typedef int DataType;
typedef struct Node
{
	DataType data;
	struct Node *next;
}ListNode, *LinkList;

int ListLength(LinkList head)
/*求表长操作*/
{
	ListNode *p;
	int count = 0;
	p = head;
	while (p->next != NULL)
	{
		p = p->next;
		count++;
	}
	return count;
}
void DestroyList(LinkList head)
/*销毁链表*/
{
	ListNode *p, *q;
	p = head;
	while (p != NULL)
	{
		q = p;
		p = p->next;
		free(q);
	}
}


void InitList(LinkList *head)
/*初始化单链表*/
{
	if ((*head = (LinkList)malloc(sizeof(ListNode))) == NULL)		/*为头结点分配一个存储空间*/
		exit(-1);
	(*head)->next = NULL;		/*将单链表的头结点指针域置为空*/
}

int InsertList(LinkList head, int i, DataType e)
/*在单链表中第i个位置插入一个结点，结点的元素值为e。插入成功返回1，失败返回0*/
{
	ListNode *pre, *p;	/*定义第i个元素的前驱结点指针pre，指针p指向新生成的结点*/
	int j;
	pre = head;			/*指针p指向头结点*/
	j = 0;
	while (pre->next != NULL&&j<i - 1)/*找到第i－1个结点，即第i个结点的前驱结点*/
	{
		pre = pre->next;
		j++;
	}
	if (j != i - 1)					/*如果没找到，说明插入位置错误*/
	{
		printf("插入位置错误！");
		return 0;
	}
	/*新生成一个结点，并将e赋值给该结点的数据域*/
	if ((p = (ListNode*)malloc(sizeof(ListNode))) == NULL)
		exit(-1);
	p->data = e;
	/*插入结点操作*/
	p->next = pre->next;
	pre->next = p;
	return 1;
}
int DeleteList(LinkList head, int i, DataType *e)
/*删除单链表中的第i个位置的结点。删除成功返回1，失败返回0*/
{
	ListNode *pre, *p;
	int j;
	pre = head;
	j = 0;
	while (pre->next != NULL&&pre->next->next != NULL&&j<i - 1)/*判断是否找到前驱结点*/
	{
		pre = pre->next;
		j++;
	}
	if (j != i - 1)				/*如果没找到要删除的结点位置，说明删除位置有误*/
	{
		printf("删除位置有误");
		return 0;
	}
	/*指针p指向单链表中的第i个结点，并将该结点的数据域值赋值给e*/
	p = pre->next;
	*e = p->data;
	/*将前驱结点的指针域指向要删除结点的下一个结点，也就是将p指向的结点与单链表断开*/
	pre->next = p->next;
	free(p);				/*释放p指向的结点*/
	return 1;
}

算法实现：

//插入排序的链表实现函数的声明
void InsretSort(LinkList L);
void main()
{
	int i;
	DataType a[] = { 12, 33, 15, 34, 5, 98 };
	LinkList A;					//声明单链表A
	ListNode *p;
	InitList(&A);					//初始化单链表A
	for (i = 1; i <= sizeof(a) / sizeof(a[0]); i++)	//利用数组元素创建单链表A
	{
		if (InsertList(A, i, a[i - 1]) == 0)
		{
			printf("插入位置不合法!");
			return;
		}
	}
	InsretSort(A);
	p = A->next;
	while (p!=NULL)
	{
		printf("%4d", p->data);
		p = p->next;
	}
	printf("\n");
}

void InsretSort(LinkList L)
{
	ListNode *p = L->next, *pre, *q;
	L->next = NULL;
	while (p != NULL)
	{
		if (L->next == NULL)
		{
			L->next = p;
			p = p->next;
			L->next->next = NULL;
		}
		else
		{
			pre = L;
			q = L->next;
			while (q != NULL&&q->data < p->data)
			{
				pre = q;
				q = q->next;
			}
			q = p->next;
			p->next = pre->next;
			pre->next = p;
			p = q;
		}
	}
}

4、希尔排序（不稳定）

//希尔排序（不稳定）
void ShellSort(int a[], int n, int delta[], int m);
void ShellInsert(int a[], int n, int c);
void main()
{
	int a[] = { 17, 46, 32, 87, 58, 9, 50, 38, 17, 46, 32, 87, 58, 9, 50, 38 };
	int delta[] = { 6,4, 2, 1 }, m = 4, n;
	n = sizeof(a) / sizeof(a[0]);
	printf("希尔排序前：\n");
	PrintArray(a, n);
	ShellSort(a, n, delta, m);
	printf("希尔排序后：\n");
	PrintArray(a, n);
}

void ShellInsert(int a[], int n, int c)
{
	int i, j, t;
	for (i = c; i < n; ++i)
	{
		if (a[i] < a[i - c])
		{
			int t = a[i];
			for (j = i - c;j>=0&&t<a[j];j=j-c)
			{
				a[j + c] = a[j];
			}
			a[j + c] = t;
		}
	}
}

void ShellSort(int a[], int n, int delta[], int m)
{
	for (int i = 0; i < m; ++i)
	{
		ShellInsert(a, n, delta[i]);
		printf("第%d趟排序结果;", i + 1);
		PrintArray(a, n);
	}
}

5、冒泡排序（稳定）

void BubbleSort(int a[],int n);
void main()
{
	int a[] = { 64, 44, 12, 35, 98, 70, 22, 88 };
	int n = sizeof(a) / sizeof(a[0]);
	printf("冒泡排序前：\n");
	PrintArray(a, n);
	BubbleSort(a, n);
	printf("冒泡排序后：\n");
	PrintArray(a, n);
}

void BubbleSort(int a[], int n)
{
	int i, j, t;
	for (i = 1; i < n;++i)
	{ 
		for (j = 0; j < n - i; ++j)
		{
			if (a[j]>a[j + 1])
			{
				t = a[j];
				a[j] = a[j+1];
				a[j+1] = t;
			}
		}
		printf("第i趟排序的结果：",i);
		PrintArray(a, n);
	}
}

6、双向冒泡

//双向冒泡
void BubbleSort2(int a[], int n);

void main()
{
	int a[] = { 64, 44, 12, 35, 98, 70, 22, 88 };
	int n = sizeof(a) / sizeof(a[0]);
	printf("冒泡排序前：\n");
	PrintArray(a, n);
	BubbleSort2(a, n);
	printf("冒泡排序后：\n");
	PrintArray(a, n);
}

void BubbleSort2(int a[], int n)
{
	int i, t, flag = 1;
	int low = 0, high = n - 1;
	while (low < high&&flag)
	{
		flag = 0;
		for (i = low; i < high; ++i)
		{
			if (a[i]>a[i + 1])
			{
				t = a[i];
				a[i] = a[i+1];
				a[i+1] = t;
				flag = 1;
			}
		}
		high--;
		for (i = high; i > low; --i)
		{
			if (a[i] < a[i - 1])
			{
				t = a[i];
				a[i] = a[i-1];
				a[i-1] = t;
				flag = 1;
			}
		}
		low++;
		printf("第%d趟排序结果：", i);
		PrintArray(a, n);
	}
}

7、快速排序（不稳定）

//快速排序（不稳定）
//函数声明
void QSort(int a[], int n,int low,int high);
void QuickSort(int a[], int n);
int Partition(int a[], int low, int high);


void main()
{
	int a[] = { 64, 44, 12, 35, 70, 22, 88 };
	int n = sizeof(a) / sizeof(a[0]);
	printf("快速排序前：\n");
	PrintArray(a, n);
	//BubbleSort(a, n);
	QuickSort(a, n);
	printf("快速排序后：\n");
	PrintArray(a, n);
}

void QSort(int a[], int n, int low, int high)
{
	int pivot;
	static int count = 1;
	if (low < high)
	{
		pivot = Partition(a, low, high);
		PrintArray2(a, n, pivot, count);
		count++;
		QSort(a, n, low, pivot - 1);
		QSort(a, n, pivot + 1, high);
	}
}
void QuickSort(int a[], int n)
{
	QSort(a, n, 0, n - 1);
}
int Partition(int a[], int low, int high)
{
	int t, pivot;
	pivot = a[low];
	t = a[low];
	while (low < high)
	{
		while (low < high&&a[high] >= pivot)
			high--;
		if (low < high)
		{
			a[low] = a[high];
			low++;
		}
		while (low < high&&a[low] <= pivot)
			low++;
		if (low < high)
		{
			a[high] = a[low];
			high--;
		}
		a[low] = t;
	}
	return low;
}

8、简单选择排序（不稳定）

void SelectSort(int a[], int n);


void main()
{
	int a[] = { 64, 44, 12, 35, 70, 22, 88 };
	int n = sizeof(a) / sizeof(a[0]);
	printf("简单选择排序前：\n");
	PrintArray(a, n);
	SelectSort(a, n);
	printf("简单选择排序后：\n");
	PrintArray(a, n);
}

void SelectSort(int a[], int n)
{
	int i, j, k, t;
	for (i = 0; i < n - 1; ++i)
	{
		j = i;
		for (k = i + 1; k < n; ++k)
		{
			if (a[k] < a[j])
				j = k;
		}
		if (j != i)
		{
			t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
		printf("第%d趟排序结果：", i + 1);
		PrintArray(a, n);
	}
}

输出结果的实现：

void PrintArray(int a[], int n);
void PrintArray2(int a[], int n, int pivot, int count);

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

void PrintArray2(int a[], int n, int pivot, int count)
{
	int i;
	printf("第%d次划分结果：[", count);
	for (int i = 0; i < pivot; ++i)
	{
		printf("%-4d", a[i]);
	}
	printf("]");
	printf("%3d", a[pivot]);
	printf("[");
	for (i = pivot+1; i < n; ++i)
	{
		printf("%-4d", a[i]);
	}
	printf("]");
	printf("\n");
}