java排序--交换排序--冒泡排序和快速排序

交换排序的基本思想是：交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排 序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

交换排序有冒泡排序和快速排序

冒泡排序有基础写法和优化后写法，我们先来看最基础的冒泡排序：

特性：
1丶时间复杂度：O(N^2)
2丶空间复杂度：O(1)
3丶稳定性：稳定

下面是代码实现：

public class BubbleSort {
    public static void Bubble(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 1; j <array.length-i ; j++) {
                if(array[j-1]>array[j]){
                    int temp = 0;
                    temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int [] array = {6,25,34,9,12,55,56};
        Bubble(array);
        System.out.println(Arrays.toString(array));
    }
}   

结果如下：

上面是冒泡排序最基础的写法，下面介绍一种优化后的冒泡排序：

public class BubbleSort {
    public static void Bubble(int[] array){
        for (int i = 0; i < array.length; i++) {
            boolean f = false;
            for (int j = 1; j <array.length-i ; j++) {
                if(array[j-1]>array[j]){
                    int temp = 0;
                    temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                    f = true;
                }
            }
            if(!f){
                break;
            }
        }
    }

    public static void main(String[] args) {
        int [] array = {6,25,34,9,12,55,56};
        Bubble(array);
        System.out.println(Arrays.toString(array));
    }
}

结果同上

下面介绍快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序特性：
1丶时间复杂度：O(N*logN)
2丶空间复杂度：O(logN)
3丶稳定性：不稳定

代码实现如下：

  public static int partion(int[] array,int low,int high) {
        int temp = array[low];
        while (low < high) {
            while ((low < high) && array[high] >= temp) {
                high--;
            }
            if (high >= low) {
                break;
            } else {
                array[low] = array[high];
            }
        }
        while (low < high) {
            while ((low < high) && array[low] <= temp) {
                low++;
            }
            if (low >= high) {
                break;
            } else {
                array[high] = array[low];
            }

        }
        array[low] = temp;
        return low;
    }

    public static void insertSort(int[] array,int start,int end) {
                int temp = 0;
                for (int i = start + 1; i <= end; i++) {
                    temp = array[i];
                    int j = 0;
                    for ( j = i - 1; j >= start; j--) {
                        if (array[j] > temp) {
                            array[j + 1] = array[j];
                        } else {
                            break;
                        }
                    }
                    array[j+1] = temp;
                 }
    }

    public static void quick(int[] array,int start,int end){

        if(end-start+1 <= 16){
            insertSort(array,start,end);
            return;
        }

        int par = partion(array,start,end);
        //找左边是否有两个数据以上
        if(par > start+1){
            quick(array,start,par-1);
        }
        //右边是否有两个数据以上
        if(par < end-1){
            quick(array,par+1,end);
        }

    }
    //快速排序
    public static void quickSort(int[] array){
                quick(array,0,array.length-1);
            }

结果如下：

以上就是冒泡排序及其优化和快速排序。