排序代码实践

排序代码，部分代码省略（未保存）
//排序练习
//学习自大话数据结构

#include<iostream>
#define MAXSIZE 10
using namespace std;
struct SqList//顺序表结构
{
	int r[MAXSIZE + 1];//存储排列数组，r[0]作哨兵或临时变量
	int length;
};
void swap(SqList*, int, int);//交换
void bubble_sort1(SqList*);//简单版冒泡排序
void bubble_sort2(SqList*);//冒泡排序
void bubble_sort3(SqList*);//冒泡排序改进版
void select_sort(SqList*);//选择排序法
void insert_sort(SqList*);//插入排序
void shell_sort(SqList*);//希尔排序
void heap_sort(SqList*);//堆排序,默认采用大顶堆（完全二叉树
void heapAdjust(SqList*, int, int);//默认除根节点已满足堆定义
void merge_sort(SqList*);//归并排序
void mSort(int[], int[], int, int);//递归实现归并排序,前数组无序，调用后后数组有序
void merge(int[], int[], int, int,int);//合并两数列并进排序
void merge_sort2(SqList*);//非递归归并排序
void mergePass(int[], int[], int, int);
void quick_sort(SqList*);//快速排序法
void qSort(SqList*, int, int);//递归实现快排
int partition(SqList*, int, int);//将list一分为二

int main()
{}
void swap(SqList* l, int a, int b)//交换
{
	int temp = l->r[a];
	l->r[a] = l->r[b];
	l->r[b] = temp;
}
void bubble_sort1(SqList* l)//简单版冒泡排序
{
	for (int i = 1; i < l->length; i++)
		for (int j = i + 1; j <= l->length; j++)
			if(l->r[i]>l->r[j])
				swap(l, i, j);
}
void bubble_sort2(SqList* l)//冒泡排序
{
	for (int i = 1; i < l->length; i++)
		for (int j = l->length - 1; j >= i; --j)
			if (l->r[j] > l->r[j + 1])
				swap(l,j, j + 1);
}
void bubble_sort3(SqList* l)//冒泡排序改进版
{
	bool flag = true;
	for (int i = 1; i < l->length && flag; i++)//循环未发生交换，即flag为false时退出循环
	{
		flag = false;
		for (int j = l->length - 1; j >= i; --j)
		{
			if (l->r[j] > l->r[j + 1])
			{
				swap(l, j, j + 1);
				flag = true;
			}
		}
	}
}
void select_sort(SqList* l)//选择排序法
{ 
	int min=1;
	for (int i = 1; i < l->length; i++)
	{
		min = i;
		for (int j = i + 1; j <= l->length; j++)
		{
			if (l->r[j] < l->r[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			swap(l, min, i);
		}
	}
}
void heap_sort(SqList * l)//堆排序,默认采用大顶堆（完全二叉树
{
	for (int i = l->length/ 2; i > 0; i--)//构建大顶堆
	{
		heapAdjust(l, i, l->length);
	}
	for (int i = l->length; i > 0; i--)
	{
		swap(l, 1, i);//取出最大值
		heapAdjust(l, 1, i - 1);//对堆进行调整
	}
	//获得从小到大的序列
}
void heapAdjust(SqList* l, int s, int m)//默认除根节点已满足堆定义
{
	int temp = l->r[s];
	for (int i = 2 * s; i <= m; i *= 2)
	{
		if (l->r[i] < l->r[i + 1])
			i++;
		if (l->r[i] < temp)
			break;
		l->r[s] = l->r[i];
		s = i;
	}
	l->r[s] = temp;
}
void merge_sort(SqList*l)//归并排序
{
	mSort(l->r, l->r, 1, l->length);
}
void mSort(int SR[], int TR1[ ], int s, int t)//递归实现归并排序,前数组无序，调用后后数组有序
{
	int m = (s + t) / 2;
	int TR2[MAXSIZE + 1];
	if (s == t)
		TR1[s] = SR[s];
	else
	{
		mSort(SR, TR2, s, m);
		mSort(SR, TR2, m + 1, t);
		merge(TR2, TR1, s, m, t);
	}
}
void merge(int SR[], int TR[], int i, int m, int n)//合并两数列并进行排序
{
	int k,j;
	for (j = m + 1, k = i; i <= m && j <= n; k++)
	{
		SR[i] > SR[j] ? TR[k] = SR[j++] : TR[k] = SR[i++];
	}
	if (i <= m)
	{
		for (int s = 0; s + i <= m; s++)
		{
			TR[k + s] = SR[i + s];
		}
	}
	if(j<=n)
	{
		for (int s = 0;s+j<=n;s++)
		{
			TR[k + s] = SR[s + j];
		}
	}
}
void merge_sort2(SqList* l)//非递归归并排序
{
	int TR[MAXSIZE + 1];
	int k = 1;//数组间隔
	while (k < l->length)
	{
		mergePass(l->r, TR, k,l->length);
		k = 2 * k;
		mergePass( TR, l->r, k, l->length);
		k = 2 * k;
	}
}
void mergePass(int SR[], int TR[], int s, int n)//将SR中相邻长度为s的子序列两两归并到TR中
{
	int i = 1;
	while(i<n-2*s+1)	
	{ 
		merge(SR, TR, i, i + s - 1, i + s * 2 - 1);
		i += 2 * s;
	}
	if(i+s-1<n)//剩两个子序列
	{
		merge(SR, TR, i, i + s - 1, n);
	}
	else//剩一个子序列
		for(int j=i;j<=n;j++)
		{
			TR[j] = SR[i];
		}
}
void quick_sort(SqList*l)//快速排序法
{
	qSort(l, 1, l->length);
}
void qSort(SqList*l, int low, int high)//递归实现快排
{
	//由于小数组时直接插入排序比快排性能更好
	//可增加判断if(high-low<MAX_LENGTH_INSERT_SORT） insert_sort(...)
	//使小数组时直接使用直接插入法进行排序
	if(low<high)
	{
		int pivot = partition(l, low, high);//获得中心点
		qSort(l, low, pivot - 1);
		qSort(l, pivot + 1, high);
	}
	//if语句可优化为while语句，采用迭代减少递归次数
	/*
	* 
	while(low<high)
	{
	int privot=partition(l,low,high);
	qsort(l,low,privot-1);
	low=privot+1;
	}
	*/
}
int partition(SqList* l, int low, int high)//将list一分为二
{
	//算法优化,防止privotkey极端小或大，三数取中
	//
	int m = low + (high + low) / 2;
	if (l->r[low] > l->r[high])
		swap(l, low, high);
	if (l->r[m] > l->r[high])
		swap(l, m, high);
	if (l->r[m] > l->r[low])
		swap(l, low, m);
	//
	int privotkey = l->r[low];
	//l->r[0] = privotkey;
	while (low < high)
	{
		while (l->r[high] >= privotkey&&low<high)
			high--;
		swap(l, low, high);
		//swap函数可优化如下，privotekey可存储至l->r[0]
		/*1.
		l->r[low]=l->r[high];
		*/
		while (l->r[low] <= privotkey && low < high)
			low++;
		swap(l, low, high);
		/*2.
		l->r[high]=l->r[low];
		l->r[low]=l->r[0];
		*/
	}
	return low;
}