交换排序-Java

package com.paixu.paixuTest;


import java.util.Arrays;
import java.util.Scanner;

/**
 * 交换排序
 * 1）冒泡排序
 * 2）快速排序：这个最好，一定要掌握
 */
public class jiaoHuanPaiXu {
    public static void main(String[] args) {
        System.out.println("请输入带排序数，以空格间隔：");
        Scanner scanner = new Scanner(System.in);
        int[] arr = new int[5];
        while (scanner.hasNext()){
            for (int i=0;i<arr.length;i++){
                arr[i] = scanner.nextInt();
            }
            // 1、冒泡排序
            maoPao(arr);

            // 2、快速排序
            kuaiPai(arr);

        }
    }

    /** 快排会用到分治法的思想
     * 分治法的思想，基准元素
     * 扫描，确定一次基准元素位置，分治，继续扫描，继续确定元素位置，直到最后。
     * @param arr
     */
    private static void kuaiPai(int[] arr) {
        int _left = 0;
        int _right = arr.length-1;
        sortFun(arr,_left,_right);
        System.out.println("快速排序："+Arrays.toString(arr));

    }

    private static void sortFun(int[] arr, int _left, int _right) {
        int left = _left;
        int right = _right;
        int temp = 0;  // 用于存放基准元素
        if (left<=right){
            temp = arr[left];
            while (left!=right){   // 最后是left=right的时候，停止扫描，确定最终位置
                // 从右开始扫描
                while (right>left && arr[right] >=temp)
                    right--;
                arr[left] = arr[right];
                // 从左开始扫描
                while (left<right && arr[left] <= temp)
                    left++;
                arr[right] = arr[left];
            }
            // 将基准元素唯一确定位置
            arr[right] = temp;
            sortFun(arr,_left,left-1);
            sortFun(arr,right+1,_right);
        }
    }

    /**
     * 5个数组元素
     * 冒泡排序
     * @param arr
     */
    private static void maoPao(int[] arr) {
        for (int i=1;i<arr.length;i++){
            boolean flag = false;  // 设置这个，是为了减少比较的次数，如果在一轮循环中，没有交换元素，说明所有元素有序了。
            for (int j=0;j<arr.length-i;j++){
                // 两两比较，大的往后移动
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;  // 只要发生了交换，就为true
                }
            }
            // 没有发生交换，则直接退出循环
            if (!flag){
                break;
            }
        }
        System.out.println("冒泡排序："+Arrays.toString(arr));

    }
}