#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */
#define N 9
#define MAXSIZE 100 /* 用于要排序数组个数最大值 */
typedef struct
{
int r[MAXSIZE + 1]; /* 用于存储要排序数组,r[0]用作哨兵或临时变量 */
int length; /* 用于记录顺序表的长度 */
}SqList;
/* 交换L中数组r的下标为i和j的值 */
void swap(SqList *L, int i, int j)
{
int temp = L -> r[i];
L -> r[i] = L -> r[j];
L -> r[j] = temp;
}
void print(SqList L)
{
int i;
fo r(i = 1; i < L.length; i++)
{
printf("%d,", L.r[i]);
}
printf("%d", L.r[i]);
printf("\n");
}
/* 初级版冒泡排序*/
void BubbleSort0(SqList *L)
{
int i, j;
for (i = 1; i < L -> length; i++)
{
for (j = i + 1; j <= L -> length; j++)
{
if (L -> r[i] > L -> r[j])
{
swap(L, i, j); /* 交换L->r[i]与L->r[j]的值 */
}
}
}
}
/* 正宗版冒泡排序 */
void BubbleSort1(SqList *L)
{
int i, j;
for (i = 1; i < L -> length; i++)
{
swap(L, j, j + 1); /* 交换L->r[j]与L->r[j+1]的值 */
}
}
}
}
/*升级版冒泡排序 */
void BubbleSort2(SqList *L)
{
int i, j;
int 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 -> r[j] > L -> r[j + 1])
{
swap(L, j, j + 1); /* 交换L->r[j]与L->r[j+1]的值 */
flag = TRUE; /* 如果有数据交换,则flag为true */
}
}
}
}
/* 简单选择排序 */
void 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 -> r[min] > L -> r[j]) /* 如果有小于当前最小值的关键字 */
{
min = j; /* 将此关键字的下标赋值给min */
}
}
if (i != min) /* 若min不等于i,说明找到最小值,交换 */
{
swap(L, i, min); /* 交换L->r[i]与L->r[min]的值 */
}
}
}
/* 直接插入排序 */
void InsertSort(SqList *L)
{
int i, j;
for (i = 2; i <= L -> length; i++)
{
if (L -> r[i] < L -> r[i - 1]) /* 将L->r[i]插入有序子表 */
{
L -> r[0] = L -> r[i]; /* 设置哨兵 */
for (j = i - 1; L -> r[j] > L -> r[0]; j--)
{
L -> r[j + 1] = L -> r[j]; /* 记录后移 */
}
L -> r[j + 1] = L->r[0]; /* 插入到正确位置 */
}
}
}
/*希尔排序 */
void 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 -> r[i] < L -> r[i - increment]) /*将L->r[i]插入有序增量子表 */
{
L -> r[0] = L -> r[i]; /* 暂存在L->r[0] */
for (j = i - increment; j > 0 && L -> r[0] < L -> r[j]; j -= increment)
{
L -> r[j + increment] = L -> r[j]; /* 记录后移,查找插入位置 */
}
L -> r[j + increment] = L -> r[0]; /* 插入 */
}
}
printf("第%d趟排序结果: ",++k);
print(*L);
}
while(increment > 1);
}
/* 堆排序/
/* 已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义, 本函数调整L->r[s]的关键字,使L->r[s..m]成为一个大顶堆 */
void HeapAdjust(SqList *L , int s , int m)
{
int temp, j;
temp = L -> r[s];
for (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; /* rc应插入在位置s上 */
}
L -> r[s] = L -> r[j];
s = j;
}
L -> r[s] = temp; /* 插入 */
}
/* 堆排序 */
void HeapSort(SqList *L)
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]重新调整为大根堆 */
}
}
/* 归并排序*/
/* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */
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++)
/* 将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 */
}
}
}
/* 递归法 */
/* 将SR[s..t]归并排序为TR1[s..t] */
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;
/* 将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 MergeSort(SqList *L)
{
MSort(L -> r , L -> r , 1 , L -> length);
}
/* 非递归法 */
/* 将SR[]中相邻长度为s的子序列两两归并到TR[] */
void MergePass(int SR[] , int TR[] , int s , int n)
{
int i = 1;
int j;
while(i <= n - 2 * s + 1)
{ /* 两两归并 */
Merge(SR , TR , i , i + s - 1 , i + 2 * s - 1);
i = i + 2 *s;
}
if(i < n - s + 1) /* 归并最后两个序列 */
{
Merge(SR , TR , i , i + s - 1 , n);
}
else /* 若最后只剩下单个子序列 */
{
for(j = i ; j <= n ; j++)
{
TR[j] = SR[j];
}
}
}
/* 归并非递归排序 */
void MergeSort2(SqList *L)
{
int* TR = (int*)malloc(L -> length * sizeof(int)); /* 申请额外空间 */
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; /* 子序列长度加倍 */
}
}
/* 快速排序*/
/* 交换顺序表L中子表的记录,使枢轴记录到位,并返回其所在位置 ,
此时在它之前(后)的记录均不大(小)于它*/
int Partition(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; /* 返回枢轴所在位置 */
}
/* 对子序列L->r[low..high]作快速排序 */
void 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 QuickSort(SqList *L)
{
QSort(L , 1 , L -> length);
}
/* 快速排序优化算法 */
int Partition1(SqList *L , int low , int high)
{
int pivotkey;
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 , high , m); /* 交换中间与右端数据,保证中间较小 */
}
if(L -> r[m] > L -> r[low])
{
swap(L , m , low); /* 交换中间与左端数据,保证左端较小 */
}
pivotkey = L -> r[low]; /* 用子表的第一个记录作枢轴记录 */
L -> r[0] = pivotkey; /* 将枢轴关键字备份到L->r[0] */
while(low < high) /* 从表的两端交替地向中间扫描 */
{
while(low < high && L -> r[high] >= pivotkey)
{
high--;
}
L -> r[low] = L -> r[high];
while(low < high && L -> r[low] <= pivotkey)
{
low++;
}
L -> r[high] = L -> r[low];
}
L -> r[low] = L -> r[0];
return low; /* 返回枢轴所在位置 */
}
void QSort1(SqList *L , int low , int high)
{
int pivot;
if((high - low) > MAX_LENGTH_INSERT_SORT)
{
while(low < high)
{
pivot = Partition1(L , low , high);
/* 将L->r[low..high]一分为二,算出枢轴值pivot */
QSort1(L , low , pivot - 1); /* 对低子表递归排序 */
/* QSort(L,pivot+1,high); /* 对高子表递归排序 */
low = pivot + 1; /* 尾递归 */
}
}
else
{
InsertSort(L);
}
}
/* 快速排序 */
void QuickSort1(SqList *L)
{
QSort1(L , 1 , L -> length);
}
int main()
{
int i;
int a[N]={9 , 1 , 5 , 8 , 3 , 7 , 4 , 6 , 2};
SqList Q;
for(i = 0 ; i < N ; i++)
{
Q.r[i + 1] = a[i];
}
Q.length = N;
printf("排序前:\n");
print(Q);
printf("*******************\n");
printf("初级冒泡排序:\n");
BubbleSort0(&Q);
print(Q);
printf("*******************\n");
printf("正宗版冒泡排序:\n");
BubbleSort1(&Q);
print(Q);
printf("*******************\n");
printf("升级版冒泡排序:\n");
BubbleSort2(&Q);
print(Q);
printf("*******************\n");
printf("选择排序:\n");
SelectSort(&Q);
print(Q);
printf("*******************\n");
printf("直接插入排序:\n");
InsertSort(&Q);
print(Q);
printf("*******************\n");
printf("希尔排序:\n");
ShellSort(&Q);
print(Q);
printf("*******************\n");
printf("堆排序:\n");
HeapSort(&Q);
print(Q);
printf("*******************\n");
printf("归并排序(递归法):\n");
MergeSort(&Q);
print(Q);
printf("*******************\n");
printf("归并排序(非递归法):\n");
MergeSort2(&Q);
print(Q);
printf("*******************\n");
printf("快速排序:\n");
QuickSort(&Q);
print(Q);
printf("*******************\n");
printf("优化版快速排序:\n");
QuickSort1(&Q);
print(Q);
printf("*******************\n");
}
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */
#define N 9
#define MAXSIZE 100 /* 用于要排序数组个数最大值 */
typedef struct
{
int r[MAXSIZE + 1]; /* 用于存储要排序数组,r[0]用作哨兵或临时变量 */
int length; /* 用于记录顺序表的长度 */
}SqList;
/* 交换L中数组r的下标为i和j的值 */
void swap(SqList *L, int i, int j)
{
int temp = L -> r[i];
L -> r[i] = L -> r[j];
L -> r[j] = temp;
}
void print(SqList L)
{
int i;
fo r(i = 1; i < L.length; i++)
{
printf("%d,", L.r[i]);
}
printf("%d", L.r[i]);
printf("\n");
}
/* 初级版冒泡排序*/
void BubbleSort0(SqList *L)
{
int i, j;
for (i = 1; i < L -> length; i++)
{
for (j = i + 1; j <= L -> length; j++)
{
if (L -> r[i] > L -> r[j])
{
swap(L, i, j); /* 交换L->r[i]与L->r[j]的值 */
}
}
}
}
/* 正宗版冒泡排序 */
void BubbleSort1(SqList *L)
{
int i, j;
for (i = 1; i < L -> length; i++)
{
for (j = L -> length - 1; j >= i; j--) /* j是从后往前循环 */
{
if (L -> r[j] > L ->r[j + 1]) /* 前者大于后者*/
{swap(L, j, j + 1); /* 交换L->r[j]与L->r[j+1]的值 */
}
}
}
}
/*升级版冒泡排序 */
void BubbleSort2(SqList *L)
{
int i, j;
int 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 -> r[j] > L -> r[j + 1])
{
swap(L, j, j + 1); /* 交换L->r[j]与L->r[j+1]的值 */
flag = TRUE; /* 如果有数据交换,则flag为true */
}
}
}
}
/* 简单选择排序 */
void 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 -> r[min] > L -> r[j]) /* 如果有小于当前最小值的关键字 */
{
min = j; /* 将此关键字的下标赋值给min */
}
}
if (i != min) /* 若min不等于i,说明找到最小值,交换 */
{
swap(L, i, min); /* 交换L->r[i]与L->r[min]的值 */
}
}
}
/* 直接插入排序 */
void InsertSort(SqList *L)
{
int i, j;
for (i = 2; i <= L -> length; i++)
{
if (L -> r[i] < L -> r[i - 1]) /* 将L->r[i]插入有序子表 */
{
L -> r[0] = L -> r[i]; /* 设置哨兵 */
for (j = i - 1; L -> r[j] > L -> r[0]; j--)
{
L -> r[j + 1] = L -> r[j]; /* 记录后移 */
}
L -> r[j + 1] = L->r[0]; /* 插入到正确位置 */
}
}
}
/*希尔排序 */
void 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 -> r[i] < L -> r[i - increment]) /*将L->r[i]插入有序增量子表 */
{
L -> r[0] = L -> r[i]; /* 暂存在L->r[0] */
for (j = i - increment; j > 0 && L -> r[0] < L -> r[j]; j -= increment)
{
L -> r[j + increment] = L -> r[j]; /* 记录后移,查找插入位置 */
}
L -> r[j + increment] = L -> r[0]; /* 插入 */
}
}
printf("第%d趟排序结果: ",++k);
print(*L);
}
while(increment > 1);
}
/* 堆排序/
/* 已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义, 本函数调整L->r[s]的关键字,使L->r[s..m]成为一个大顶堆 */
void HeapAdjust(SqList *L , int s , int m)
{
int temp, j;
temp = L -> r[s];
for (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; /* rc应插入在位置s上 */
}
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); /* 将L->r[1..i-1]重新调整为大根堆 */
}
}
/* 归并排序*/
/* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */
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++)
/* 将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 */
}
}
}
/* 递归法 */
/* 将SR[s..t]归并排序为TR1[s..t] */
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;
/* 将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 MergeSort(SqList *L)
{
MSort(L -> r , L -> r , 1 , L -> length);
}
/* 非递归法 */
/* 将SR[]中相邻长度为s的子序列两两归并到TR[] */
void MergePass(int SR[] , int TR[] , int s , int n)
{
int i = 1;
int j;
while(i <= n - 2 * s + 1)
{ /* 两两归并 */
Merge(SR , TR , i , i + s - 1 , i + 2 * s - 1);
i = i + 2 *s;
}
if(i < n - s + 1) /* 归并最后两个序列 */
{
Merge(SR , TR , i , i + s - 1 , n);
}
else /* 若最后只剩下单个子序列 */
{
for(j = i ; j <= n ; j++)
{
TR[j] = SR[j];
}
}
}
/* 归并非递归排序 */
void MergeSort2(SqList *L)
{
int* TR = (int*)malloc(L -> length * sizeof(int)); /* 申请额外空间 */
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; /* 子序列长度加倍 */
}
}
/* 快速排序*/
/* 交换顺序表L中子表的记录,使枢轴记录到位,并返回其所在位置 ,
此时在它之前(后)的记录均不大(小)于它*/
int Partition(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; /* 返回枢轴所在位置 */
}
/* 对子序列L->r[low..high]作快速排序 */
void 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 QuickSort(SqList *L)
{
QSort(L , 1 , L -> length);
}
/* 快速排序优化算法 */
int Partition1(SqList *L , int low , int high)
{
int pivotkey;
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 , high , m); /* 交换中间与右端数据,保证中间较小 */
}
if(L -> r[m] > L -> r[low])
{
swap(L , m , low); /* 交换中间与左端数据,保证左端较小 */
}
pivotkey = L -> r[low]; /* 用子表的第一个记录作枢轴记录 */
L -> r[0] = pivotkey; /* 将枢轴关键字备份到L->r[0] */
while(low < high) /* 从表的两端交替地向中间扫描 */
{
while(low < high && L -> r[high] >= pivotkey)
{
high--;
}
L -> r[low] = L -> r[high];
while(low < high && L -> r[low] <= pivotkey)
{
low++;
}
L -> r[high] = L -> r[low];
}
L -> r[low] = L -> r[0];
return low; /* 返回枢轴所在位置 */
}
void QSort1(SqList *L , int low , int high)
{
int pivot;
if((high - low) > MAX_LENGTH_INSERT_SORT)
{
while(low < high)
{
pivot = Partition1(L , low , high);
/* 将L->r[low..high]一分为二,算出枢轴值pivot */
QSort1(L , low , pivot - 1); /* 对低子表递归排序 */
/* QSort(L,pivot+1,high); /* 对高子表递归排序 */
low = pivot + 1; /* 尾递归 */
}
}
else
{
InsertSort(L);
}
}
/* 快速排序 */
void QuickSort1(SqList *L)
{
QSort1(L , 1 , L -> length);
}
int main()
{
int i;
int a[N]={9 , 1 , 5 , 8 , 3 , 7 , 4 , 6 , 2};
SqList Q;
for(i = 0 ; i < N ; i++)
{
Q.r[i + 1] = a[i];
}
Q.length = N;
printf("排序前:\n");
print(Q);
printf("*******************\n");
printf("初级冒泡排序:\n");
BubbleSort0(&Q);
print(Q);
printf("*******************\n");
printf("正宗版冒泡排序:\n");
BubbleSort1(&Q);
print(Q);
printf("*******************\n");
printf("升级版冒泡排序:\n");
BubbleSort2(&Q);
print(Q);
printf("*******************\n");
printf("选择排序:\n");
SelectSort(&Q);
print(Q);
printf("*******************\n");
printf("直接插入排序:\n");
InsertSort(&Q);
print(Q);
printf("*******************\n");
printf("希尔排序:\n");
ShellSort(&Q);
print(Q);
printf("*******************\n");
printf("堆排序:\n");
HeapSort(&Q);
print(Q);
printf("*******************\n");
printf("归并排序(递归法):\n");
MergeSort(&Q);
print(Q);
printf("*******************\n");
printf("归并排序(非递归法):\n");
MergeSort2(&Q);
print(Q);
printf("*******************\n");
printf("快速排序:\n");
QuickSort(&Q);
print(Q);
printf("*******************\n");
printf("优化版快速排序:\n");
QuickSort1(&Q);
print(Q);
printf("*******************\n");
}