Java 排序（快排，归并）

Java 排序有Java.util.Arrays的sort方法，具体查看JDK API（一般都是用快排实现的，有的是用归并）

 package yxy;

 import java.util.Arrays;

 public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         int[] arrs = { 1,0,5,9 };
         Arrays.sort(arrs);
         for (int a : arrs) {
             System.out.print(a+"\t");
         }
     }
 }

运行结果：

0    1    5    9    

但是如果我是想让从大到小排序呢，（可以逆序输出吧，一边儿呆着去，我是想让数组自己就从大到小排序）（http://luoqidunwu.iteye.com/blog/1571687）

 package yxy;

 import java.util.Arrays;
 import java.util.Comparator;

 class DownCompare implements Comparator<Integer> {

     @Override
     public int compare(Integer o1, Integer o2) {
         // TODO Auto-generated method stub
         // return o1==02?0:(o1<o2?1:-1);
         if (o1.intValue() < o2) {
             return 1;
         } else if (o1 == o2) {
             return 0;
         } else {
             return -1;
         }
     }

 }

 public class Test {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Integer[] arrs = { 1, 0, 5, 9 };
         Arrays.sort(arrs, new DownCompare());
         for (int a : arrs) {
             System.out.print(a + "\t");
         }
     }
 }

运行结果：

9    5    1    0    

其实是这个方法，需要写一个类继承Comparator接口

sort(T[] a, Comparator<? super T> c)
          根据指定比较器产生的顺序对指定对象数组进行排序。

如果说自己写快排呢

先说点儿快排稳定性的吧，快排是不稳定的，比如说 5 8(a) 8(b)  1（a） 1(b) 选5作为枢纽元素，排序后1((b)  1(a) 5 8(b)  8(a)

 //参考：http://www.algolist.net/Algorithms/Sorting/Quicksort
 package yxy;

 class QuickSort {
     int partition(int arr[], int left, int right) {
         int i = left, j = right;
         int tmp;
         int pivot = arr[(left + right) / 2]; // 选择中间元素作为枢元
         //若改为int pivot = left; ：则 java.lang.StackOverflowError

         while (i < j) {                         //若改为i<=j: 则java.lang.StackOverflowError
             while (arr[i] < pivot)
                 i++;
             while (arr[j] > pivot)
                 j--;
             if (i <= j) {                     //若改为 i<j :则java.lang.StackOverflowError
                 tmp = arr[i];
                 arr[i] = arr[j];
                 arr[j] = tmp;
                 i++;
                 j--;
             }
         }
         return i;
     }

     void quickSort(int arr[], int left, int right) {
         if (arr == null || arr.length <= 1)
             return;
         int index = partition(arr, left, right);
         if (left < index)
             quickSort(arr, left, index - 1);
         if (index < right)
             quickSort(arr, index, right);
     }
 }

 public class Test2 {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         int[] arr = { 1, 0, 5, 9 };
         new QuickSort().quickSort(arr, 0, arr.length - 1);
         for (int a : arr) {
             System.out.print(a + "\t");
         }
     }

 }

对快排不熟悉，为什么改变代码会出现java.lang.StackOverflowError不清楚

明哥给我说的方法，很好理解（下面估计说不清，画个图看看就容易理解了），枢纽元素选择最后一个，然后2个下标指针i,s都指向开始，s的作用是指向i扫描过的第一个比枢纽元素大的位置，i扫描到比枢纽元素小的就和s位置的换，i位置比枢纽元素大的就直接i++

 package yxy;

 class QuickSort {

     void quickSort(int arr[], int left, int right) {
         if (arr == null || arr.length <= 1 || left > right) {
             return;
         }
         int i = left, s = left, p = right, tmp; // p指向枢元的位置，i一直往下走，当遇到比arr[p]小的元素时和arr[s]交换
         while (i < p) {
             if (arr[i] < arr[p]) {
                 tmp = arr[i]; // 这三句，如果刚开始的元素都小于枢纽元素，则都是自己和自己交换，影响效率，可以判断i和s是否相等，相等就不交换了
                 arr[i] = arr[s];
                 arr[s] = tmp;
                 i++;
                 s++;
             } else {
                 i++;
             }
         }
         tmp = arr[s];
         arr[s] = arr[p];
         arr[p] = tmp;
         quickSort(arr, left, s - 1);
         quickSort(arr, s + 1, right);
     }
 }

 public class Test2 {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         int[] arr = { 1, 0, 5, 9 };
         new QuickSort().quickSort(arr, 0, arr.length - 1);
         for (int a : arr) {
             System.out.print(a + "\t");
         }
     }

 }

12、13、14和21、22、23这么写太麻烦了，写个函数吧

     void swap(int a,int b){
         int tmp;
         tmp=a;
         b=a;
         a=tmp;
     }

哇，不行哇，哦，java传递参数的问题，记起刚学C时经常碰到这个问题了吧

     void swap(Integer a,Integer b){
         Integer tmp;
         tmp=a;
         b=a;
         a=tmp;
     }

这个也不行

详情参考：http://bbs.csdn.net/topics/390245117   28楼

归并排序