关于排序算法

 一、简单算法

（一）冒泡排序

注意：无论是慢慢把大数一步一步移到后面还是把小数一步一步移动到前面，都是一个道理。另外，注意flag的设定。

#include<iostream>
using namespace std;
#define MaxSize 10
typedef struct
{
	int r[MaxSize + 1];     //用于存储要排序的数组，r[0]用作哨兵或临时变量
	int length;            //用于记录顺组表的长度
}Sqlist;
void Swap(Sqlist *L,int i,int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}
void BubbleSort(Sqlist* L)
{
	int i;
	int j = 0;
	int flag = 1;
	for (i = L->length-1;i >= 0 && flag == 1;i--)
	{
		flag = 0;
		for (j = 0;j  < i;j++)
		{
			if (L->r[j] > L->r[j+1])
			{
				Swap(L, j, j+1);
				flag = 1;
			}
		}
	}
}
int main()
{
	Sqlist* L  = new Sqlist;
	L->length = 9;
	for(int i = 0;i < 9;i++)
	{
		L->r[i] = 20 - 2 * i;
	}
	BubbleSort(L);
	for (int i = 0;i < L->length;i++)
	{
		cout << L->r[i]<< endl;
	}

	system("pause");
	return 0;
}

（二）简单选择排序

#include<iostream>
using namespace std;
#define MaxSize 10

typedef struct
{
	int r[MaxSize + 1];     //用于存储要排序的数组，r[0]用作哨兵或临时变量
	int length;            //用于记录顺组表的长度
}Sqlist;
void Swap(Sqlist* L, int i, int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}
//简单选择排序
void SelectSort(Sqlist* L)
{
	int i, j, min;
	for (int i = 0;i < L->length;i++)
	{
		min = i;
		for (j = i + 1;j < L->length;j++)
		{
			if (L->r[min] > L->r[j])
			{
				min = j;
			}
		}
		if (min != i)
		{
			Swap(L, i, min);
		}
	}
}
int main()
{
	Sqlist* L = new Sqlist;
	L->length = 9;
	for (int i = 0;i < 9;i++)
	{
		L->r[i] = 20 - 2 * i;
	}
	SelectSort(L);
	for (int i = 0;i < L->length;i++)
	{
		cout << L->r[i] << endl;
	}

	system("pause");
	return 0;
}

简单选择排序在性能上略优于冒泡排序

（三） 直接插入排序

#include<iostream>
using namespace std;
#define MaxSize 10

typedef struct
{
	int r[MaxSize + 1];     //用于存储要排序的数组，r[0]用作哨兵或临时变量
	int length;            //用于记录顺组表的长度
}Sqlist;
void Swap(Sqlist* L, int i, int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}
//直接插入排序
void InsertSort(Sqlist* L)
{
	int j = 0;
	for (int i = 1;i < L->length;i++)
	{
		int temp = L->r[i];
		for (j = i; j > 0 && L->r[j - 1] > temp;j--)
		{
			L->r[j] = L->r[j - 1];
		}
		L->r[j] = temp;
	}
}
int main()
{
	Sqlist* L = new Sqlist;
	L->length = 9;
	for (int i = 0;i < 9;i++)
	{
		L->r[i] = 20 - 2 * i;
	}
	InsertSort(L);
	for (int i = 0;i < L->length;i++)
	{
		cout << L->r[i] << endl;
	}

	system("pause");
	return 0;
}

直接插入排序法比简单选择排序和冒泡性能好一点。

二、改进算法

（一）希尔排序

#include<iostream>
using namespace std;
#define MaxSize 10

typedef struct
{
	int r[MaxSize + 1];     //用于存储要排序的数组，r[0]用作哨兵或临时变量
	int length;            //用于记录顺组表的长度
}Sqlist;
void Swap(Sqlist* L, int i, int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}
//希尔排序
void ShellSort(Sqlist* L)
{
	
	int gap, i, j, temp;
	for (gap = L->length / 2; gap >= 1; gap /= 2)//缩小步长
	{
		for (i = gap; i < L->length; i++)    //对遍历到的数进行插入排序
			if (L->r[i] < L->r[i - gap])
			{
				temp = L->r[i];
				for (j = i - gap; j >= 0 && L->r[j] > temp; j -= gap)
					L->r[j + gap] = L->r[j];
				L->r[j + gap] = temp;
			}
	}
}
int main()
{
	Sqlist* L = new Sqlist;
	L->length = 9;
	for (int i = 0;i < 9;i++)
	{
		L->r[i] = 20 - 2 * i;
	}
	ShellSort(L);
	for (int i = 0;i < L->length;i++)
	{
		cout << L->r[i] << endl;
	}

	system("pause");
	return 0;
}

（二）堆排序

#include<iostream>
using namespace std;
#define MaxSize 10

typedef struct
{
	int r[MaxSize + 1];     //用于存储要排序的数组，r[0]用作哨兵或临时变量
	int length;            //用于记录顺组表的长度
}Sqlist;
void Swap(Sqlist* L, int i, int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}
void HeapAdjust(Sqlist *L, int s, int m)
{
	int temp = L->r[s];
	for (int j = 2 * s;j <= m;j * 2)
	{
		if (j < m && L->r[j] < L->r[j + 1])
		{
			++j;            //j记录关键字中较大的
		}
		if (temp >= L->r[j])
		{
			break;
		}
		L->r[s] = L->r[j];
		s = j;
	}
	L->r[s] = temp;
}
void HeapSort(Sqlist *L)
{
	int i;
	for (i = L->length / 2;i > 0;i--)             //把L中的r构建成一个小顶堆
	{
		HeapAdjust(L, i, L->length);
	}
	for (i = L->length;i > 1;i--)
	{
		Swap(L, 1, i);
		HeapAdjust(L, 1, i - 1);
	}
}
int main()
{
	Sqlist* L = new Sqlist;
	L->length = 9;
	for (int i = 0;i < 9;i++)
	{
		L->r[i] = 20 -  i;
	}
	HeapSort(L);
	for (int i = 0;i < L->length;i++)
	{
		cout << L->r[i] << endl;
	}
	system("pause");
	return 0;
}

不适合待排序列个数较少的情况。

（三）归并排序

#include<iostream>
using namespace std;
#define maxsize 10

typedef struct
{
	int r[maxsize + 1];     //用于存储要排序的数组，r[0]用作哨兵或临时变量
	int length;            //用于记录顺组表的长度
}sqlist;
void Merge(int SR[], int TR[], int i, int m, int n)
{
	int j, k, l;
	for (j = m + 1, k = i;i <= m && j <= n;k++)
	{
		if (SR[i] < SR[j])
			TR[k] = SR[i++];
		else
			TR[k] = SR[j++];
	}
	if (i <= m)
	{
		for (l = 0;l <= m - i;l++)
		{
			TR[k+1] = SR[i + 1];
		}
	}
	if (j <= n)
	{
		for (l = 0;l <= n - i;l++)
		{
			TR[k + 1] = SR[j + 1];
		}
	}
}
void MSort(int SR[], int TR1[], int s, int t)
{
	int m;
	int TR2[maxsize + 1];
	if (s == t)
		TR1[s] = SR[s];
	else
	{
		m = (s + t) / 2;
		MSort(SR, TR2, s, m);
		MSort(SR, TR2, m + 1, t);
		Merge(TR2, TR1, s, m, t);
	}
}
void Mergesort(sqlist *L)
{
	MSort(L->r, L->r, 1, L->length);
}
int main()
{
	sqlist* l = new sqlist;
	l->length = 9;
	for (int i = 0;i < 9;i++)
	{
		l->r[i] = 20 -  i;
	}
	Mergesort(l);
	for (int i = 0;i < l->length;i++)
	{
		cout << l->r[i] << endl;
	}
	system("pause");
	return 0;
}

（四）快速排序

#include<iostream>
using namespace std;
#define maxsize 10

typedef struct
{
	int r[maxsize + 1];     //用于存储要排序的数组，r[0]用作哨兵或临时变量
	int length;            //用于记录顺组表的长度
}sqlist;
void swap(sqlist *L,int i,int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = temp;
}
int Parttion(sqlist* L, int low, int high)
{
	int pivotkey;
	pivotkey = L->r[low];
	while (low < high)
	{
		while (low < high && L->r[high] >= pivotkey)
			high--;
		swap(L, low, high);
		while (low < high && L->r[low] <= pivotkey)
			low++;
		swap(L, low, high);
	}
	return low;                //返回枢纽所在位置
}
void QSort(sqlist *L,int low,int high)
{
	int pivot;
	if (low < high)
	{
		pivot = Parttion(L, low, high);

		QSort(L, low, pivot - 1);
		QSort(L, pivot + 1, high);
	}
}
void Quicksort(sqlist *L)
{
	QSort(L, 0, L->length-1);
}

int main()
{
	sqlist* l = new sqlist;
	l->length = 10;
	for (int i = 0;i < 10;i++)
	{
		l->r[i] = 20 -  i;
	}
	Quicksort(l);
	for (int i = 0;i < l->length;i++)
	{
		cout << l->r[i] << endl;
	}
	system("pause");
	return 0;
}