数组合并排序和快速排序

学习C语言的都知道很多时候我们都需要对数组进行排序，之前给大家分享了选择排序和冒泡排序，现在给大家分享一个比较难一点数组合并排序和快速排序。同样分析其相应的时间复杂度和空间复杂度。如果分析错了，还望指点一二。现在辅助合并排序的程序。

合并排序程序方法一：
#include <stdio.h>
void merge(int r[], int s[], int x1, int x2, int x3) /*实现一次归并排序函数*/
{
    int i, j, k;
    i = x1; 	/*第一部分的开始位置*/
    j = x2 + 1; /*第二部分的开始位置*/
    k = x1;
    while ((i <= x2) && (j <= x3))
     		/*当i和j都在两个要合并的部分中*/
        if (r[i] <= r[j])
     /*筛选两部分中较小的元素放到数组s中*/
    {
        s[k] = r[i];
        i++;
        k++;
    }
    else
    {
        s[k] = r[j];
        j++;
        k++;
    }
    while (i <= x2)
  			/*将x1~x2范围内的未比较的数顺次加到数组r中*/
        s[k++] = r[i++];
    while (j <= x3)
    		/*将x2+1~x3范围内的未比较的数顺次加到数组r中*/
        s[k++] = r[j++];
}
void merge_sort(int r[], int s[], int m, int n)
{
    int p;
    int t[20];
    if (m == n)
        s[m] = r[m];
    else
    {
        p = (m + n) / 2;
        merge_sort(r, t, m, p);
    	/*递归调用merge_sort函数将r[m]~r[p]归并成有序的t[m]~t[p]*/
        merge_sort(r, t, p + 1, n);	
		/*递归调用merge_sort函数将r[p +1]~r[n]归并成有序的t[p+1]~t[n]*/
        merge(t, s, m, p, n); /*调用函数将前两部分归并到s[m]~s[n]*/
    }
    }
main()
{
    int a[11];
    int i;
    printf("please input 10 numbers:\n");
    for (i = 1; i <= 10; i++)
        scanf("%d", &a[i]);
  merge_sort(a, a, 1, 10);					 /*调用merge_sort函数进行归并排序*/
    printf("the sorted numbers:\n");
    for (i = 1; i <= 10; i++)
        printf("%5d", a[i]);
   }
 
合并排序程序方法二：
#include<stdio.h>
   void main()
   { 
	   int a[3]={1,3,5},b[5]={2,4,6,8,10},c[8];
       int i=0,j=0,k,m,l=0;
while(i<3&&j<5)
{

    if (a[i]<b[j])
{
          c[l]=a[i];
              i++;
               l++;
}
else
{
        c[l]=b[j];
         j++;
              l++;
}
if(i>2)
{
       for(m=l;m<8&&j<5;m++,j++)
            c[m]=b[j];
}
}
          for(k=0;k<8;k++)
           printf("%d ",c[k]);
}

第一个程序运行结果：

第二个程序运行结果：

对于合并排序，先对所要进行排序的序列进行分解，直到分为单个元素为止，然后将其进行两两合并。由于最终分解成单个元素，因此在合并的时候.将小数放在前面，大数放在后面，得到一个有序序列。接下来对两个相连的有序序列进行排序，先比较有序序列中的第一个元素，将较小的元素放入临时数组中，接着将较小元素所在数组的下一个元素与另一个数组中的较小元素，比较依次相比。合并排序在最坏的情况下的键值比较次数一般为O（nlogn），当n很大时，平均情况下，和平排序算法的比较次数要小于0.25n次，空间复杂度为O（n）。

对于快速排序算法，主要是先要选择一个中轴，接下来会根据该元素的值来划分子数组。选择中轴有许多不同的策略，主要是针对程序的要求。之后我们讲分别从子数组的两端进行扫描，并且将扫描的元素与中轴比较。小于中轴的元素位于子数组的左半部分，直到遇到第一个小于等于中轴的元素才会停止。依次这样排出数组元素的大小输出。程序如下：

快速排序程序方法一：
#include <stdio.h>
#include<iostream.h>
void main()
{
    int i, j, t, a[11];					/*定义变量及数组为基本整型*/
    printf("please input 10 numbers:\n");
    for (i = 1; i < 11; i++)
        scanf("%d", &a[i]);				
    for (i = 1; i <= 9; i++)
        for (j = i + 1; j <= 10; j++)
            if (a[i] > a[j])				/*如果后一个数比前一个数大则利用中间变量t实现俩值互换*/
    {
        t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    printf("the sorted numbers:\n");
    for (i = 1; i <= 10; i++)
        printf("%5d", a[i]);			
	 printf("\n");
}

快速排序程序方法二：
#include<stdio.h>
#include<stdlib.h>
int a[100];
void f(int i, int j)
{
int t,l=i,h=j,m;    //设置两个变量i、i,排序开始的时候i=1,j=n
   m=a[(i+j)/2];     //以最中间的数组元素作为关键数据，赋值给m
  while (i<=j)
    {
      while (a[i]<m) i=i+1;     //从j开始向前搜索，即由后开始向前搜索（j=j-1），找到第一个小于m的值，两者交换
      while (a[j]>m) j=j-1;       //从i开始向后搜索，即由前开始向后搜索（i=i+1），找到第一个大于m的值，两者交换； 
      if (i<=j) 
       { t=a[i]; a[i]=a[j]; a[j]=t; i=i+1; j=j-1;}  //一直重复，直到跳出循环体 
    }
  if(i<h) f(i,h);
  if(l<j) f(l,j);
}

void main()
{
  int n,i;
  printf("请输入排序的个数：  ");
  scanf("%d", &n);
  for (i=1;i<=n;i=i+1)
  scanf("%d", &a[i]);
  f(1,n);
  for (i=1; i<=n; i=i+1)
  printf("%d ",a[i]);
  printf("\n"); 
}

快速排序第一个程序结果：

第二个结果：

对于快速排序算法，主要是先要选择一个中轴，接下来会根据该元素的值来划分子数组。选择中轴有许多不同的策略，主要是针对程序的要求。之后我们讲分别从子数组的两端进行扫描，并且将扫描的元素与中轴比较。小于中轴的元素位于子数组的左半部分，直到遇到第一个小于等于中轴的元素才会停止。依次这样排出数组元素的大小输出。因此，快速排序的时间复杂度为O（n）,空间复杂度为O（1）。合并排序和快速排序相比，感觉合并不太好理解，但是不怕，多做几次慢慢就熟悉了。上面这两种排序方法我都采用了两种程序实现，其实核心思想是没有变的。都是按照其思想原谅的。