day_07 简单的算法

复习

二分查找法

核心思想：分治思想
前提：数组必须是有序的，经过排序之后的数组
实现思想：通过使用中间元素和目标元素比较	来进行范围的缩小。

public class BineraySearch {
    public static void main(String[] args) {
        int[] arr = {21, 35, 12, 20, 65, 5, 56};
        for (int j = 0; j < arr.length - 1; j++) {
            int min = j; // min来记录当前最小的元素所在的位置
            for (int i = j; i < arr.length; i++) {
                if (arr[i] < arr[min]) {
                    min = i;
                }
            }
            // 比较结束之后  min记录的就是当前最小的
            // 元素所在的位置  将最小的元素和当前元素进行位置 的交换
            int temp = arr[j];
            arr[j] = arr[min];
            arr[min] = temp;

        }

        // 遍历数组
        for (int x : arr) {
            System.out.println(x);
        }
        boolean b = search(arr, 65);
        System.out.println("查找目标元素的结果：" + b);
    }
    /**
     * 实现二分搜索法 查找目标元素
     * @param arr 查找的数组
     * @param key 查找的目标元素
     * @return  boolean 找到目标元素 返回true  如果没有找到 则返回false
     */
    public  static  boolean  search(int[] arr , int key){
        int start = 0;
        int end = arr.length - 1;
        // 查找目标元素 结束的 条件是： 找到目标元素 或者 整个数组查找结束
        // 在循环执行过程中，start  不能大于end
        while(start <=  end){
            // 确定中间 元素的位置
            int mid = (start + end)/2;
            if(key == arr[mid]){
                return  true;
            }else if(key < arr[mid]){
                end = mid - 1;
            }else{//key > arr[mid]
                start = mid + 1;
            }
        }
        return  false;
    }
}

JDK API文档的使用

Arrays

专门针对数组操作的工具类

二分法查找

使用：

System.out.println(res);
// 在当前数组的指定范围内查找目标元素
//如果找到 则返回目标元素在完整数组中的 索引
int res1 = Arrays.binarySearch(arr,2,5,5);
System.out.println(res1);

排序算法的使用

//使用Arrays提供的排序算法对数组进行排序
// Arrays.sort(arr); 
 // 包含开始位置 的 元素 但是不包含结束位置的元素
 Arrays.sort(arr,2,5);

jdk原码的解读

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;// 计算中间位置  使用了无符号右移 相当于除2
        int midVal = a[mid];

        if (midVal < key)
            low = mid + 1;
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // 找到则直接返回元素所在的索引
    }
    return -(low + 1);  //没有找到 则返回负数
}

排序算法

将数组转化为String类型

//将数组转换为String
String arrStr =  Arrays.toString(arr);
 System.out.println("----" + arrStr);

作业，尝试解读原码并实现将整形数组转换为字符串输出，形式为[21,35,12,20,65,5,56]

Random

public static void main(String[] args) {
    Random random = new Random();
    //返回一个伪随机数  bound  返回的是任意的随机整数
    System.out.println(random.nextInt());
    //返回一个伪随机数  bound  返回的是0--100之间的数
    System.out.println(random.nextInt(100));
}

//Math的Random的方法
System.out.println((int)(Math.random() * 80 + 20) );=

数组的拷贝

public class ArrayCopyTest {
    public static void main(String[] args) {
        int[] arr= {21, 35, 20 ,12, 65, 5, 56};
        int[] dest = new int[3];// 目标数组的长度必须大于等于源数组才可以
        /*
        int[] src,拷贝的 源数组
       	int srcPos,拷贝的源数组的起始位置
       	int[] dest,// 拷贝的目标数组
       	int destPos, //拷贝到目标数组中的放入的 起始位置
       	int length,// 拷贝 的元素的个数
         */
        System.arraycopy(arr,0,dest,0,arr.length);
        for(int x : dest){
            System.out.println(x);

        }
    }
}

二维数组（了解）

二维数组的声明：
int[][] arr = new int[行数][列数]
二维数组的动态初始化

public static void main(String[] args) {
        /*
        * 在生命二维数组的时候，两个维度，一个维度表示行，另一个维度表示列
        * 行列可以相同也可以不同
        * 当我们通过arr.length去获取数组的长度时，其实获取的是数组的行数
        * */

        int [][] arr = new int[5][3];
        System.out.println(arr.length);
        // 给二维数组中的元素赋值
        arr[0][0] = 2;
        arr[1][1] = 9;
        arr[2][2] = 7;
        arr[3][2] = 5;
        for (int i = 0 ; i < arr.length ; i++){
            for (int j = 0 ; j < arr[i].length ; j++){
                System.out.print(arr[i][j] + " ");

            }
            System.out.println();

        }
    }

二维数组的静态初始化

public static void main(String[] args) {

        int[][] arr = {{1,2,3},{3,2,1},{4,5,6},{6,5,4},{1,5,9}};
        for (int i = 0 ; i < arr.length ; i++){
            for (int j = 0 ; j < arr[i].length ; j++){
                System.out.print(arr[i][j] + " ");

            }
            System.out.println();
        }
    }

// 静态初始化另一种写法
int[][] arr = new int[][]{{1,2,3},{3,2,1},{4,5,6},{6,5,4},{1,5,9,100}};

使用二维数组打印杨辉三角

特点：	第一行	一个元素	  为1
		第二行	两个元素	  都为1
		之后每行	首元素和末尾元素均为1	其余元素 yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j]

public class Yanghui {
    /*
    使用二维数组打印杨辉三角
        特点  第一行 只有一个元素 且为1
              第二行 两个元素  都为1
              之后每行  首元素和 末元素均为1  其余元素等于
         yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j]
     */
    public static void main(String[] args) {
        int yanghui[][] =new int[10][];//声明二维数组的时候 行数必须指定 列数可以在使用列之前来指定
        for(int i = 0 ; i < yanghui.length;i++){
            yanghui[i] = new int[i + 1];	// 指定每行的列数。
			
			// 给列赋值元素
            for(int j = 0 ; j < yanghui[i].length;j++){
                	// 每行首尾元素为1;
					if( j == 0 || i == j){
                    yanghui[i][j] = 1;
                }else{

                    yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
                }
            }
        }
        
        // 二位数组的遍历
        for(int i = 0 ; i < yanghui.length;i++){
            for(int j = 0 ;j < yanghui[i].length; j++){

                System.out.print(yanghui[i][j] +"  ");
            }
            System.out.println();

        }
    }
}

二维数组的内存分配情况：