排序的几种方法（合并，快速，冒泡排序）

合并排序：

合并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 　合并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。 　将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。合并排序也叫归并排序。

程序如下：

//合并排序，将数组从中间分开来，递归向下排序，然后再合并起来
public class HeBingPaiXu {
    private static int[] a={5,2,6,1,7,3,4};

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MergeSort(0,6);
        for(int i=0;i<7;i++)
        {
            System.out.print(a[i]+" ");
        }
    }
    
    //排序函数
    public static void MergeSort(int start,int end)
    {
        if(start>=end)
        {
            return;
        }
        int middle=(start+end)/2;
        MergeSort(start,middle);
        MergeSort(middle+1,end);
        Merge(start,middle,end);
    }
    
    //合并函数
    public static void Merge(int start,int middle,int end)
    {
        int i=start,j=middle+1,k=0;
        int[] b=new int[end-start+1];
        while((i<=middle)&&(j<=end))
        {
            if(a[i]<a[j]) b[k++]=a[i++];
            else
                b[k++]=a[j++];
        }
        
        if(i>middle)
        {
            for(int q=j;q<=end;q++)
                b[k++]=a[q];
        }
        else
        {
            for(int q=i;q<=middle;q++)
                b[k++]=a[q];
        }
        
        int m=0,n=0;
        for( m=start,n=0;m<=end;m++,n++)
        {
            a[m]=b[n];
        }
            
    }

}

快速排序：

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，以一个元素为基准，其中一部分的所有数据都这个数小，另外一部分的所有数据都要大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

程序如下：

//快速排序
public class KuaiSuPaiXu {

    private static int[] a={5,2,6,1,7,3,4};
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        QuickSort(0,6);
        for(int i=0;i<7;i++)
        {
            System.out.print(a[i]+" ");
        }
    }
    
    public static void QuickSort(int start,int end)
    {
        if(start>=end)
            return;
        //两个区域的划分
        int temp=a[start];//以开始位置的元素作为基准
        int i=start,j=end+1;
        while(true)
        {
            while(a[++i]<temp&&i<end);
            while(a[--j]>temp);
            if(i>=j) break;
            else
            {
                int t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
        }
        //将基准元素放到合适位置
        a[start]=a[j];
        a[j]=temp;
        //划分过的区域再排序
        QuickSort(start,j-1);
        QuickSort(j+1,end);
    }

}

冒泡排序：

冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

程序如下：

//冒泡排序
public class MaoPaoPaiXu {
    
    private static int[] a={5,2,6,1,7,3,4};
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //i控制的是冒泡的次数，第一次 将数组中最大的数放到数组最后
        //第二次 将数组中次大的数放到数组最后，依次类推
        for(int i=0;i<=5;i++)
        {
            boolean flag=true;
            for(int j=0;j<=6-i-1;j++)
            {
                if(a[j]>a[j+1])
                {
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    flag=false;
                }
            }
            //如果排序的过程中，如果在一次循环过程中，没有交换的话，就说明排序已经完成，直接
            //退出即可
            if(flag)
                break;
        }
            
        
        for(int i=0;i<7;i++)
        {
            System.out.print(a[i]+" ");
        }
    }

}