【java基础总结】02.排序

IDE（Integrated Development Environment），集成开发环境。

1.数组（Arrays）：数组元素存放的数据若是原生数据类型，则是数据本身，若是对象的引用，即引用指向对象。

 

面试当中会问到的问题：冒泡排序，交换排序，快速排序  二分查找（待查找的数据必须有序）

 

冒泡排序和快速拍戏都属于交换排序

1.冒泡:

public static void bubbleSort(int[] array) {                   
        for(int i = 0; i < array.length - 1; i++){
            for(int j = 0; j < array.length - i - 1; j++) {
                if(array[j] > array[j + 1]){             //可以添加一个boolean型的变量记录，若为true，则执行交换，若为false，则跳过不执行
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }

 

public static void bubbleSort(int[] array) {                   
        for(int i = 0; i < array.length - 1; i++){
            for(int j = 0; j < array.length - i - 1; j++) {
                if(array[j] > array[j + 1]){             //可以添加一个boolean型的变量记录，若为true，则执行交换，若为false，则跳过不执行
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
       }
}
public static void bubbleSort(int[] array) {                   
        for(int i = 0; i < array.length - 1; i++){
            for(int j = ; j < array.length; j++) {
                if(array[i] > array[j]){         
                    int temp = array[j];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
       }
}

2.快速排序：原理如下

static int partition(int[] unsorted, int low, int high)
        {
            int pivot = unsorted[low];
            while (low < high)
            {
                while (low < high && unsorted[high] > pivot) high--;
                unsorted[low] = unsorted[high];
                while (low < high && unsorted[low] <= pivot) low++;
                unsorted[high] = unsorted[low];
            }
            unsorted[low] = pivot;
            return low;
        }

        static void quick_sort(int[] unsorted, int low, int high)
        {
            int loc = 0;
            if (low < high)
            {
                loc = partition(unsorted, low, high);
                quick_sort(unsorted, low, loc - 1);
                quick_sort(unsorted, loc + 1, high);
            }
        }

3.二分查找：

带查找的数据有序，然后进行查找

查找方式为：查找中间元素与待查找的值比对，若小于，则从左侧中去中间值在比对。

public static int binarySearch(int[] array,int value){
    int low = 0;
    int high = array.length;
    int middle;
    while(low<=high){
       middle = (low + high)/2;
       if(array[middle] == value){
          return middle;
       }
       if(array[middle] > value){
          high = middle - 1;
       }
       if(array[middle] < value){
          high = middle + 1;
       }
    }
    return -1;
}

 

参考：更多排序 http://www.cnblogs.com/kkun/archive/2011/11/23/2260312.html