求助： 快速排序中递归问题

也不行

纯小白一枚， 求解答。

啊哈磊的源码在下面，就是弄不懂 函数里的两个递归就如何步步执行的，执行时函数的参数又是如何变化的。

quicksort(left,i-1)； 第一次是quicksort(1,5)，当执行完了是下一步是执行quicksort(1,2)？
什么时候会执行到 quicksort(i+1,right)；这两个递归有是如何交替执行的？

#include <stdio.h>
int a[101],n;//定义全局变量，这两个变量需要在子函数中使用

void quicksort(int left,int right)
{
    int i,j,t,temp;
    if(left>right)
       return;
      
    temp=a[left]; //temp中存的就是基准数
    i=left;
    j=right;
    while(i!=j)
    {
                   //顺序很重要，要先从右边开始找
                   while(a[j]>=temp && i<j)
                            j--;
                   //再找右边的
                   while(a<=temp && i<j)
                            i++;

                   //交换两个数在数组中的位置
                   if(i<j)
                   {
                            t=a;
                            a=a[j];
                            a[j]=t;
                   }
    }
    //最终将基准数归位
    a[left]=a;
    a=temp;
   
    quicksort(left,i-1);//继续处理左边的，这里是一个递归的过程
    quicksort(i+1,right);//继续处理右边的 ，这里是一个递归的过程
}

int main()
{
    int i,j,t;
    //读入数据
    scanf("%d",&n);
    for(i=1;i<=n;i++)
                   scanf("%d",&a);

    quicksort(1,n); //快速排序调用
   
    //输出排序后的结果
    for(i=1;i<=n;i++)
        printf("%d ",a);

    getchar();getchar();
    return 0;
}

帅小子

你这个代码好像抄错了吧，我编译了一下，发现是错的。
我去到了啊哈磊的博客下面找到了正确的代码，如下：

1. #include <stdio.h>
   
2. int a[101],n;//定义全局变量，这两个变量需要在子函数中使用
   
3. void quicksort(int left,int right)
   
4. {
   
5.     int i,j,t,temp;
   
6.     if(left>right)
   
7.        return;
   
8.                                    
   
9.     temp=a[left]; //temp中存的就是基准数
   
10.     i=left;
    
11.     j=right;
    
12.     while(i!=j)
    
13.     {
    
14.                    //顺序很重要，要先从右边开始找
    
15.                    while(a[j]>=temp && i<j)
    
16.                             j--;
    
17.                    //再找右边的
    
18.                    while(a[i]<=temp && i<j)
    
19.                             i++;
    
20.                    //交换两个数在数组中的位置
    
21.                    if(i<j)
    
22.                    {
    
23.                             t=a[i];
    
24.                             a[i]=a[j];
    
25.                             a[j]=t;
    
26.                    }
    
27.     }
    
28.     //最终将基准数归位
    
29.     a[left]=a[i];
    
30.     a[i]=temp;
    
31.                                 
    
32.     quicksort(left,i-1);//继续处理左边的，这里是一个递归的过程
    
33.     quicksort(i+1,right);//继续处理右边的 ，这里是一个递归的过程
    
34. }
    
35. int main()
    
36. {
    
37.     int i,j,t;
    
38.     //读入数据
    
39.     scanf("%d",&n);
    
40.     for(i=1;i<=n;i++)
    
41.                    scanf("%d",&a[i]);
    
42.     quicksort(1,n); //快速排序调用
    
43.                                 
    
44.     //输出排序后的结果
    
45.     for(i=1;i<=n;i++)
    
46.         printf("%d ",a[i]);
    
47.     getchar();getchar();
    
48.     return 0;
    
49. }

复制代码

我画一个图给你演示一下。箭头表示的是方向，红色数字表示的是顺序。
还有，我把这个代码改了一下，输出了某些中间结果，用不同的数据去测试一下我的这个代码吧，或许可以帮助你的理解。

1. #include <stdio.h>
   
2. int a[101],n;
   
3. 
   
4. int cnt=0;//这个cnt就是帮助你理解第几次调用函数或者什么的
   
5. 
   
6. void quicksort(int left,int right)
   
7. {
   
8.     int i,j,t,temp;
   
9.    
   
10.     printf("left:%d right:%d cnt:%d\n",left,right,cnt);cnt++;//注意这里
    
11.    
    
12.     if(left>right)
    
13.        return;
    
14.                                    
    
15.     temp=a[left];
    
16.     i=left;
    
17.     j=right;
    
18.     while(i!=j)
    
19.     {
    
20. 
    
21.                    while(a[j]>=temp && i<j)
    
22.                             j--;
    
23. 
    
24.                    while(a[i]<=temp && i<j)
    
25.                             i++;
    
26. 
    
27.                    if(i<j)
    
28.                    {
    
29.                             t=a[i];
    
30.                             a[i]=a[j];
    
31.                             a[j]=t;
    
32.                    }
    
33.     }
    
34. 
    
35.     a[left]=a[i];
    
36.     a[i]=temp;
    
37. 
    
38.     quicksort(left,i-1);
    
39.    
    
40.     printf("left:%d right:%d cnt:%d\n",left,right,cnt);cnt++;//注意这里
    
41.    
    
42.     quicksort(i+1,right);
    
43.    
    
44.     printf("left:%d right:%d cnt:%d\n",left,right,cnt);cnt++;//注意这里
    
45. }
    
46. int main()
    
47. {
    
48.     int i,j,t;
    
49. 
    
50.     scanf("%d",&n);
    
51.     for(i=1;i<=n;i++)
    
52.                    scanf("%d",&a[i]);
    
53.     quicksort(1,n);
    
54.                                 
    
55. 
    
56.     for(i=1;i<=n;i++)
    
57.         printf("%d ",a[i]);
    
58.     getchar();getchar();
    
59.     return 0;
    
60. }

复制代码