排序

1 冒泡排序

冒泡排序算法的运作如下:   分为降序和升序排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

升序排序

排序前数组顺序：67    69    100    87    89    90    75    46   
第1次排序结果：67    69    87    89    90    75    46    100   
第2次排序结果：67    69    87    89    75    46    90    100   
第3次排序结果：67    69    87    75    46    89    90    100   
第4次排序结果：67    69    75    46    87    89    90    100   
第5次排序结果：67    69    46    75    87    89    90    100   
第6次排序结果：67    46    69    75    87    89    90    100   
第7次排序结果：46    67    69    75    87    89    90    100   
最终排序结果：46    67    69    75    87    89    90    100

降序排序

排序前数组顺序：67    69    100    87    89    90    75    46   
第1次排序结果：69    100    87    89    90    75    67    46   
第2次排序结果：100    87    89    90    75    69    67    46   
第3次排序结果：100    89    90    87    75    69    67    46   
第4次排序结果：100    90    89    87    75    69    67    46   
第5次排序结果：100    90    89    87    75    69    67    46   
第6次排序结果：100    90    89    87    75    69    67    46   
第7次排序结果：100    90    89    87    75    69    67    46   
最终排序结果：100    90    89    87    75    69    67    46   

算法如下

public class BubbleSort{
     public static void main(String[] args){
          int score[] = {67, 69, 100, 87, 89, 90, 75, 46};

           for (int i = 0; i < score.length -1; i++){    //最多做n-1趟排序
             for(int j = 0 ;j < score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                 if(score[j] < score[j + 1]){    注意核心在这 如果升序那么就 是>

                     int temp = score[j];
                     score[j] = score[j + 1];
                     score[j + 1] = temp;
                 }
             }            
             System.out.print("第" + (i + 1) + "次排序结果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "	");
             }
             System.out.println("");
         }
             System.out.print("最终排序结果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "	");
        }
     }
 }

2 选择排序

   升序

排序前数组顺序：67    69    100    87    89    90    75    46   
第1次排序结果：46    69    100    87    89    90    75    67   
第2次排序结果：46    67    100    87    89    90    75    69   
第3次排序结果：46    67    69    100    89    90    87    75   
第4次排序结果：46    67    69    75    100    90    89    87   
第5次排序结果：46    67    69    75    87    100    90    89   
第6次排序结果：46    67    69    75    87    89    100    90   
第7次排序结果：46    67    69    75    87    89    90    100   
第8次排序结果：46    67    69    75    87    89    90    100   
最终排序结果：46    67    69    75    87    89    90    100   

public class BubbleSort{
     public static void main(String[] args){
         int score[] = {67, 69, 100, 87, 89, 90, 75, 46};
         System.out.print("排序前数组顺序：");
         for(int a = 0; a < score.length; a++){
             System.out.print(score[a] + "	");
         }
         System.out.println("");
         for (int i = 0; i < score.length; i++){    //最多做n-1趟排序
             for(int j = i+1 ;j < score.length; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                 if(score[i] > score[j]){  
                     int temp = score[i];
                     score[i] = score[j];
                     score[j] = temp;
                 }
             }            
             System.out.print("第" + (i + 1) + "次排序结果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "	");
             }
             System.out.println("");
         }
             System.out.print("最终排序结果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "	");
        }
     }
 }

3 快速排序

一趟快速排序的算法是：

1. 设置两个变量start、end，排序开始的时候：start=1，end=N；
2. 以第一个数组元素作为关键数据，赋值给pivot，即 pivot=arry[1]；
3. 从end开始向前搜索，即由后开始向前搜索（end--），找到第一个小于pivot的值arry[end]，并与arry[start]交换,即swat(arry,start,end)；
4. 从start开始向后搜索，即由前开始向后搜索（start++），找到第一个大于pivot的arry[start]，与arry[end]交换,即swat(arry,start,end);
5. 重复第3、4步，直到 start==end，这个时候arry[start]=arry[end]=pivot，而pivot的位置就是其在整个数组中正确的位置；
6. 通过递归，将问题规模不断分解。将pivot两边分成两个数组继续求新的pivot，最后解出问题。

public class QuickSort {
    //打印数组
    public static void print(int arry[])
    {
       for(int i:arry)
        {
            System.out.print(i+" ");
        }
           System.out.println();
    }

    //partition返回某一个index，在index左边的元素都比index所在元素值小，右边的都比index所在元素值大
    public static int partition(int []arry,int start,int end)
    {
        int pivot=arry[start];//将首元素最为pivot
        while(start<end)
        {
            //找到第一个大于pivot的arry[end]
            while(pivot<arry[end]&&start<end)
                end--;
            arry[start]=arry[end];
            
            //找到第一个小于pivot的arry[start]
            while(pivot>arry[start]&&start<end)
                start++;
            arry[end]=arry[start];
        }
        //最后start==end以后的位置就是起始pivot存放的位置
        arry[start]=pivot;
        //返回pivot的位置，后面按次位置分解
        return start;
    }
    
    public static void quickSort(int []arry,int start,int end)
    {
        //判断start与end的位置
        if(start>=end)
            return;
        int pivot=partition(arry,start,end);
        quickSort(arry,start,pivot-1);
        quickSort(arry,pivot+1,end);
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arry[]={5,6,2,7,1};
        int len=arry.length;

        System.out.print("快速排序前数组元素为：");
        print(arry);
      
        quickSort(arry,0,len-1);
        
        System.out.print("快速排序后数组元素为：");
        print(arry);
    }
}