冒泡排序、插入排序算法、合并排序算法和快速排序算法

题目要求：
（1）分别针对随机生成的若干组整数序列（比如规模为1000个数，10000个数，100000个数）进行排序，排序算法使用四种方法，至少包括以下三种经典方法：插入排序算法、合并排序算法和快速排序算法
（2）在用不同的排序算法对多组整数进行排序时，统计各种情况下排序所耗费的时间，并对结果进行分析
（3）当要求为降序时，如何修改？并尝试实现
（4）如果随机生成了10个数，在使用快速排序进行排序时，尝试给出数组的演化情况。分析排序算法的稳定性及排序算法的空间性能

主要思路：
在主程序中先随机生成数组，在调用各种排序函数，最后统计各种情况下排序所耗费的时间

第一步是随机生成数组，先让用户输入随机生成的整数序列的规模，并将其赋值给生成随机数的循环上限。a[i]=1+rand()%N;这一步中的N表示生成的每个随机数在多大的范围内，题目中没有要求，我就将其定为和数组的规模相同，如果题目后续有要求的话，可以把N换成1000，100000等等。

第二步是调用各种排序函数，这些函数都非常经典，代码没什么难点，相关注释都在代码中体现了。因为调用函数后会改变原函数的顺序，所以我将随机生成的数组复制了3组，这里就产生了一个问题，一开始因为随机生成的数组规模有大到100000，所以我定义的数组为int a[100000];但是如果复制的数组也为int b[100000];三组复制后不能运行了，我猜想是太大了，所以将复制的数组降低了一个数量级int b[10000]; int c[10000];int d[10000]；分别调用一个函数。一开始合并排序是采用的递归方法，但是当输入规模增大时，会表现出效率低的缺点，且在排序过程中会不断的开辟临时空间，容易造成内存混乱。所以在代码中附了一个非递归式的方法，具体实现过程体现在注释中。

第三步是计算每个排序方法的耗费时间，分别在不改变数组规模和改变数组规模后进行计算，测试结果汇总到表格如下：

时间耗费/ms （1000） （1000） （1000） （2000） （4000） （8000） （10000）
冒泡排序 100 98 109 227 521 1074 1311
插入排序 98 84 100 208 469 1030 1121
合并排序 107 90 100 202 521 997 1094
快速排序 96 96 111 200 429 920 1097
我们从上述表格可以发现：
（1） 当生成相同规模的随机数组时，四种排序算法的耗费时间相对大小会有所变化，第一次合并排序时间最长，第二次冒泡排序时间最长，第三次快速排序时间最长。
（2） 当生成的随机数组规模越来越大，可以发现冒泡排序耗费时间最长，其次是插入排序，快速排序耗费时间最短。

第四步是将升序改为降序。
对于冒泡排序而言，就是将if (aa[j]>aa[j+1])里的“>”换成“<”，将每次循环中最小的数置到最后；
对于插入排序而言，就是将if(bb[i]<bb[i-1])和while(j>=0&&x<bb[j])里的“<”换成“>”把比基准小的数依次后移；
对于合并排序而言，就是将if(L[i]<=R[j])里的“<”换成“>”，两个子序列首元素做比较，大者取出置入父序列；
对于快速排序而言，就是将while(i<j && a[j] >= x) j–里的“>”换成”<”，从最右侧元素开始，如果比哨兵小，那么它的位置就正确，然后判断前一个元素，直到不满足条件，再将while(i<j && a[i] <= x) i++; 里的“<”换成”>”，让下标为i的元素开始与哨兵比较大小，比其大，那么它所处的位置就正确，然后判断后一个，直到不满足条件。

第五步是使用快速排序进行排序时，数组的演化情况。演化过程中省略了位置相对正确的判断，只显示了元素有交换位置的演化步骤，具体过程如代码所示。
排序算法的稳定性和空间性能
（1）冒泡排序就是把小的元素往前调（或者把大的元素往后调）。是相邻的两个元素进行比较，而且是否需要交换也发生在这两个元素之间。所以，如果两个元素相等，就不用交换，如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个元素相邻起来，最终也不会交换它俩的位置，所以相同元素经过排序后顺序并没有改变。
所以冒泡排序的时间复杂度是O(n^2)，空间复杂度为O(1)，是一种稳定排序算法。
（2）插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，也就是第一个元素（默认它有序）。比较是从有序序列的末尾开始，也就是把待插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面。否则一直往前找直到找到它该插入的位置。如果遇见一个与插入元素相等的，那么把待插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序仍是排好序后的顺序。
所以插入排序的时间复杂度在最好情况下为O(n)，最坏情况下为O(n^2)，空间复杂度为O(1)，是稳定的。
（3）合并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素（认为直接有序）或者2个序列（1次比较和交换)，然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。
所以，合并排序时间复杂度是O(nlgn)，空间复杂度是O(n)，也是稳定的排序算法。
（4）快速排序有两个方向，左边的i下标一直往右走，而右边的 j 下标一直往左走，如果i和j都走不动了，i<=j, 交换a[i]和a[j]，重复上面的过程，直到i>j。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11 现在中枢元素 5 和 3（第 5 个元素，下标从 1 开始计）交换就会把元素 3 的稳定性打乱。
所以快速排序的时间复杂度在最好情况下是O(nlgn)，在最坏情况下是O(n^2)，空间复杂度在最坏情况下是O(n)，是一个不稳定的排序算法，不稳定发生在中枢元素和 a[j] 交换的时刻。

#include<iostream>
#include<iomanip>
#include<time.h>
using namespace std; //随机数函数头文件
void print(int arr[], int n)
{  
    for(int j=0;j<n;j++)
	{  
      cout<<arr[j]<<'\t';  
     }  
    cout<<endl;  
}  
void BubbleSort(int aa[], int n)
{
    for (int i=0; i<n-1; i++) //每一轮比较都把最大的数放到最后
	{
            for (int j=0;j<n-i-1;j++) //循环比较相邻两个数
	        {
                    if (aa[j]>aa[j+1])  //如果第j个元素比后一个大
					{
                            int temp=aa[j];
                            aa[j]=aa[j+1]; //就交换二者的位置
                            aa[j+1]=temp;
                     }
             }
     }
}
void insertSort(int bb[], int n)
{
   for(int i=1;i<n;i++) //第一个元素作为基准元素，从第二个元素开始把其插到正确的位置
   {
	  if(bb[i]<bb[i-1]) //如果第i个元素比前面的元素小
	  {
	      int j=i-1;     //需要判断第i个元素与前面的多个元素的大小，换成j继续判断
              int x=bb[i]; //将第i个元素复制为哨兵
	      while(j>=0&&x<bb[j]) //找哨兵的正确位置，比哨兵大的元素依次后移
	      {
                 bb[j+1]=bb[j]; 
	             j--;
	      }
	      bb[j+1] = x;  //把哨兵插入到正确的位置
	  }   
   }
}
void mergesort(int cc[],int n)  //合并排序的递归主体
{
    void merge(int cc[], int L[], int R[], int l, int r);  //声明merge函数
    if(n>1)    //多于一个元素才需要排序
    {
        int mid=n/2;
        int *left=(int*)malloc(sizeof(int)*mid);
        int *right=(int*)malloc(sizeof(int)*(n-mid));
        for(int i=0;i<mid;i++)
            left[i]=cc[i];       //建立临时数组存储左半部分序列
        for(int j=mid;j<n;j++)
            right[j-mid]=cc[j];  //建立临时数组存储右半部分序列
        mergesort(left,mid);    //调用自身对左半部分进行合并排序
        mergesort(right,n-mid); //调用自身对右半部分进行合并排序
        merge(cc,left,right,mid,n-mid);   //两个有序序列的合并操作，封装为函数
        free(left);
        free(right);
    }
}
void merge(int cc[],int L[],int R[],int l,int r)  //两个有序序列L、R合并为A，l,r分别为L,R的长度
{
    int i=0,j=0,k=0;
    while(i<l&&j<r)  //两个子序列首元素做比较，小者取出置入父序列
    {
        if(L[i]<=R[j])
            cc[k++]=L[i++];
        else
            cc[k++]=R[j++];
    }
    while(i<l)       //将左半部分剩余元素置入父序列
    {
        cc[k++]=L[i++];
    }
    while(j<r)       //将右半部分剩余元素置入父序列
    {
        cc[k++]=R[j++];
    }
}
/*void mergesort(int A[], int n){    //非递归实现。只开辟一个大小与待排序数组相同的存储数组，排序过程中直接在该数组上进行操作。不反复开辟临时数组
	int step;   
	int *p, *q, *t;
	int i, j, k, len1, len2;
	int *temp;  
	step = 1;      //初始步长为1，即将单个元素作为有序子序列进行合并
	p = A;
	q = (int*)malloc(sizeof(int)*n);  //q为临时开辟的空间，用来存储已排序序列，大小为待排序数组的长度
	temp = q;                              //temp与q指向同一段内存，留作最后释放内存空间时使用，因为q指针在后面排序操作中可能会改变指向
	while (step<n)
	{
		i = 0;
		j = i + step;
		k = i;                             //k用作临时数组的下标
		len1 = i + step < n ? i + step : n;   //len1表示有序序列1的下标上限
		len2 = j + step < n ? j + step : n;   //len2表示有序序列2的下标上限
		while (i<n)
		{
			while (i<len1&&j<len2)        //两个子序列首元素做比较，小者取出置入父序列
			{
				q[k++] = p[i]<p[j] ? p[i++] : p[j++];
			}
			while (i<len1)                //将子序列1的剩余元素置入父序列
			{
				q[k++] = p[i++];
			}
			while (j<len2)                //将子序列2的剩余元素置入父序列
			{
				q[k++] = p[j++];
			}
			i = j;                        //j经过自增变为len2，然后赋值给i
			j = i + step;                 //i被赋值为len2,加上步长再赋值给j
			k = i;                        
			len1 = i + step < n ? i + step : n;
			len2 = j + step < n ? j + step : n;
		}
		step *= 2;   //步长翻倍，即将原步长2倍个数的数组元素作为有序子序列进行合并
		t = p;       //t作为临时指针变量，用于交换p和q的指针指向
		p = q;       //将p指针指向经过一轮合并排序后的临时数组
		q = t;       //将q指针指向原数组
	}
	if (A != p){     //如果最终p指针的指向改变为临时数组，则将完成排序的数组拷贝至原数组
		memcpy(A, p, sizeof(int)*n);
	}
	free(temp);
}*/
void quickSort(int a[], int low ,int high)
{
	if(low<high)  //判断是否满足排序条件，递归的终止条件
	{
		int i = low, j = high;   //把待排序数组元素的第一个和最后一个下标分别赋值给i,j，使用i,j进行排序；
		int x = a[low];    //将待排序数组的第一个元素作为哨兵，将数组划分为大于哨兵以及小于哨兵的两部分                                   
		while(i<j)  
		{
		  while(i<j && a[j] >= x) j--;  //从最右侧元素开始，如果比哨兵大，那么它的位置就正确，然后判断前一个元素，直到不满足条件
		  if(i<j) a[i++] = a[j];   //把不满足位次条件的那个元素值赋值给第一个元素，（也即是哨兵元素，此时哨兵已经保存在x中，不会丢失）并把i的加1
		  while(i<j && a[i] <= x) i++; //换成左侧下标为i的元素开始与哨兵比较大小，比其小，那么它所处的位置就正确，然后判断后一个，直到不满足条件
		  if(i<j) a[j--] = a[i];  //把不满足位次条件的那个元素值赋值给下标为j的元素，（下标为j的元素已经保存到前面，不会丢失）并把j的加1
		} 
	        a[i] = x;   //完成一次排序，把哨兵赋值到下标为i的位置，即前面的都比它小，后面的都比它大
		quickSort(a, low ,i-1);  //递归进行哨兵前后两部分元素排序 ， low,high的值不发生变化，i处于中间
		quickSort(a, i+1 ,high);
	}
}
void main()
{
  int N;
  cout<<"请输入随机生成的整数序列的数字个数：";
  cin>>N;
  int a[100000];
  srand(time(0)); //调用随机数
  for(int i=0;i<N;i++)
  {
    a[i]=1+rand()%N; //随机数的使用方法
  }
  cout<<"随机生成的数组为：\n";
  print(a,N);
  int b[10000];
  int c[10000];
  int d[10000];
  memcpy(b,a,sizeof(b));
  memcpy(c,a,sizeof(b));
  memcpy(d,a,sizeof(b));
  double start1, finish1; /* 定义开始的时间和结束的时间 */
  double start2, finish2;
  double start3, finish3;
  double start4, finish4;
  
  start1=(double)clock(); 
  BubbleSort(a,N);//冒泡排序函数
  
  cout<<"冒泡排序后生成的数组为：\n";
  print(a,N);
  cout<<"排序耗费的时间为：\n";
  finish1=(double)clock();
  printf("%.4fms\n", (finish1-start1));
  
  start2=(double)clock(); 
  insertSort(b,N);//插入排序函数
  cout<<"插入排序后生成的数组为：\n";
  print(b,N);
  cout<<"排序耗费的时间为：\n";
  finish2=(double)clock();
  printf("%.4fms\n", (finish2-start2));
  
  start3=(double)clock(); 
  mergesort(c,N);//合并排序函数
  cout<<"合并排序后生成的数组为：\n";
  print(c,N);
  cout<<"排序耗费的时间为：\n";
  finish3=(double)clock();
  printf("%.4fms\n", (finish3-start3));
  
  start4=(double)clock();
  quickSort(d,0,N-1);//快速排序函数
  cout<<"快速排序后生成的数组为：\n";
  print(d,N);
  cout<<"排序耗费的时间为：\n";
  finish4=(double)clock();
  printf("%.4fms\n", (finish4-start4));
}

#include<iostream>
#include<iomanip>
#include<time.h>
using namespace std; //随机数函数头文件
void print(int arr[], int n)
{  
    for(int j=0;j<n;j++)
	{  
      cout<<arr[j]<<'\t';  
     }  
    cout<<endl;  
}  
void BubbleSort(int aa[], int n)
{
    for (int i=0; i<n-1; i++) //每一轮比较都把最大的数放到最后
	{
            for (int j=0;j<n-i-1;j++) //循环比较相邻两个数
	        {
                    if (aa[j]<aa[j+1])  //如果第j个元素比后一个大
					{
                            int temp=aa[j];
                            aa[j]=aa[j+1]; //就交换二者的位置
                            aa[j+1]=temp;
                     }
             }
     }
}
void insertSort(int bb[], int n)
{
   for(int i=1;i<n;i++) //第一个元素作为基准元素，从第二个元素开始把其插到正确的位置
   {
	  if(bb[i]>bb[i-1]) //如果第i个元素比前面的元素大
	  {
	      int j=i-1;     //需要判断第i个元素与前面的多个元素的大小，换成j继续判断
              int x=bb[i]; //将第i个元素复制为哨兵
	      while(j>=0&&x>bb[j]) //找哨兵的正确位置，比哨兵小的元素依次后移
	      {
                 bb[j+1]=bb[j]; 
	             j--;
	      }
	      bb[j+1]=x;  //把哨兵插入到正确的位置
	  }   
   }
}
void mergesort(int cc[],int n)  //合并排序的递归主体
{
    void merge(int cc[], int L[], int R[], int l, int r);  //声明merge函数
    if(n>1)    //多于一个元素才需要排序
    {
        int mid=n/2;
        int *left=(int*)malloc(sizeof(int)*mid);
        int *right=(int*)malloc(sizeof(int)*(n-mid));
        for(int i=0;i<mid;i++)
            left[i]=cc[i];       //建立临时数组存储左半部分序列
        for(int j=mid;j<n;j++)
            right[j-mid]=cc[j];  //建立临时数组存储右半部分序列
        mergesort(left,mid);    //调用自身对左半部分进行合并排序
        mergesort(right,n-mid); //调用自身对右半部分进行合并排序
        merge(cc,left,right,mid,n-mid);   //两个有序序列的合并操作，封装为函数
        free(left);
        free(right);
    }
}
void merge(int cc[],int L[],int R[],int l,int r)  //两个有序序列L、R合并为cc，l,r分别为L,R的长度
{
    int i=0,j=0,k=0;
    while(i<l&&j<r)  //两个子序列首元素做比较，大者取出置入父序列
    {
        if(L[i]>=R[j])
            cc[k++]=L[i++];
        else
            cc[k++]=R[j++];
    }
    while(i<l)       //将左半部分剩余元素置入父序列
    {
        cc[k++]=L[i++];
    }
    while(j<r)       //将右半部分剩余元素置入父序列
    {
        cc[k++]=R[j++];
    }
}
/*void mergesort(int A[], int n){    //非递归实现。只开辟一个大小与待排序数组相同的存储数组，排序过程中直接在该数组上进行操作。不反复开辟临时数组
	int step;   
	int *p, *q, *t;
	int i, j, k, len1, len2;
	int *temp;  
	step = 1;      //初始步长为1，即将单个元素作为有序子序列进行合并
	p = A;
	q = (int*)malloc(sizeof(int)*n);  //q为临时开辟的空间，用来存储已排序序列，大小为待排序数组的长度
	temp = q;                              //temp与q指向同一段内存，留作最后释放内存空间时使用，因为q指针在后面排序操作中可能会改变指向
	while (step<n)
	{
		i = 0;
		j = i + step;
		k = i;                             //k用作临时数组的下标
		len1 = i + step < n ? i + step : n;   //len1表示有序序列1的下标上限
		len2 = j + step < n ? j + step : n;   //len2表示有序序列2的下标上限
		while (i<n)
		{
			while (i<len1&&j<len2)        //两个子序列首元素做比较，小者取出置入父序列
			{
				q[k++] = p[i]<p[j] ? p[i++] : p[j++];
			}
			while (i<len1)                //将子序列1的剩余元素置入父序列
			{
				q[k++] = p[i++];
			}
			while (j<len2)                //将子序列2的剩余元素置入父序列
			{
				q[k++] = p[j++];
			}
			i = j;                        //j经过自增变为len2，然后赋值给i
			j = i + step;                 //i被赋值为len2,加上步长再赋值给j
			k = i;                        
			len1 = i + step < n ? i + step : n;
			len2 = j + step < n ? j + step : n;
		}
		step *= 2;   //步长翻倍，即将原步长2倍个数的数组元素作为有序子序列进行合并
		t = p;       //t作为临时指针变量，用于交换p和q的指针指向
		p = q;       //将p指针指向经过一轮合并排序后的临时数组
		q = t;       //将q指针指向原数组
	}
	if (A != p){     //如果最终p指针的指向改变为临时数组，则将完成排序的数组拷贝至原数组
		memcpy(A, p, sizeof(int)*n);
	}
	free(temp);
}*/
void quickSort(int a[], int low ,int high)
{
	if(low<high)  //判断是否满足排序条件，递归的终止条件
	{
		int i=low, j=high;   //把待排序数组元素的第一个和最后一个下标分别赋值给i,j，使用i,j进行排序；
		int x=a[low];    //将待排序数组的第一个元素作为哨兵，将数组划分为大于哨兵以及小于哨兵的两部分                                   
		while(i<j)  
		{
		  while(i<j && a[j] <= x) j--;  //从最右侧元素开始，如果比哨兵小，那么它的位置就正确，然后判断前一个元素，直到不满足条件
		  if(i<j) a[i++] = a[j];   //把不满足位次条件的那个元素值赋值给第一个元素，（也即是哨兵元素，此时哨兵已经保存在x中，不会丢失）并把i的加1
		  while(i<j && a[i] >= x) i++; //换成左侧下标为i的元素开始与哨兵比较大小，比其大，那么它所处的位置就正确，然后判断后一个，直到不满足条件
		  if(i<j) a[j--] = a[i];  //把不满足位次条件的那个元素值赋值给下标为j的元素，（下标为j的元素已经保存到前面，不会丢失）并把j的加1
		} 
	        a[i] = x;   //完成一次排序，把哨兵赋值到下标为i的位置，即前面的都比它小，后面的都比它大
		quickSort(a, low ,i-1);  //递归进行哨兵前后两部分元素排序 ， low,high的值不发生变化，i处于中间
		quickSort(a, i+1 ,high);
	}
}
void main()
{
  int N;
  cout<<"请输入随机生成的整数序列的数字个数：";
  cin>>N;
  int a[100000];
  srand(time(0)); //调用随机数
  for(int i=0;i<N;i++)
  {
    a[i]=1+rand()%N; //随机数的使用方法
  }
  cout<<"随机生成的数组为：\n";
  print(a,N);
  int b[10000];
  int c[10000];
  int d[10000];
  memcpy(b,a,sizeof(b));
  memcpy(c,a,sizeof(b));
  memcpy(d,a,sizeof(b));
  double start1, finish1; /* 定义开始的时间和结束的时间 */
  double start2, finish2;
  double start3, finish3;
  double start4, finish4;
  
  start1=(double)clock(); 
  BubbleSort(a,N);//冒泡排序函数
  
  cout<<"冒泡排序后生成的数组为：\n";
  print(a,N);
  cout<<"排序耗费的时间为：\n";
  finish1=(double)clock();
  printf("%.4fms\n", (finish1-start1));
  
  start2=(double)clock(); 
  insertSort(b,N);//插入排序函数
  cout<<"插入排序后生成的数组为：\n";
  print(b,N);
  cout<<"排序耗费的时间为：\n";
  finish2=(double)clock();
  printf("%.4fms\n", (finish2-start2));
  
  start3=(double)clock(); 
  mergesort(c,N);//合并排序函数
  cout<<"合并排序后生成的数组为：\n";
  print(c,N);
  cout<<"排序耗费的时间为：\n";
  finish3=(double)clock();
  printf("%.4fms\n", (finish3-start3));
  
  start4=(double)clock();
  quickSort(d,0,N-1);//快速排序函数
  cout<<"快速排序后生成的数组为：\n";
  print(d,N);
  cout<<"排序耗费的时间为：\n";
  finish4=(double)clock();
  printf("%.4fms\n", (finish4-start4));
}

#include<iostream>
#include<iomanip>
#include<time.h>
using namespace std; //随机数函数头文件
void print(int arr[], int n)
{  
    for(int j=0;j<n;j++)
	{  
      cout<<arr[j]<<'\t';  
     }  
    cout<<endl;  
}  
void quickSort(int a[], int low ,int high)
{
	if(low<high)  //判断是否满足排序条件，递归的终止条件
	{
		int i=low, j=high;   //把待排序数组元素的第一个和最后一个下标分别赋值给i,j，使用i,j进行排序；
		int x=a[low];    //将待排序数组的第一个元素作为哨兵，将数组划分为大于哨兵以及小于哨兵的两部分                                   
		while(i<j)  
		{
		  while(i<j && a[j] <= x) 
		  {
			  j--;//从最右侧元素开始，如果比哨兵小，那么它的位置就正确，然后判断前一个元素，直到不满足条件
			  //print(a,10);
		  }
		  if(i<j) 
		  {
			  a[i++] = a[j];   //把不满足位次条件的那个元素值赋值给第一个元素，（也即是哨兵元素，此时哨兵已经保存在x中，不会丢失）并把i的加1
		      print(a,10);
		  }
		  while(i<j && a[i] >= x)
		  {
			  i++; //换成左侧下标为i的元素开始与哨兵比较大小，比其大，那么它所处的位置就正确，然后判断后一个，直到不满足条件
		      //print(a,10);
		  }
		  if(i<j) 
		  {
			  a[j--] = a[i];  //把不满足位次条件的那个元素值赋值给下标为j的元素，（下标为j的元素已经保存到前面，不会丢失）并把j的加1
		      print(a,10);
		  } 
		}
	        a[i] = x; //完成一次排序，把哨兵赋值到下标为i的位置，即前面的都比它小，后面的都比它大
			print(a,10);
		quickSort(a, low ,i-1);  //递归进行哨兵前后两部分元素排序 ， low,high的值不发生变化，i处于中间
		quickSort(a, i+1 ,high);
	}
}
void main()
{
  int N;
  cout<<"请输入随机生成的整数序列的数字个数：";
  cin>>N;
  int a[100];
  srand(time(0)); //调用随机数
  for(int i=0;i<N;i++)
  {
    a[i]=1+rand()%100; //随机数的使用方法
  }
  cout<<"随机生成的数组为：\n";
  print(a,N); 
  cout<<"快速排序时数组的演化过程：\n";
  quickSort(a,0,N-1);//快速排序函数
}