欢迎使用CSDN-markdown编辑器

java 排序

package cn.itcast.demo;
import java.util.Arrays;
public class Demo02 {
    public static void main(String[] args) {
        int[] arr = new int[]{6,1,2,3,9,7,4,5,10,8};

        selectSort(arr);
        selectSortM(arr);
        niXu(arr);
        quickSort(arr);
        System.out.println(Arrays.toString(arr));


    }

    /**
     * 快速排序
     * @param arr
     */
    private static void quickSort(int[] arr) {
        sort(arr,0,arr.length-1);

    }
    /***
     * 快速排序
     * @param arr
     * @param stIndex
     * @param edIndex
     */
    private static void sort(int[] arr,int stIndex,int edIndex) {

        if(stIndex>edIndex){
            return;
        }
        int i,j,temp,t;//起始位置 结束位置 基准数 临时变量
        i = stIndex;
        j = edIndex;
        temp = arr[stIndex];

        while(i<j){//循环条件：在数组起始下标小于数组结束下标的时候循环
            //比对：从右往左找小于基数的元素 循环不能越界  i小于 j 说明 还有说可以比对 
            while(arr[j]>temp && i<j ){
                j--;//如果j的数大于基准数那么 向左遍历 --  直到条件不成立找到小于基准数的 
            }
            while(arr[i]<=temp && i<j){//从第下标1开始比较   arr[i] 初始位置是 基准数据  不跟自己比对
                i++;//如果i的元素小于基准数那么 向右遍历 ++ 直到条件不成立找到大于基准数的 
            }
            //经过以上两个循环  一个找到比基数小的  一个找到比基数大的  停止循环 到这里交换元素
            if(i<j){//开始元素下标小于结束元素下标  说明还没遍历完  可以交换位置
                t = arr[j];//将j 找到的小于基准数的元素赋临时变量

                arr[j] = arr[i];//元素大的放右边

                arr[i] = t;//小的元素往左放
            }

        }
        //循环结束将基准数和 刚才结束循环的数组元素下标交换位置 
        //中间数不会大于基准数 因为从右往左先遍历，找到小的才停止  然后执行 从左往右遍历 找到比基准数大的才停止 
        //A 遍历  找到小于 基准数  停止循环   
        //B 遍历  找到大于基准数  停止循环
        //A  B交换位置
        //A 遍历  找到小于 基准数  停止循环   
        //B 遍历  没到大于基准数   一直遍历小 i  不小于  j  
        //这是两者相遇  那么 A 遍历这个数就是比基准数小
        //所以不用判断中间数是否回大于基准数

        System.out.println("中间位置："+arr[i]+":"+arr[j]);
        arr[stIndex] = arr[i];
        System.out.println("起始位置："+arr[stIndex]);
        arr[j] = temp;
        System.out.println("中间位置："+arr[j]);
        System.out.println(Arrays.toString(arr));
        sort(arr, stIndex, i-1);
        sort(arr, j+1, edIndex);

    }

    /*
     * 二分查找法
     * @param arr
     * @param sum
     * @return
     */
    public static int erFb(int[] arr,int sum){

        int min=arr[0],max = arr.length-1;
        int mid = 0;
        while (min<=max) {
            mid = (min+max)/2;
            if(sum>mid){
                mid = mid+1;
            }else if(sum<mid){
                max = mid-1;
            }else{
                return mid;
            }

        }
        return -1;

    }
    /**
     * 数组逆序
     * @param arr
     */
    private static void niXu(int[] arr) {

        for (int min=0,max=arr.length-1; min < max; min++,max--) {  
            //          if (arr[min]==arr[max]) {
            //              break;
            //          }
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;


        }
        System.out.println(Arrays.toString(arr));

    }

    /**
     * 冒泡排序
     * @param arr
     */
    private static void selectSortM(int[] arr) {

        for (int i = 0; i < arr.length-1; i++) {

            for (int j = 0; j < arr.length-1-i; j++) {

                if(arr[j]>arr[j+1]){

                    int temp = arr[j];

                    arr[j] = arr[j+1];

                    arr[j+1] = temp;
                }
            }

        }
        System.out.println(Arrays.toString(arr));

    }
    /**
     * 选择排序
     * @param arr
     */
    private static void selectSort(int[] arr) {

        for (int i = 0; i < arr.length-1; i++) {

            for (int j = i+1; j < arr.length; j++) {

                if(arr[i]>arr[j]){

                    int temp = arr[i];

                    arr[i] = arr[j];

                    arr[j] = temp;

                }
            }
        }
        System.out.println(Arrays.toString(arr));

    }
}