Java、C语言实现快速排序算法

代码：

Java：

public static void quicksort(int[] input, int left, int right) {
    if(left >= right) return;
    int pivot = input[left];
    int L = left;
    int R = right;
    while(left < right){
        while(input[right] >= pivot && left < right){
            right--;
        }
        while(input[left] <= pivot && left < right){
            left++;
        }
        if(left < right){
            int mid1 = input[left];
            input[left] = input[right];
            input[right] = mid1;
        }
    }
    input[L] = input[left];
    input[left] = pivot;
    quicksort(input,L,left-1);
    quicksort(input,left+1,R);
}

C语言:

#include <stdio.h>

#include <stdlib.h>
int   findpivot();
int   partion ();
void  quicksort ();
int main()
{
    int n,i;
    printf("请输入需要排序的元素的个数：");
    scanf("%d",&n);
    int a[n];
    for(i = 0;i < n;i++){
        printf("请输入第%d个元素:",i+1);
        scanf("%d",&a[i]);                                        //将全部元素储存到数组中
    }
    quicksort(0,n-1,a);                                          //快速排序算法
    printf("由小到大排序后的结果是：\n");
    for(i=0; i<n; i++)
    {
        printf("%d ",a[i]);                                          //输出
    }
    printf("\n");
    return 0;

}

void   quicksort (int i,int j,int A[])                      //快速排序算法
{
    int  pivot ;
    int  p,k;
    p = findpivot(i,j,A);                                          //中间元素在数组中的序号
    if (p!=-1)
    {
        pivot = A[p];                                                //中间元素
        k = partion ( i, j, pivot,A) ;                         //快速排序，并返回左游标
        quicksort( i, k-1,A);                                   //递归调用快速排序算法，对返回的左游标的左侧进行快速排序
        quicksort( k, j,A);                                       //递归调用快速排序算法，对返回的左游标的右侧进行快速排序     
    }
}

int   findpivot(int i,int j,int A[])                            //寻找中间元素
{
    int  firstkey ;
    int  k;
    firstkey = A[i];
    for ( k=i ;  k<=j; k++ ){
        if ( A[k]> firstkey )
            return k ;                                              //返回两个不同的元素中的较大值（从左侧开始寻找）
        else  if ( A[k]<firstkey )
            return  i ;
    }
    return  -1;                                                    // 如果找不到中间元素则返回-1
}

int  partion (int i,int j,int pivot,int A[])                //对数组进行分割
{
    int L, R,t;
    L = i ;
    R = j ;
    do
    {
        t = A[L];                                                   //交换元素
        A[L] = A[R];
        A[R] = t;
        while ( A[L]< pivot ){                               //如果左游标指向的元素小于中间元素
            L = L +1 ;                                            //左游标右移
        }                                                              //直到左游标指向的元素大于中间元素
        while ( A[R]>= pivot ){                            //如果右游标指向的元素大于等于中间元素
            R = R -1 ;                                           //右游标左移
        }                                                             //直到右游标指向的元素小于中间元素
    }while ( L <= R );                                       //左游标大于右游标结束循环
    return L ;                                                    //返回左游标

}

算法要点：

（1）中间值v 的选择，其位置确定在A[k]

   设findpivot(i,j), 求A[i].key,…,A[j].key的中间值v

   v=( A[i].key，A[(i+j)/2].key,  A[j].key的中值)

   v=从A[i].key到 A[j].key最先找到的两个不同关键字中的最大的

（2）A[i].key,…,A[j].key分割成A[i],…,A[k-1]和A[k+1],…,A[j]两部分。

   扫描：令游标 L从左（L=i）向右扫描，越过key小于v的记录，直到A[L].key ≥v为止；

   同时令游标R从右（R=j）开始向左扫描，越过key大于等于v的记录,直到A[R].key＜v的记录A[R]为止；

   测试：若L>R（L=R+1），成功划分，L是右边子序列的起始下表；

   交换：若L<R,则swap( A[L], A[R] )

   重复上述操作，直至过程进行到L>R（L=R+1）为止