Java学习笔记day06

新手小白6

已于 2022-10-26 17:06:58 修改

阅读量155

点赞数

分类专栏： Java学习记录文章标签： java 学习算法

于 2022-09-27 20:25:58 首次发布

本文链接：https://blog.csdn.net/kouzai8880/article/details/127077823

版权

Java学习记录专栏收录该内容

41 篇文章 0 订阅

订阅专栏

二维数组

概念

存储数组的数组

名词

长度: 二维数组中一维数组的个数
元素: 一个一维数组
下标(索引): 一维在二维数组中的位置

步骤

1.声明
	数据类型[][] 数组名;
2.创建
	动态
		带值
			数组名 = new 数据类型[][]{
				{值1, 值2, ... },
				{值3, 值4, 值5, ...},
				{值6, ...},
				...
			};
		不带值
			数组名 = new 数据类型[x][y];
			x: 二维数组中一维数组的个数
			y: 一维数组中元素的个数，可写，可不写
		特点: 可以将声明与创建分开，也可以同时进行
	静态
		数据类型[][] 数组名 = {
			{值1, 值2, ... },
			{值3, 值4, 值5, ...},
			{值6, ...},
			...
		};
		特点: 声明与创建必须同时进行
3.操作
	改
		修改指定位置的一维数组
			数组名[下标] = 新的一维数组;
				数组名[下标]
			查询指定位置的元素
				数组名[下标1][下标2];
				下标1: 一维数组在二维数组中的位置
				下标2: 元素在一维数组中的位置
			查询二维数组的长度
				数组名.length
				注意: 长度为二维数组中一维数组的个数，不是所有元素的个数

特殊情况

遍历
思想:
	逐个获取二维数组中的一维数组
	逐个获取一维数组中的每个元素

杨辉三角

i
0	1	0	0	0	0	0
1	1	1	0	0	0	0
2	1	2	1	0	0	0
3	1	3	3	1	0	0
4	1	4	6	4	1	0
5	1	5	10	10	5	1
	...
	0	1	2	3	4	5
	
	当j==0或j==i时值为1
	j<i时: 当前位置[i][j] = 上一行[i-1][j] + 上一行[i-1][j-1]
	j>i时: 值为0

算法

人: 图灵
奖项: 图灵奖
计算机: 图灵机
图灵说: 软件就是数据结构+算法

概念

公式

优点

提高计算机的运算符效率
如:
	//原来的
	int sum = 0;
	for(int i = 1; i < 101; i++){
		sum += i;
	}
	System.out.println(sum);
	
	数学公式:(首项 + 尾项)*项数/2
	int sum = (1 + 100)*100/2;

如何判断算法是否优秀

时间复杂度: 代码执行的时长，越短越好
空间复杂度: 代码在运行占用的内存，内存越少越好

常用的算法

两数交换
	int a = 10;
	int b = 2;
	int c = a; //找一个中间数记录a
	a = b; //将b的值赋值给a
	b = c; //将中间数的值赋值b
	
寻找最值(最大值/最小值)
	int[] nums = {10, 99, 88, 101, 7, 61, 34, 57, 99};
	//寻找最大值
	//假设一个数为最大值，必须是数组中的数
	int max = nums[0];
	//循环获取数组中所有的数与假设的最大值比较
	for(int i = 0; i < nums.length; i++){
		//获取数组中i位置的值
		int x = nums[i];
		//使用获取的值与假设的最大值比较
		if(x > max){
			max = x;
		}
	}

寻找最值的下标
	int[] nums = {10, 99, 88, 101, 7, 61, 34, 57, 99};
	//寻找最小值下标
	//假设一个数为最小值下标，要求该数的值在数组下标的取值范围内
	int minIndex = 0;
	//循环获取数组中所有的数与假设的最小值下标对应的数比较
	for(int i = 0; i < nums.length; i++){
		//获取数组中i位置的值
		int x = nums[i];
		//判断假设的最小值下标对应的数与获取数组中的数比较
		if(nums[minIndex] > x){
			minIndex = i;
		}
	}
	System.out.println("最小值下标为: " + minIndex);
	
排序
	冒泡排序
	int[] nums = {10, 22, 4, 16, 8, 99, 101, 50, 86, 62};
	for(int i = 0; i < nums.length - 1; i++) {
		for(int j = 0; j < nums.length - i - 1; j++) {
			if(nums[j] > nums[j + 1]) {
				int temp = nums[j];
				nums[j] = nums[j + 1];
				nums[j + 1] = temp;
			}
		}
	}
	for (int i : nums) {
		System.out.print(i + "   ");
	}
	System.out.println();
	
	选择排序
	int[] nums = {10, 22, 4, 16, 8, 99, 101, 50, 86, 62};
	for(int i = 0; i < nums.length - 1; i++) {
		int minIndex = i;
		for(int j = i + 1; j < nums.length; j++) {
			if(nums[j] < nums[minIndex]) {
				minIndex = j;
			}
		}
		if(minIndex != i) {
			int temp = nums[i];
			nums[i] = nums[minIndex];
			nums[minIndex] = temp;
		}
	}
    for (int i : nums) {
		System.out.print(i + "   ");
	}
	System.out.println();
	
	JDK提供的排序(快速排序)
		Arrays.sort(数组);
		规则: 从小到大

练习

寻找以下数组的最大值与最大值下标
	int[] nums = {10,9,88,12,7,76,34,57,109};
分别使用冒泡排序,选择排序,JDK提供的排序对以下数组进行排序
	int[] nums = {10,9,88,12,7,76,34,57,109};
定义以下方法并调用
	1,定义寻找数组中最大值的方法,要求传入数组,返回最大值
	2,定义寻找数组中最大值下标的方法,要求传入数组,返回最大值下标
	3,寻找数组中是否存在指定数据的方法,要求传入数组与指定的数据.如果数据存在返回数据在数组中的位置,如果不存在返回-1
	4,定义方法对数组进行排序,要求传入数组,返回排序好的数组(按照从大到小的方式排序)


public class Test01 {
	public static void main(String[] args) {
		int[] nums = {10,9,88,12,7,76,34,57,109};
		
		//寻找数组中的最大值
		int max = nums[0];
		for (int i : nums) {
			if(i > max) {
				max = i;
			}
		}
		System.out.println("数组中的最大值为: " + max);
		
		//寻找数组中的最大值下标
		int maxIndex = 0;
		for(int i = 0; i < nums.length; i++) {
			if(nums[i] > nums[maxIndex]) {
				maxIndex = i;
			}
		}
		System.out.println("数组中最大值的下标为: " + maxIndex);
	}
}

import java.util.Arrays;

public class Test02 {
	public static void main(String[] args) {
		int[] arr1 = {10, 9, 88, 12, 7, 76, 34, 57, 109};
		System.out.print("原数组是: ");
		printArray(arr1);
		bubbleSort(arr1);
		
		System.out.println("------------------------------------------------------------");
		
		int[] arr2 = {10, 9, 88, 12, 7, 76, 34, 57, 109};
		System.out.print("原数组是: ");
		printArray(arr2);
		selectSort(arr2);	
		
		System.out.println("------------------------------------------------------------");
		
		int[] arr3 = {10, 9, 88, 12, 7, 76, 34, 57, 109};
		System.out.print("原数组是: ");
		printArray(arr3);
		Arrays.sort(arr3);
		System.out.print("Arrays.sort(): ");
		printArray(arr3);
	}
	
	//打印数组
	public static void printArray(int[] nums) {
		for (int i : nums) {
			System.out.print(i + "   ");
		}
		System.out.println();
	}
	
	//冒泡排序
	public static void bubbleSort(int[] nums) {
		for(int i = 0; i < nums.length - 1; i++) {
			for(int j = 0; j < nums.length - i - 1; j++) {
				if(nums[j] > nums[j + 1]) {
					int temp = nums[j];
					nums[j] = nums[j + 1];
					nums[j + 1] = temp;
				}
			}
		}
		System.out.print("冒泡排序: ");
		printArray(nums);	
	}
	
	//选择排序
	public static void selectSort(int[] nums) {
		for(int i = 0; i < nums.length - 1; i++) {
			int minIndex = i;
			for(int j = i + 1; j < nums.length; j++) {
				if(nums[j] < nums[minIndex]) {
					minIndex = j;
				}
			}
			if(minIndex != i) {
				int temp = nums[i];
				nums[i] = nums[minIndex];
				nums[minIndex] = temp;
			}
		}	
		System.out.print("选择排序: ");
		printArray(nums);	
	}
}

public class Test03 {
	public static void main(String[] args) {
		int [] arr = {10, 22, 4, 16, 8, 99, 101, 50, 86, 62};	
		System.out.println("数组中最大值为: " + findMax(arr));
		System.out.println("数组中最大值下标为: " + findMaxIndex(arr));
		System.out.println("4在数组中的位置为: " + findData(arr, 4));
		int[] newArr = arraySort(arr);
		for (int a : newArr) {
			System.out.print(a + "   ");
		}
		System.out.println();
	}
	
	//定义寻找数组中最大值的方法,要求传入数组,返回最大值
	public static int findMax(int[] arr) {
		int max = arr[0];
		for (int a : arr) {
			if(a > max) {
				max = a;
			}
		}
		return max;
	}
	
	//定义寻找数组中最大值下标的方法,要求传入数组,返回最大值下标
	public static int findMaxIndex(int[] arr) {
		int maxIndex = 0;
		for(int i = 0; i < arr.length; i++) {
			if(arr[i] > arr[maxIndex]) {
				maxIndex = i;
			}
		}
		return maxIndex;
	}
	
	//寻找数组中是否存在指定数据的方法,要求传入数组与指定的数据.
	//如果数据存在返回数据在数组中的位置,如果不存在返回-1
	public static int findData(int[] arr, int data) {
		for(int i = 0; i < arr.length; i++) {
			if(data == arr[i]) {
				return i;
			}
		}
		return -1;		
	}
	
	//定义方法对数组进行排序,要求传入数组,返回排序好的数组(按照从大到小的方式排序)
	public static int[] arraySort(int[] arr) {
		//选用冒泡排序
		for(int i = 0; i < arr.length - 1; i++) {
			for(int j = 0; j < arr.length - i - 1; j++) {
				if(arr[j] < arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		return arr;
	}
	
}