容器的排序-1

排序规则

排序的规则主要应用在两个大类型上面，一个是基本数据类型（按照日常的大小排序），另外一个就是引用数据类型（包括内置类和自定义的类）。
对于引用数据类型：
内置类：内部已经自定义了规则，直接可以使用。如Integer、String等类型都是继承了Comparable接口的，都重写了ComparaTo方法。观其源码如下：

  //Integer的排序源码
  public int compareTo(Integer anotherInteger) {
      return compare(this.value, anotherInteger.value);
  }


  public static int compare(int x, int y) {
      return (x < y) ? -1 : ((x == y) ? 0 : 1);
  }

  //String类型的排序源码
  public int compareTo(String anotherString) {
      int len1 = value.length;
      int len2 = anotherString.value.length;
      int lim = Math.min(len1, len2);
      char v1[] = value;
      char v2[] = anotherString.value;

      int k = 0;
      while (k < lim) {
          char c1 = v1[k];
          char c2 = v2[k];
          if (c1 != c2) {
              return c1 - c2; //先从前至后比较单个字母的Unicode码
          }
          k++;
      }
      return len1 - len2; //如果字母一样的话就比较长度
  }

冒泡排序

• 冒泡排序：基本思想是比较相邻元素值，如果满足条件就交换元素值。
• 直接选择排序：排序速度比冒泡速度快一些，基本思想是将制定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与制定的排序位置交换。

import java.util.Arrays;


public class testorder {
    public static void main(String[] args) {
        int[] arr = new int[]{64,2,3,55,44,23,1};
//      Arrays.sort(arr);
        testorder a = new testorder();
//      a.sort1(arr);
        a.showit(arr);
        System.out.println();
        System.out.println("******************");
        a.reverseSort(arr);
        int index = Arrays.binarySearch(arr,2);
        System.out.println();
        System.out.println("检索该数在数组中位置为："+index);

    }

    //冒泡排序方法
    public static void sort(int arr[]){
        int temp = 0;
        //最终版
        boolean sorted = true;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    sorted = false;
                }
            }
            if(sorted){
                break;
            }
        }
        showit(arr);
    }


    // 直接排序法，相对运行时间比冒泡排序的时间要短,每一趟从排序的数据元素中选出最小
    // 或者最大的一个元素，顺序的放在已经排好的序列的而最后，直到数据元素排序完毕
    public void sort1(int arr[]){
        for(int i = 1;i<arr.length;i++){
            int index = 0;
            for(int j = 1;j<=arr.length-i;j++){
                if(arr[j]>arr[index]){
                    index = j;
                }
            }
            int temp = arr[arr.length-i];
            arr[arr.length-i] = arr[index];
            arr[index] = temp;
        }
        showit(arr);
    }

    //测试数组的反转排序
    public void reverseSort(int arr[]){
        int j = arr.length;
        for(int i = 0;i<arr.length/2;i++){
            int temp = arr[i];
            arr[i] = arr[j-i-1];
            arr[j-i-1] = temp;
        }
        showit(arr);
    }

    //利用foreach逐步打印要打印的数组
    public void showit(int arr[]){
        for(int i:arr){
            System.out.print(i+"\t");
        }
    }   
}