数组排序--选择 --插入 -归并，希尔， 树

选择排序：
选择排序：
选择排序

            100,2,3,23,66,98,18,50
        默认了0 位置上的数最大  100    zuidaxiabiao = 0  zuidashu = 100
        0   和  1 位置上的数比较，发现0大, 不换
        0   和  2位置上的数比较， 发现 0大，不换
        。。。。。。
        0 和 7比较， 0比较大，0和7交换位置
        50 2 3 23 66 98 18 100
        选择排序的精髓就是我们只换下标，不直接换实际的数，这样可以减少更换的次数，从而提高效率
        public void xuanZhePaiXu() {
            /**
        {1,3,2,66,23,98,18,50}

        1 ,3,2,66,23,98,18,50
        100,2,3,23,66,98,18,50

        冒泡排序 -- 每一次都要进行交换，效率很低下

        选择排序
        默认了0 最大  100    zuidaxiabiao = 0  zuidashu = 100
        0   和  1 位置上的数比较，发现0大, 不换
        0   和  2位置上的数比较， 发现 0大，不换
        。。。。。。
        0 和 7比较， 0比较大，0和7交换位置
        50 2 3 23 66 98 18 100


        默认0最大   zuidaxiaobiao=0  zuidashu= 50
        0 和 1 比较   0最大
        。。。。
        0 和4比较   4比较大    默认4最大
        4 和5比较   5比较大     默认5最大
        5 和 6比较  5比较大   5和6就交换位置
        **/

        int arr[] = new int[50000];

        for(int i=0; i<arr.length; i++) {
            arr[i] = new Random().nextInt(100000);
        }
        Arrays.sort(arr);
        for(int i=0; i<arr.length; i++) {
            int zuidaxiabiao = 0;
            int zuidashu = arr[0]; // 100

            for(int j=1; j<arr.length; j++ ) {
                if(zuidashu > arr[j]) {
                    //默认的0大
                }else {
                    zuidaxiabiao = j;
                    zuidashu = arr[j];
                }
                if( j == arr.length-1-i) {
                    int temp = arr[zuidaxiabiao];
                    arr[zuidaxiabiao] = arr[j];
                    arr[j] = temp;  
                }   
            }   
        }



    }

插入排序：
插入排序的理念就是先把数组的第一个数作为一个数组，而是已经排序好的，从第二个开始去，通过和第一个数组元素比较，选择插入该数据到第一个数组的合适位置：

{100,3,2,660,23,98,18,50}

    public void chaRuPaiXu() {
    /**
        {[,3,2,66,23,98,18],[50]}
        插入排序：
        把当前数组拆分成两个数组：

        {【,,,,】,【1,2,3,18,23,50,66,98】}


        {[,3,2,66,23,98,18],[50]}
        ,2,66,23,98,18,1,50
        2,66,23,98,18,1,3,50



        {100,3,2,660,23,98,18,50}


        [100] [100,2,660,23,98,18,50]

        num = 3 
        【2,3】【100,660,23,98,18,50】
        num = 2

        【2,3,100】【660,23,98,18,50】
        660
        【2,3,23,100】,【660,98,18..】
        23

        【2,3,23,100,660】【,98,18..】



    **/






        int arr[] = new int[100000];

        for(int i=0; i<arr.length; i++) {
            arr[i] = new Random().nextInt(100000);
        }

        for(int i=1; i<arr.length; i++) {  // i = 3
            int j = i;        //j=4
            int num = arr[i];   //num = 23

            while(j>0&& num<arr[j-1]) { // arr[3] = 660
                arr[j] = arr[j-1];  //    
                j--;                //

            }

            arr[j] = num;      //2  3  100  660  23

        }

    }

但是，这些我们编写的算法效率都很低下，java默认使用二叉树排序，效率很高，所以一般我们队数组进行排序都使用java的工具排序

//java自带排序算法
        Arrays.sort(arr);

二分查找法，二分查找法的原理就是将数组进行排序，然后在通过和中间数的对比大小，判断我们要查找的数据时在左边还是右边，依次循环，从而放弃原来逐个比较的原则

public void erFenChaZhao() {
        int arr[] = {2,66,23,98,18,1,3,50};
        //100000000000   52

        //   0 1 2 3   4  5   6 7

        //  9  > #

        //(4+7)/2 = 3
        /*
        for(int i=0 ;i<arr.length; i++) {
            if(arr[i] == 9) {
                System.out.println("9这个数在"+i+"位置上！");
            }
        }
        */
        Arrays.sort(arr);
        for(int i=0 ;i<arr.length; i++) {

                System.out.println(arr[i]);

        }
        //{1,2,3,18,23,50,66,98};
        int n = 66;
        int zuobian = 0;
        int youbian = arr.length; // 7
        for(int i=0;i<arr.length; i++) {
            int zhongjian = (zuobian + youbian)/2;
            int num = arr[zhongjian]; //18
            if(n>num) {
                zuobian = index-1;
            }else if(n<num) {
                youbian = index+1;
            }else {
                System.out.println(n+"在低" +zhongjian +"个位置");
                break;
            }

        }



    }