数组高级

数组高级

二分查找

二分查找思路： 查找元素的索引，一次排除一半的元素
    1.计算开始索引和结束索引
           start = 0;
           end = array.length-1
    2.计算中的索引 mid = (start+end)/2;
    3.让中间元素和目标元素key进行比较
        array[mid]>key 时: end=mid-1
        array[mid]<key 时：start=mid+1
        array[mid]==key 时：mid就是要找的索引

    4.循环执行2.3步骤，直到start>end结束。如果没有找到返回-1

public class ArrayDemo1 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8};

        //调用二分查找的方法
        int index = binarySearch(array, 9);
        System.out.println(index);
    }

    //需求：查找数组中指定元素出现的索引
    public static int binarySearch(int[] array, int key) {
        //1.计算开始索引和结束索引
        int start = 0;
        int end = array.length - 1;
        //如果start <= end；就可以一直找
        while (start <= end) {
            //2.计算中的索引 mid = (start+end)/2;
            int mid = (start + end) / 2;
            // 3.让中间元素和目标元素key进行比较
            if (array[mid] > key) {
                //array[mid]>key 时: end=mid-1
                end = mid - 1;
            } else if (array[mid] < key) {
                //array[mid]<key 时：start=mid+1
                start = mid + 1;
            } else {
                //array[mid]==key 时：mid就是要找的索引
                return mid;
            }
        }
        //如果没有找到，就返回-1
        return -1;
    }
}

 

冒泡排序

冒泡排序的规则：
1.相邻两个元素两两比较，小的放前面，大的放后面。
2.一共比较的轮数是n-1轮
3.每一轮比较，要上前一轮少一次

//对元素进行排序
public static void sort(int[] array) {
    //1.确定比较的轮数，长度-1
    for (int i = 0; i < array.length - 1; i++) {
        //2.每一轮比较的次数，比前一轮少1次
        for (int j = 0; j < array.length - 1 - i; j++) {
            //3.每一轮相邻的两个元素进行比较，大的往后的，小的往前放
            if (array[j] > array[j + 1]) {
                int temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
}

 

快速排序

快速排序的思路：
1.把0索引的元素确定为基准数
2.从右往左找比基准数小的
3.从左往右找比基准数大的
4.把左右两边的数据交换
5.基准数归位

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] array = {6, 8, 7, 5, 3, 4, 2};
        quiteArray(array, 0, array.length - 1);

        //遍历数组中的元素，并打印
        String s = Arrays.toString(array); 
        System.out.println(s);
    }

    public static void quiteArray(int[] array, int left, int right) {
        //递归的出口
        if (right < left) { return; }
        //先记录开始索引和结束索引的位置
        int left0 = left;
        int right0 = right; 
        //定义基准数
        int baseNumber = array[left0];
        while (left != right) {
            //从右往左，找比基准数小的
            while (array[right] >= baseNumber && right > left) {
                right--;
            }
            //从左往右，找比基准数大的
            while (array[left] <= baseNumber && right > left) {
                left++;
            }
            //把左右两边的数据进行交换
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;
        }
        //把left位置的元素放在left0位置
        array[left0] = array[left];
        //基准数放在left位置
        array[left] = baseNumber;
        //左右两部分分别快速排序
        quiteArray(array, left0, left - 1);
        quiteArray(array, right + 1, right0);
    } 
}