学习Java简单整理笔记--Day08

1，二维数组
---1，定义
    存放一组一维数组的数组，称二维数组
---2，声明
    语法：
        数据类型[ ][ ] 数组名；
---3，创建
    1，动态
        语法：
            不带值：
                 数组名 = new 数据类型 [一维数组的个数] [一维数组中元素的个数];
            带值：
                 数组名 = new 数据类型 [ ] [ ]{
                    {1，2，3，4}，
                    {12，13，14}，
                    {23，25}，
                    {33}
                 }；
    2，静态
        语法：
            数据类型  数组名 = {
                    {1，2，3，4}，
                    {12，13，14}，
                    {23，25}，
                    {33}
                    }；
---4，使用
修改
    修改二维数组中某个一维数组中的某个位置的值
        数组名[下标1][下标2] = 值;
        注意:
            下标1:一维数组在二维数组中的位置
            下标2:元素在一维数组中的位置
    修改二维数组中的一维数组
        数组名[下标] = 新的一维数组;
        下标:一维数组在二维数组中的位置
    修改整个二维数组
        数组名 = 新的二维数组;
查询
    查询二维数组中某个一维数组中的某个位置的值
        数组名[下标1][下标2]
        注意:
            下标1:一维数组在二维数组中的位置
            下标2:元素在一维数组中的位置
    查询二维数组中的一维数组
        数组名[下标]
        下标:一维数组在二维数组中的位置
    查询整个二维数组
        遍历
    查询二维数组长度
        数组名.length
        注意:获取的长度是二维数组中一维数组的个数
---5，特殊情况
    1,遍历
    思想:
        1,遍历二维数组
        2,获取二维数组中的一维数组
        3,遍历一维数组
        4,获取一维数组中的元素
    2,查找(见笔记07)
    3,杨辉三角(了解)

import java.util.Arrays;
public class Demo08 {
	/**
	 * 杨辉三角
	 * 	i	
	 * 	0	1
		1	1	1
		2	1	2	1
		3	1	3	3	1
		4	1	4	6	4	1
		
			0	1	2	3	4	j
			...					
	 */
	public static void main(String[] args) {
		int[][] num = new int[8][8]; 
		//使用i变量控制一维数组，也就是控制行
		for (int i = 0; i < num.length; i++) {
			//使用j变量控制一维数组中的元素，也就是控制列
			for (int j = 0; j < num[i].length; j++) {
				if (j == 0) {
					num[i][j] = 1;
				}else if (i > 0 && j <= i) {
					num[i][j]= num[i-1][j] +num[i-1][j-1];
				}
			}
		}
		for (int i = 0; i < num.length; i++) {
			for (int j = 0; j < num[i].length; j++) {
				System.out.print(num[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

结果：

---6，算法
    1，定义
        用代码解决数学公式就是算法
    2，性质：
        1.时间复杂度：执行该代码所需时间，时间越短越好
        2.空间复杂度：执行该代码所占运行内存空间大小，所占内存越小越好
    3，优点
        提高代码的执行效率
    4，常见算法：
        1，两个数交换
            int  a = 10;
            int  b = 2;
            int  c = a;
            a = b;
            b = c;
        2,寻找最大(最小)值；查询一组数的最大(最小)值所对应的下标
        3，冒泡排序：
            思想:相邻比较    
            代码思路  :
                1,获取数组
                2,循环比较多轮
                3,遍历数组中的数据
                4,让当前数据与后一个比较,如果前一个数大于/小于后一个数
                5,交换位置

 

        

public class Demo07 {
	public static void main(String[] args) {
		int[] nums = new int[] {23,17,45,78,9,99,76,11};
		//使用i变量控制比较轮数
		for (int i = 0; i < nums.length-1; i++) {
			//遍历数组，比较两个数，将小的移到前面
			for (int j = 0; j < nums.length-1; j++) {
				if (nums[j]  > nums[j+1]) {
					int x = nums[j+1];
					nums[j+1] =nums[j];
					nums[j] = x;
				}
			}
		}
		for (int i : nums) {
			System.out.print(i+",");
	    }	
	}
}

    结果：  

 

 4，选择排序：【思想：指定位置比较】

public class Demo07 {
	public static void main(String[] args) {
		int[] num = new int[] {23,17,45,78,9,99,76,11};
		for (int j = 0; j < num.length-1; j++) {
			//假设一个最小值的初始位置
			int minIndex = j;
			//定义一个目标位置
			int tagIndex = j;
			//遍历数组
			for (int i = j; i < num.length; i++) {
				if (num[minIndex] > num[i]) {
					minIndex = i;
				}
			}
			//此时假设最小值的下标就是真正的最小值的下标位置
			if (minIndex != tagIndex) {
				int x = num[tagIndex];
				num[tagIndex] = num[minIndex];
				num[minIndex] = x;
			}
			for (int i : num) {
				System.out.println(i);
			}
		}	
	}
}

结果：

        5，【jdk提供了一种排序工具：Arrays.sort(数组名)； ---默认从小到大排序
        6，二分查询【数组必须是有序的】
        二分查找法:
        要求:数组必须有有序的
        代码思路  :
        1,定义开始位置,0
        2,定义结束位置,数组长度-1
        3,循环判断开始位置小于等于结束位置
        4,计算中间位置
        5,判断中间位置对应的数与寻找的数的关系
            等于
                找到了
            大于
                如果数组的排序规则是从小到大,移动结束位置到中间位置-1
                如果数组的排序规则是从大到小,移动开始位置到中间位置+1
            小于
                如果数组的排序规则是从小到大,移动开始位置到中间位置+1
                如果数组的排序规则是从大到小,移动结束位置到中间位置-1

import java.util.Arrays;
public class Demo08 {
	public static void main(String[] args) {
		int[] num = new int[] {23,17,45,78,9,99,76,11};
		//将数组排序
		Arrays.sort(num);
		//定义一个变量为要查找的数
		int tag = 76;
		//定义起始点并赋值；
		int start = 0;
		//定义尾值并赋值；
		int end = num.length-1;
		boolean a = false;
		while (start <= end) {
			//设置中间值
			int center = (start+end)/2; 
			//判断中间值所对应的数值与所查数值的大小来改变中间值在数组中的位置
			if (num[center] == tag) {
				System.out.println("此数找到了！");
				a = true;
				break;
			}else if (num[center] > tag) {
				end =center - 1;
			}else {
				start = center + 1;
			}
		}
		if ( a = true) {
	
		}else {
			System.out.println("此数未找到！");
		}
	}
}

 结果：