2.数组常用的算法

数组的算法

• 冒泡

public static void mp(int[] arr){
    for (int i = arr.length-1;i>0; i--) {
        for (int j = 0; j < i; j++) {
            //两两比较，如果前面大则交换
            if (arr[j]>arr[j+1]){
                int tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
            }
        }
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

• 选择排序

public class SelectSort {
    public static void main(String[] args) {
        /**
         * 选择排序
         *  循环找出参加比较的数据中最小的，然后使用最小值和最前面的数据交换位置
         */
        int[] arr = {3, 1, 6, 2, 5};
        for (int i = 0; i < arr.length; i++) {
            //将设第一个最小
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                //找出最小值
                if (arr[j] < arr[min]) {
                    //最小值的下标min
                    min = j;
                }
            }
            //如果min不等于i，表示猜测错误需要发生交换
            if (min != i) {
                int tmp = arr[min];
                arr[min] = arr[i];
                arr[i] = tmp;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

//有重复值时候的二分查找
public class selectSort_01 {
    public static void main(String[] args) {
        int[] arr = {1, 9, 2, 4, 3, 19, 2};
        //排序
        anySort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static boolean anySort(int[] arr) {
        if (null == arr || arr.length == 0) {
            System.out.println("wuxiao");
            return false;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            //从0开始
            int index = i;
            //与后一位进行比较
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] > arr[j]) {
                    index = j;
                }
            }
            //值交换
            if (index != i) {
                int tmp = arr[index];
                arr[index] = arr[i];
                arr[i] = tmp;
            }
        }
        return true;
    }
}

• 二分查找

public class binSerarch {
    public static void main(String[] args) {
        int[] arr = {1, 12, 23, 15, 6, 9, 3, 4, 2};
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        //二分查找-前提数据必须是有序的，未找到返回负数
        int i = Arrays.binarySearch(arr, 6);
        System.out.println(i);

        /**
         * 源码
         *     private static int binarySearch0(int[] a, int fromIndex, int toIndex,
         *                                      int key) {
         *         int low = fromIndex;
         *         int high = toIndex - 1;
         *
         *         while (low <= high) {
         *             int mid = (low + high) >>> 1;
         *             int midVal = a[mid];
         *
         *             if (midVal < key)
         *                 low = mid + 1;
         *             else if (midVal > key)
         *                 high = mid - 1;
         *             else
         *                 return mid; // key found
         *         }
         *         return -(low + 1);  // key not found.
         *     }
         */
    }
}

   public static int halfSer2(int[] arr, int key) {
        int max, min, mid;
        min = 0;
        max = arr.length - 1;
        while (min <= max) {
            mid = (max + min) >> 1;
            if (key > arr[mid]) {
                min = mid + 1;
            } else if (key < arr[mid]) {
                max = mid - 1;
            }
            return mid;

        }
        //如果要插入一个元素直接返回min min是一直变大的
        return -1;
    }
package day03.ArrayUtils;

public class arraySer {
    public static void main(String[] args) {
        /**
         * 二分法查找 数组是有序的 找18
         * 11 12 13 14 15 16 17 18 19 20 （10个）
         * 中间元素 arr[5]=15
         *  开始下标变成5+1
         *  重新计算中间元素的下标
         *  如果找20 最后一次 （9+9)/2 arr9=20
         */
        int[] arr = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
        int index = binSer(arr, 18);
        System.out.println(index);

    }

    private static int binSer(int[] arr, int dest) {
        int begin = 0;
        int end = arr.length - 1;
        //开始在一直增加，end在一直减小 当重合的时候就是找到元素
        while (begin <= end) {
            int mid = (begin + end) / 2;
            if (arr[mid] == dest) {
                return mid;
            } else if (arr[mid] < dest) {
                //元素在中间的右边，begin要向后移动
                begin = mid + 1;
            } else {
                //元素在中间的右边，end要向前移动
                end = mid - 1;
            }
        }
        return -1;
    }
}