二维数组
概念
存储数组的数组
名词
长度: 二维数组中一维数组的个数
元素: 一个一维数组
下标(索引): 一维在二维数组中的位置
步骤
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;
}
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;
}
}