java 实现交换排序（冒泡和快速排序）

java 实现交换排序

1、实现冒泡排序
2、实现快速排序

代码实现

/**
 * 交换排序
 * 1、冒泡排序
 * 2、快速排序
 */
public class ExchangeSort {

    /**
     * 冒泡排序
     * 数组内相邻两个数据进行比较，小的在上，大的在下
     * 每循环一趟就将最大的排在下面
     * @param array 要排序排序的数组
     * @return 排好序的数组
     */
    public int[] bubbleSort_1(int[] array){
        int temp;
        for(int i = 0;i < array.length - 1;i ++){ // 控制循环次数，即循环多少次可以排完序
            for(int j = 0;j < array.length - 1 - i;j ++){
                if(array[j] > array[j + 1]){
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }

    /**
     * 可以改进一下冒泡排序
     * @param array 要排序排序的数组
     * @return 排好序的数组
     */
    public int[] bubbleSort(int[] array){
        int temp;
        boolean flag = false; // 排序结束标志
        for(int i = 0;i < array.length - 1;i ++){ // 控制循环次数，即循环多少次可以排完序
            for(int j = 0;j < array.length - 1 - i;j ++){
                if(array[j] > array[j + 1]){
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    flag = true;
                }
            }
            if(!flag) // 当一趟没有数据交换时,说明排序完成
                break;
            else
                flag = false; // 当发生数据交换时再重置
        }
        return array;
    }

    /**
     * 快速排序
     * @param array 要排序的数组
     * @return 排好序的数组
     */
    public int[] quickSort(int[] array){
        // 调用递归排序方法
        qSort(array, 0, array.length - 1);
        return array;
    }

    /**
     * 递归排序方法
     * @param array 要排序的数组
     * @param low 数组的起始位置
     * @param high 数组结束位置
     */
    private void qSort(int[] array,int low,int high){
        if(low >= high) // 递归结束条件，判断数组长度
            return;
        else{
            int old_low = low; // 要排的数组的开始位置
            int old_high = high; // 要排的数组的结束位置
            // 数组中的数据要跟key代表的数据进行比较，比key大的排在key的右边，比key小的排在左边
            int key = array[low];
            // 判断条件，进行交换数据
            while(low < high){
                // 现在要找比key大的还是小的，即从high找还是从low找
                if(key == array[low]){ // 从high位置向左去找比key小的
                    while(array[high] > key && low < high){
                        high --;
                    }
                    if(low < high){
                        array[low] = array[high];
                        array[high] = key;
                        low ++;
                    }
                }
                else{ // 从low向右方向找比key大的
                    while(array[low] < key && low < high){
                        low ++;
                    }
                    if(low < high){
                        array[high] = array[low];
                        array[low] = key;
                        high --;
                    }
                }
            }
            // 这时比key大的排在key的右边，比key小的排在左边；
            // 这时low == high，且low和high都代表key的所在位置

            // 排key左边数据
            if(low - 1 > 0)
                qSort(array, old_low, low -1); // 要排序的数据：从数组的old_low位置开始到key前面一个数据的位置结束
            // 排key右边数据
            if(low + 1 < array.length - 1)
                qSort(array, low + 1, old_high); // 要排的数据：从数组的key后面一个数据的位置开始到old_high位置结束
        }
    }

}

/**
 * 测试类
 */
public class Demo {
    public static void main(String[] args) {
        ExchangeSort sort = new ExchangeSort();
        int[] array_1 = new int[]{49,38,65,97,76,13,27,49};
        System.out.println("要排序数组：");
        for(int n : array_1)
            System.out.print(n + "  ");

        System.out.println();

        array_1 = sort.bubbleSort(array_1);
        System.out.println("冒泡排序结果：");
        for(int n : array_1)
            System.out.print(n + "  ");

        System.out.println();

        int[] array_2 = new int[]{49,38,65,97,76,13,27,49};
        array_2 = sort.quickSort(array_2);
        System.out.println("快速排序结果：");
        for(int n : array_2)
            System.out.print(n + "  ");
    }
}

效果

要排序数组：
49  38  65  97  76  13  27  49  
冒泡排序结果：
13  27  38  49  49  65  76  97  
快速排序结果：
13  27  38  49  49  65  76  97