排序算法-类编写

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

#define N 1000
class SqList
{
public:
	
	void BubbleSort(SqList *L);  //冒泡排序
	void BubbleSort2(SqList *L); //改进的冒泡排序
	void SelectSort(SqList *L);  //选择排序
	void InsertSort(SqList *L);  //插入排序
	void ShellSort(SqList *L);   //希尔排序
	void HeapSort(SqList *L);    //堆排序
	void MergeSort(SqList *L);   //归并排序
	void QuickSort(SqList *L);   //快速排序
	void SetArr(int len, int array[]);
	void print(SqList *L);
	
private:
	int arr[N];
	int length;
	void HeapAdjust(SqList *L, int s, int m);
	void swap(SqList *L, int i, int j);
	void MSort(int SR[], int TR1[], int s, int t);
	void Merge(int SR[], int TR[], int i, int m, int n);
	int Partition(SqList *L, int low, int high);
	void QSort(SqList *L, int low, int high);
};


int main()
{

	SqList L;
	int a[10] = { 5, 6, 4, 7, 8, 99, 41, 45, 12, 12 };
	int length = sizeof(a) / sizeof(int);
	L.SetArr(length,a);
	printf("冒泡排序：\n");
	L.BubbleSort(&L);
	L.print(&L);

	L.SetArr(length, a);
	printf("改进冒泡排序：\n");
	L.BubbleSort2(&L);
	L.print(&L);

	L.SetArr(length, a);
	printf("选择排序：\n");
	L.SelectSort(&L);
	L.print(&L);

	L.SetArr(length, a);
	printf("插入排序：\n");
	L.InsertSort(&L);
	L.print(&L);

	L.SetArr(length, a);
	printf("希尔排序：\n");
	L.ShellSort(&L);
	L.print(&L);

	L.SetArr(length, a);
	printf("堆排序：\n");
	L.HeapSort(&L);
	L.print(&L);

	L.SetArr(length, a);
	printf("归并排序：\n");
	L.MergeSort(&L);
	L.print(&L);

	L.SetArr(length, a);
	printf("快速排序：\n");
	L.QuickSort(&L);
	L.print(&L);
}


void SqList::BubbleSort(SqList *L) {
	if (L->arr == NULL || L->length == 0)
		return;
	for (int i = 1; i<L->length; i++)
	{
		for (int j = L->length; j>i; j--)
		{
			if (L->arr[j] < L->arr[j - 1])
			{
				swap(L, j - 1, j);
			}
		}
	}
}
void SqList::BubbleSort2(SqList *L)
{
	int i, j;
	bool flag = true;			/* flag用来作为标记 */
	for (i = 1; i<L->length && flag; i++) /* 若flag为true说明有过数据交换，否则停止循环 */
	{
		flag = false;				/* 初始为False */
		for (j = L->length - 1; j >= i; j--)
		{
			if (L->arr[j]>L->arr[j + 1])
			{
				swap(L, j, j + 1);	/* 交换L->r[j]与L->r[j+1]的值 */
				flag = true;		/* 如果有数据交换，则flag为true */
			}
		}
	}
}
void SqList::SelectSort(SqList *L)
{
	int i, j, min;
	for (i = 1; i<L->length; i++)
	{
		min = i;						/* 将当前下标定义为最小值下标 */
		for (j = i + 1; j <= L->length; j++)/* 循环之后的数据 */
		{
			if (L->arr[min]>L->arr[j])	/* 如果有小于当前最小值的关键字 */
				min = j;				/* 将此关键字的下标赋值给min */
		}
		if (i != min)						/* 若min不等于i，说明找到最小值，交换 */
			swap(L, i, min);				/* 交换L->r[i]与L->r[min]的值 */
	}
}

void SqList::InsertSort(SqList *L)
{
	int i, j;
	for (i = 2; i <= L->length; i++)
	{
		if (L->arr[i]<L->arr[i - 1]) /* 需将L->r[i]插入有序子表 */
		{
			L->arr[0] = L->arr[i]; /* 设置哨兵 */
			for (j = i - 1; L->arr[j]>L->arr[0]; j--)
				L->arr[j + 1] = L->arr[j]; /* 记录后移 */
			L->arr[j + 1] = L->arr[0]; /* 插入到正确位置 */
		}
	}
}
void SqList::ShellSort(SqList *L)
{
	int i, j, k = 0;
	int increment = L->length;
	do
	{
		increment = increment / 3 + 1;/* 增量序列 */
		for (i = increment + 1; i <= L->length; i++)
		{
			if (L->arr[i]<L->arr[i - increment])/*  需将L->r[i]插入有序增量子表 */
			{
				L->arr[0] = L->arr[i]; /*  暂存在L->r[0] */
				for (j = i - increment; j>0 && L->arr[0]<L->arr[j]; j -= increment)
					L->arr[j + increment] = L->arr[j]; /*  记录后移，查找插入位置 */
				L->arr[j + increment] = L->arr[0]; /*  插入 */
			}
		}
		printf("	第%d趟排序结果: ", ++k);
		print(L);
	} while (increment>1);
}
void SqList::HeapAdjust(SqList *L, int s, int m)
{
	int temp, j;
	temp = L->arr[s];
	for (j = 2 * s; j <= m; j *= 2) /* 沿关键字较大的孩子结点向下筛选 */
	{
		if (j<m && L->arr[j]<L->arr[j + 1])
			++j; /* j为关键字中较大的记录的下标 */
		if (temp >= L->arr[j])
			break; /* rc应插入在位置s上 */
		L->arr[s] = L->arr[j];
		s = j;
	}
	L->arr[s] = temp; /* 插入 */
}
void SqList::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); /*  将L->r[1..i-1]重新调整为大根堆 */
	}
}
void SqList::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++)	/* 将SR中记录由小到大地并入TR */
	{
		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 + l] = SR[i + l];		/* 将剩余的SR[i..m]复制到TR */
	}
	if (j <= n)
	{
		for (l = 0; l <= n - j; l++)
			TR[k + l] = SR[j + l];		/* 将剩余的SR[j..n]复制到TR */
	}
}
void SqList::MSort(int SR[], int TR1[], int s, int t)
{
	int m;
	int TR2[N + 1];
	if (s == t)
		TR1[s] = SR[s];
	else
	{
		m = (s + t) / 2;				/* 将SR[s..t]平分为SR[s..m]和SR[m+1..t] */
		MSort(SR, TR2, s, m);		/* 递归地将SR[s..m]归并为有序的TR2[s..m] */
		MSort(SR, TR2, m + 1, t);	/* 递归地将SR[m+1..t]归并为有序的TR2[m+1..t] */
		Merge(TR2, TR1, s, m, t);	/* 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t] */
	}
}
void SqList::MergeSort(SqList *L)
{
	MSort(L->arr, L->arr, 1, L->length);
}
int SqList::Partition(SqList *L, int low, int high)
{
	int pivotkey;

	pivotkey = L->arr[low]; /* 用子表的第一个记录作枢轴记录 */
	while (low<high) /*  从表的两端交替地向中间扫描 */
	{
		while (low<high&&L->arr[high] >= pivotkey)
			high--;
		swap(L, low, high);/* 将比枢轴记录小的记录交换到低端 */
		while (low<high&&L->arr[low] <= pivotkey)
			low++;
		swap(L, low, high);/* 将比枢轴记录大的记录交换到高端 */
	}
	return low; /* 返回枢轴所在位置 */
}
void SqList::QSort(SqList *L, int low, int high)
{
	int pivot;
	if (low<high)
	{
		pivot = Partition(L, low, high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
		QSort(L, low, pivot - 1);		/*  对低子表递归排序 */
		QSort(L, pivot + 1, high);		/*  对高子表递归排序 */
	}
}
void SqList::QuickSort(SqList *L)
{
	QSort(L, 1, L->length);
}
void SqList::SetArr(int len, int array[])
{
	length = len;
	for (int i = 1; i <= length; i++)
	{
		arr[i] = array[i - 1];
	}
}
void SqList::swap(SqList *L, int i, int j)
{
	int temp = L->arr[i];
	L->arr[i] = L->arr[j];
	L->arr[j] = temp;
}
void SqList::print(SqList *L)
{
	for (int i = 1; i <= L->length; i++)
		printf("%d ", L->arr[i]);
	printf("\n");
}