ACAC 查找排序（冒泡，选择，二分）

import java.util.Arrays;

/*
*1、常见算法：
*       排序算法：
*           冒泡排序，选择排序
*       查找算法：
*           二分查找
*       虽然我们可以直接调用，但是面试的时候会用
*
*  注意：java中算法不需要精通，因为java中意境封装好了
*       要排序只需调用方法就行，如：java中提供了一个数组工具类
*   java.util.Arrays
*      Arrays是一个工具类，其中有一个sort（）方法，可以排序。
*      静态方法，直接类名.调用就行
*
*   工具类中的方法大都是静态的
* */
public class Note01 {
    public static void main(String[] args) {

        int[] a = {2,23,4,5,223,54,23,646,264};
        Arrays.sort(a);

        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }


    }


}

======================================================================================================

/*
* 冒泡排序
* 5 4 2 1 0
*
* 4 5 1 0 2
*
* 4 1 0 2 5
*
* 1 0 2 4 5
*
* 0 1 2 4 5
* */
public class Test01 {
    public static void main(String[] args) {

        int[] a = {12,23,35,23,13,34,54,6,34};
        int count =0;

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

                if(a[j] > a[j+1]){
                    int b = a[j];
                    a[j] = a[j+1];
                    a[j+1] = b;
                    count++;

                }
            }
        }

        for (int i = 0; i < a.length; i++) {
            System.out.print(" " + a[i]);
        }
        System.out.println("\n交换次数： "+ count);
    }
}

======================================================================================================

/*
* 选择排序：
*   每一次从这堆数组中找出最小值
*
* 结论：选择和冒泡的比较次数一样，不会变化
*      但是交换次数变少了,冒泡的交换是选择的二倍还多
*  */
public class Test02 {

    public static void main(String[] args) {

        int[] a = {12,23,35,23,13,34,54,6,34};
        int count = 0;

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

//       第一次：i=0，让a[0]和数组中的所有元素进行比较，得出什么结果？
//              a[0]一定是最小的
//       第二次：i=1,除去a[0],进行比较，结果:a[1]一定是最小的，依次循环

            int min = i;
            for(int j = i+1; j < a.length; j ++){
                if(a[min] > a[j]){
                   min = j;

                /*int temp = a[i];
                a[i] = a[min];
                a[min] = temp;*/
/*
	为什么不在这里直接进行赋值操作，
	因为如果你第一个最大，那将一直进行赋值操作，效率降低
	结论：选择排序跟冒泡排序不一样就在此处：
	选择排序不需要每判断出结果，就赋值，
	而是 将这个元素的下标标记一下，到外边做一次交换赋值就行了
*/
                }
            }

            if(min != i){
                int temp = a[i];
                a[i] = a[min];
                a[min] = temp;
                count++;
            }

        }

        for (int i = 0; i < a.length; i++) {
            System.out.print(" " + a[i]);
        }

        System.out.println("\n交换次数： " + count);

    }

}

======================================================================================================

/*
 *数组元素查找：
 *   两种方式：
 *   1、一个一个挨着找，直到找到为止
 *   2、二分法（算法），只适合从小到大排序的，建立在排序的基础之上，相对来说查找效率较高
 *   3、原理：
 *
 *  */
public class Test03 {
    public static void main(String[] args) {

        int[] arr = {12, 23, 323, 45, 243, 456, 234, 45, 65, 5, 3, 45, 6, 2, 78, 56, 35, 278, 57};

        //逐个查找
       /* for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 2) {
                System.out.println("找到该元素，下标为： " + i);
                return;
            } else if (i == arr.length - 1) {
                System.out.println("没有找到该元素。。。");
            }
        }*/


        int[] arrr = {12, 13, 15, 17, 23, 34, 54, 68, 89, 234, 5657, 7999};
        int index = binarySearch(arrr, 7999);
        System.out.println((index == -1)? "该元素不存在":"该元素存在，下标为" + index);
    }

    /**
     * 从数组中查找目标元素的下标
     *
     * @param arrr 被查找的数组
     * @param i    目标元素
     * @return 返回-1表示该元素不存在，其他表示返回该元素的下标
     */
    public static int binarySearch(int[] arrr, int i) {
        int begin = 0;
        int end = arrr.length - 1;


        //当begin在或者等于end时，一直循环
        while (begin <= end) {

            int middle = (end + begin) / 2;

            if (arrr[middle] == i) {
                return middle;
            } else if (arrr[middle] < i) {
                begin = middle + 1;
            } else if (arrr[middle] > i){
                end = middle -1;
            }

        }
        return  -1;

    }


}

======================================================================================================

import java.util.Arrays;
/*
* java.util.Arrays工具类
*   所有方法都是静态的，直接类名.调用
*   主要使用以下两个方法：
*       二分法查找，排序
* */
public class ArraysTest01 {

    public static void main(String[] args) {

        int[] a = {12,23,3541,1,23,5,23,65,35,457,3425,757};
        Arrays.sort(a);

        for (int i = 0; i < a.length; i++) {
            System.out.print(" " +a[i]);
        }

        int index = Arrays.binarySearch(a,23);
        System.out.println(index == -1? "\n该元素不存在":"\n该元素下标为：" + index);
        //建立在排序的基础上,有重复的话，先找到谁就是谁，（二分法找）
    }
}