排序合集---2021年12月22日

1.直接插入排序

写出以单链表做存储结构的直接插入排序算法。
直接插入排序

从第二个元素开始，往前找，找的同时把前面的值赋值给后面，一旦比基准值小，则停止。

找到合适的位置插入。

从第二个开始找，因为需要前面有东西，一开始是与第一个比，后来就 是 和 i - 1 之前的数字 比较。

这里插入要注意：

对于数组来说，插入要把这个整个范围的数往后移动，得到结果。

对于链表来说，不需要移动结点，只需要交换值即可。

数组的写法：

开始的0位置 空出。
存放暂时值

前面的赋值到后面
数字覆盖
直到找到相应的位置。

//直接插入排序
void Seqlist<T>::InsertSort()
{
	int i = 0, j = 0;
	for (i = 2; i <= last; i++)
	{
		data[0] = data[i];
		j = i - 1;
		while (data[0] < data[j])  //往前覆盖，j靠近0.
		{
			data[j + 1] = data[j--];
		}
		data[j + 1] = data[0];
	}
}

链表

链表的核心思想就是把链表分成两部分 ， 一部分的头结点是first ，另一部分的头结点由p保存。

两条链。
first的链由只有一个结点不断加长，直到p为空链表（while循环结束的条件）。

//带表头的链表(类比数组的第二个数字)
template <class T>
void List<T>::insertsort()
{
	LinkNode<T>* p=0, * pre=0, * q=0;
	//首先记录第二个数字
	p = first->link->link;  //指向第二个结点的指针
	first->link->link = 0;   //构造只有一个结点和一个头结点的链表
	while (p != 0)
	{  
		q = p->link;
		pre = first;        //只有表头结点
		while (pre->link != NULL && pre->link->data < p->data)
		{
			pre = pre->link;//在first的链表中找位置。
		}
		//插入到first中。每次只插入一个p结点。
		p->link = pre->link;
		pre->link = p;
		p = q;
	}
}

2.折半插入排序

预留首个位置作为暂存位置。
找到头尾中的三个位置。
如果该值小于中间的值，则high=mid-1； 就是把高位往中间靠
以从小到大排序为例，首先用key存储需要排序的数据
第一步：折半查找——用low、mid、high划分两个区域【low，mid-1】和【mid+1，high】
第二步：判断——如果key值小于序列的中间值【mid】，则代表key值应该插入左边的区域【low，mid-1】，然后对【low，mid-1】再重复划分区域，直到low>high为止
第三步：插入——最后的插入位置应该是low(或者high+1都一样，因为low=high+1的)，我们只需要先将high之后位置的数据整体后移，然后将key赋值给【mid+1】，即完成插入。

// 折半插入排序算法
template <class E, class K>
void BinaryInsertSort(dataList<E, K>& L, int left, int right) {
	E temp;
	int low=0, high=0, mid=0; 
	for (int i = left + 1; i <= right; i++) 
	{
		temp = L[i];               //这里重载了[]这个符号
		low = left;
		high = i - 1;
		while (low <= high) 
		{
			mid = (low + high) / 2;
			if (temp < L[mid]) {
				high = mid - 1;
			}
			else {
				low = mid + 1;
			}
		}
		for (int k = i - 1; k >= low; k--) {
			L[k + 1] = L[k];
		}
		L[low] = temp;
	}
}

写法二：

// 折半插入排序算法
void Seqlist<T>::BinaryInsertSort() {
	E temp;
	int low=0, high=0, mid=0; 
	for (int i = 2; i <= right; i++) 
	{
		data[0] = data[i];               //这里重载了[]这个符号
		low = 1;
		high = i - 1;
		while (low <= high) 
		{
			mid = (low + high) / 2;
			if ( data[0] < data[mid]) 
			{
				high = mid - 1;
			}
			else {
				low = mid + 1;
			}
		}
		for (int k = i - 1; k >= low; k--) {
			 data[k + 1] =  data[k];    //把后面往前移，覆盖I 的值
		}
		 data[low] = data[0];
	}
}

3.希尔排序

给间隔排序，不是真正意义上的分组，只是操作数组时，按一定的顺序。

• 类似改进了的直接插入排序。
  优化插入排序的思想。进一步排序。
  分组，每次组距减小，直到减到1为止。
  （1）分组 di
  (2) 组内直接插入排序
  （3）缩小分组的间隔 di

按组把大的放后面，小的放前面。

di有各种不同的取法。

shell ： d1= n/2 (第一个间距) , di+1=di/2;

直接插入排序也应用到里面了。只是这里间隔是K

template <class E, class K>
void ShellSort(dataList<E, K>& L, int left, int right) {
	int i, j,
	gap = L.Length()/2;
	E temp;
	while (k >= 1)
	{
		for (i = k + 1; i <= last; i++)
		{
			data[0] = data[i]; //位置靠后的数字
			j = i - k;         //位置靠前的数字
			while (data[0] < data[j] && j>0)
			{
				data[j + k] = data[j];
				j = j - k;
			}
			data[j + k] = data[0];
		}
		k = k / 2;
	}
}

4.冒泡排序

// 冒泡排序
template <typename E, typename K>
void BubbleSort(dataList<E, K>& L) {
	int i = 0,j = 0;
	bool flag = true;
	int tem = 0;
	for (i = 1; i < last; i++)
	{
		flag = true;
		for(j=1;j<=last-i;j++)
		{	
			if (L[j] > L[j + 1])
			{
				flag = false;
				tem = data[j];
				data[j] = data[j + 1];
				data[j + 1] = tem;
			}
		}
		if (flag)  break;
	}
}

改进办法双向冒泡排序算法

把原来的双重for循环改了，
变成每次只出一个，正方向出一个，反方向出一个。

//改进版的冒泡排序(双向冒泡)
void BidBubbleSort(int array[], int n)
{
	int low, high, flag, i;
	low = 0;
	high = n - 1;
	while (low < high)
	{
		flag = 0;
		for (i = low; i < high; i++)          //正向冒泡
		{
			if (array[i] > array[i + 1])      //找到剩下中最大的
			{
				Swap(&array[i], &array[i + 1]);
				flag = 1;                    //标志， 有数据交换
			}
		}
		if (!flag)
			break;
		high--;
		for (i = high; i > low; i--) //反向冒泡
		{
			if (array[i] < array[i - 1])   //找到剩下中最小的
				Swap(&array[i], &array[i - 1]);
		}
		low++;
	}
}

5、快速排序

基本思想： 取一个基准值，将对象分为两个部分。
保证左侧子序列中所有对象的排序码都小于或等于基准对象的排序码。
右侧子序列中所有对象的排序码都大于基准值

基准对象排在这两个子序列中间
对子序列同样的方法， 直到所有元素在该位置上。

完成一次排序

int QuickPass(int low, int high)
	{
		int down = 0, up = 0;
		down = low;
		up = high;
		Element[0] = Element[low];//先保存低位置的数值，作为基准值
		while (down < up)
		{
			while ((down < up) && (Element[up] >= Element[0]))//找到第一个up位置的数值比基准值小
			{
				up--;
			}
			if (down < up)
			{
				Element[down++] = Element[up];
			}
			while ((down < up) && (Element[down] <= Element[0]))//找到第一个up位置的数值比基准值小
			{
				down++;
			}
			if (down < up)
			{
				Element[up--] = Element[down];
			}
		}
		Element[down] = Element[0];
		return down;
	}

递归

template <typename E, typename K>
//快速排序
void dataList<E, K>::QuickSort(int low, int high)
{
	int mid = 0;
	if (low < high)
	{
		mid = QuickPass(low, high);
		QuickSort(low, mid - 1);
		QuickSort(mid + 1, high);
	}
}

6、(直接)选择排序

// 直接选择排序的算法
template <typename E, typename K>
void SelectSort(dataList<E,K> &L, int left, int right){
	for (int i = left; i < right; i++)	{
		int k = i;
		for (int j = i+1; j <= right; j++){
			if (L[j] < L[k]) k = j;
		}
		if (k != i){
			L.Swap(i, k);
		}
	}
}

7、锦标赛排序

两两比较。
小的留下做父节点

类似哈夫曼树

往上生成树

用数组保存元素值

   这个过程可用一棵有n个叶子结点的完全二叉树表示，根节点中的关键字即为叶子结点中的最小关键字。在输出最小关键字之后，根据关系的可传递性，欲选出次小关键字， 仅需将叶子结点中的最小关键字改为“最大值”，如∞，然后从该叶子结点开始，和其左（右）兄弟的关键字进行比较，修改从叶子结点到根的路径上各结点的关键字，则根结点的关键字即为次小关键字。也就是所谓的树形选择排序，这种算法的缺点在于：辅助存储空间较多、最大值进行多余的比较。

8、堆排序

template <typename E, typename K>
void dataList<E, K>::Heapsort()
{
	int i = 0;
	E x;
	MyHeap<E> myheap;
	for (i = 1; i <= currentSize; i++)
	{
		myheap.Insert(Element[i]);
	}
	i = 1;
	while (!myheap.IsEmpty())
	{
		myheap.Remove(x);
		Element[i] = x;
		i++;
	}

}

9、归并排序

一个元素是有序序列，空也是有序序列。

10、分配排序

（1）桶排序

cin>>x;
data[x]=x;
用数组来排序。
但是浪费空间。
如果有重复值怎么办。

（2）基数排序