#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");
}
排序算法-类编写
最新推荐文章于 2022-12-01 22:10:52 发布