常用类的API——数组高级和递归

数组高级

二分查找

二分查找思路： 查找元素的索引，一次排除一半的元素
    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.找到基准数
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);
    } 
}

递归练习

递归指的是方法自己调用自己。

需要注意两个问题
    1.方法调用一定要有出口
    2.调用的次数不能过多

递归求和

/*
   需求：求1~5之间的和
   假设：f(n)表示求n以内的和
        f(1) = 1
        f(2) = f(1) + 2
        f(3) = f(2) + 3
        f(4) = f(3) + 4
        f(5) = f(4) + 5
        ...
        f(n) = f(n-1)+n
 */
public class DiguiDemo1 {
    public static void main(String[] args) {
        int sum = getSum(5);
        System.out.println(sum);
    }

    //求n以内的和
    public static int getSum(int n) {
        if (n == 1) {
            return 1;
        } else {
            return getSum(n - 1) + n;
        }
    }
}

递归求斐波那契数列

/*
   需求：求斐波那契数列中的第n个数是多少？
        1   1   2   3   5   8   13  21  34  55....
   规律：
        第一个数和第二个数都是1
        从第三个数开始，每一个数字是前面两个数字之和

   假设：f(n)表示数列中的第n个数的值
        f(1) = 1
        f(2) = 1
        f(3) = f(1)+f(2)
        f(4) = f(2)+f(3)
        ...
        f(n) = f(n-2)+f(n-1)
 */
public class DiguiDemo2 {
    public static void main(String[] args) {

        int num = getNum(10);
        System.out.println(num);
    }

    //求斐波那契数列的第n个数
    public static int getNum(int n) {
        if(n==1 || n==2){
            return 1;
        }else{
            return getNum(n-2) + getNum(n-1);
        }
    }
}

println(num);
}

//求斐波那契数列的第n个数
public static int getNum(int n) {
    if(n==1 || n==2){
        return 1;
    }else{
        return getNum(n-2) + getNum(n-1);
    }
}

}