文章目录
前言
本篇文章是韩顺平老师课程P156-P189（第六章：数组排序和查找）重点内容的详细总结。
- 数组（语法、赋值机制、反转、扩容）
- 排序（冒泡）
- 查找
- 二维数组（杨辉三角）
一、数组
1. 基础语法
1）介绍
- 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。
- 即：数组就是一组数据。
2）使用（动态、静态初始化语法与使用）
-
动态初始化1
- 定义：定义格式有两种，任意一种都可以
数据类型 数组名[] = new 数据类型[大小];
数据类型[] 数组名 = new 数据类型[大小];
- 引用：指定数组里要哪一个（下标）
- 定义：定义格式有两种，任意一种都可以
-
动态初始化2
- 先声明数组
数据类型 数组名[]; 数据类型[] 数组名; int a[]; 或者 int[] a; - 创建数组
数组名 = new 数据类型[大小]; a = new int[10];
- 先声明数组
-
静态初始化
-
语法1
数据类型 数组名[] = {元素值，元素值...};
-
语法2
数据类型 数组名[] = new 数据类型[]{元素值，元素值...};
-
3）注意事项和细节
- 数组是多个相同数据类型的组合，实现对这些数据的统一管理
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
- 数组创建后，如果没有赋值，有默认值
int - 0; short - 0; byte - 0; float - 0.0; double - 0.0; char - \u0000; boolean - false; String - null - 使用数组的步骤
- 声明数组并开辟空间
- 给数组各个元素赋值
- 使用数组
- 数组的下标是从0开始的
- 数组下标必须在指定的范围内使用，否则报：下标越界异常
比如 int[] arr = new int[5]; 则有效下标为0-4 - 数组属于引用类型，数组型数据是对象（object）
2. 数组赋值机制 (Arry Assign)
- 基本数据类型赋值
- 赋值方式为值拷贝，互相不会影响
- 是赋具体的值
public class Forxxx{
public static void main(String[] args){
//基本数据类型赋值，赋值方式为值拷贝
int n1 = 10;
int n2 = n1;
n2 = 80;
System.out.println(n1); //10 n1没有受n2的影响
System.out.println(n2); //80
}
}
- 数组赋值
- 默认情况下是引用传递，赋的值是地址，也叫地址拷贝
- 数值会相互影响
public class Forxxx{
public static void main(String[] args){
//数组在默认情况下是引用传递，赋的值是地址
//赋值方式为引用赋值
//是一个地址，arr2的变化会影响到arr1
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2[0] = 10;
for(int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]); //此时输出 10，2，3 受影响
}
}
}
- 数组赋值内存图（重难点）
光看图会比较抽象，这里可以看老韩的视频讲解
3. 数组拷贝
直接用一个数组拷贝案例代码进行演示。
public class Forxxx{
public static void main(String[] args){
//将 int[] arr1 = {10, 20, 30}; 拷贝到 arr2 数组，要求数据空间是独立的
int[] arr1 = {10, 20, 30};
int[] arr2 = new int[arr1.length]; //开辟新的数据空间，大小与arr1相同 -> arr1.length
for(int i = 0; i < arr1.length; i++) { //遍历 arr1，把每个元素拷贝到arr2对应的位置
arr2[i] = arr1[i];
}
//修改arr2
arr2[0] = 100;
//输出，
for(int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i] + " " + arr2[i]); // arr1 是 10，20，30； arr2 是 100， 20， 30
}
}
}
4. 数组反转（reserve）
- 数组反转重在找规律，以交换两个杯子的水为例：我们必须要用到第三个空杯子，将第一杯的水倒到空杯子里，才能将第二杯里的水倒进第一个杯子。
- 同理，想要交换数组的数据顺序，需要定义一个变量temp用来临时存放用于交换的数据
- 案例演示：要求：arr {11, 22, 33, 44, 55, 66} => arr {66, 55, 44, 33, 22, 11}
public class ArrayReverse {
//编写一个 main 方法
public static void main(String[] args) {
//定义数组
int[] arr = {11, 22, 33, 44, 55, 66};
//1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
//2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11}
//3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11}
//4. 一共要交换 3 次 = arr.length / 2
//5. 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i]
int temp = 0;
int len = arr.length; //计算数组的长度
for( int i = 0; i < len / 2; i++) {
temp = arr[len - 1 - i];//保存
arr[len - 1 - i] = arr[i];
arr[i] = temp;
}
System.out.println("===翻转后数组===");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");//66,55,44,33,22,11
}
}
}
5. 数组的扩容与缩减
- 直接通过案例演示，要求：实现动态的给数组添加元素效果，实现对数组的扩容
- 原始数组使用静态分配 int[] arr = {1, 2, 3}
- 增加的元素，直接放在数组的最后 arr = {1, 2, 3, 4} arrNew = {1, 2, 3, 4}
- 用户可以通过如下方法决定是否继续添加，添加成功，是否继续？ y/n
public class ArrayAdd02 {
//编写一个 main 方法
public static void main(String[] args) {
/*
思路分析
1. 定义初始数组 int[] arr = {1,2,3}//下标 0-2
2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
3. 遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把 4 赋给 arrNew 最后一个元素
5. 让 arr 指向 arrNew ; arr = arrNew; 那么 原来 arr 数组就被销毁
6. 创建一个 Scanner 可以接受用户输入
7. 因为用户什么时候退出，不确定，老师使用 do-while + break 来控制
*/
Scanner myScanner = new Scanner(System.in);
//初始化数组
int[] arr = {1,2,3};
do{
int[] arrNew = new int[arr.length + 1];
//遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
for(int i = 0; i < arr.length; i++) {
arrNew[i] = arr[i];
}
System.out.println("请输入你要添加的元素");
int addNum = myScanner.nextInt();
//把 addNum 赋给 arrNew 最后一个元素
arrNew[arrNew.length - 1] = addNum;
//让 arr 指向 arrNew, arr = arrNew;
//输出 arr 看看效果
System.out.println("====arr 扩容后元素情况====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
//问用户是否继续
System.out.println("是否继续添加 y/n");
char key = myScanner.next().charAt(0);
if( key == 'n') { //如果输入 n ,就结束
break;
}
} while(true);
System.out.println("你退出了添加...");
}
}
- 数组的缩减道理是一样的，老韩留了一个课堂作业，大家可以试着做一做，讲解视频我放在下面
老韩数组扩容与缩减
二、排序
- 介绍
- 是将一群数据，依照指定的顺序进行排列的过程
- 分类
- 内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）
- 外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）
- 冒泡排序(Bubble Sorting)
（后面我会写一篇专门关于冒泡排序思想和实现的文章，到时候这个地方我会放上文章超链接，如果这里没看懂的朋友可以看专题文章）- 基本思想：通过对待排序序列从后向前（从下标较大的元素开始），一次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部。
- 案例：将五个无序：24，69，80，57，13，使用冒泡排序法
public class BubbleSort {
public static void main(String[] args) {
//将五个无序：24，69，80，57，13，使用冒泡排序法
//从小到大
int[] arr = {24, 69, 80, 57, 13};
int temp = 0;//用于辅助交换的变量
//将多轮排序合并
for(int i = 0; i < arr.length - 1; i++) {//外层循环是 4 次
for(int j = 0; j < arr.length - 1 - i; j++) {//4 次比较-3 次-2 次-1 次
//如果前面的数>后面的数，就交换
if(arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("\n====第" + (i + 1) + "轮排序====");
for(int j = 0; j < arr.length; j++) {
System.out.print(arr[j] + "\t");
}
}
}
}
三、查找
-
介绍（常用查找方法）
- 1.顺序查找
- 2.二分查找（二分法，放在算法讲解）
-
案例演示
- 有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称
- 要求: 如果找到了，就提示找到，并给出下标值。
import java.util.Scanner;
public class Asgd{
public static void main(String[] args){
/*
思路分析
1. 定义一个字符串数组
2. 接收用户输入, 遍历数组，逐一比较，如果有，则提示信息，并退出
*/
//定义一个字符串数组
Scanner scan = new Scanner(System.in);
String[] arr = {"白眉","金毛","紫衫","青翼"};
System.out.println("请输入名字");
String name = scan.next();
//遍历数组，逐一比较，如果有，则提示信息，并退出
int index = -1;
for(int i = 0; i < arr.length; i++) {
//比较 字符串比较 equals, 如果要找到名字就是当前元素
if(name.equals(arr[i])) {
System.out.println("找到了");
System.out.println("下标为" + i);
//把 i 保存到 index
index = i;
break;
}
}
if(index == -1) { //没有找到
System.out.println("没找到");
}
}
}
四、二维数组 (TwoDimensionalArry)
1. 快速入门
2. 使用
-
动态初始化1
-
语法
类型[][] 数组名 = new 类型[大小][大小] -
使用
-
二维数组在内存的存在形式
-
-
动态初始化2
- 语法
- 先声明数组
类型 数组名[][]; - 再赋值
数组名[][] = new 类型[大小][大小]; //开辟空间
- 先声明数组
- 语法
-
动态初始化（列数不确定）
- 每一个一维数组的个数不一定相同
- 每一个一维数组的个数不一定相同
-
静态初始化
- 语法
类型 数组名[][] = {{值1，值2..},{值1，值2..},{值1，值2..}..}
- 语法
3. 案例：打印一个10行的杨辉三角
public class YangHui {
//编写一个 main 方法
public static void main(String[] args) {
int[][] yangHui = new int[12][];
for(int i = 0; i < yangHui.length; i++) {//遍历 yangHui 的每个元素
//给每个一维数组(行) 开空间
yangHui[i] = new int[i+1];
//给每个一维数组(行) 赋值
for(int j = 0; j < yangHui[i].length; j++){
//每一行的第一个元素和最后一个元素都是 1
if(j == 0 || j == yangHui[i].length - 1) {
yangHui[i][j] = 1;
} else {//中间的元素
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}
}
//输出杨辉三角
for(int i = 0; i < yangHui.length; i++) {
for(int j = 0; j < yangHui[i].length; j++) {//遍历输出该行
System.out.print(yangHui[i][j] + "\t");
}
System.out.println();//换行.
}
}
}
4. 细节
- 一维数组声明方式有两种
int[] x int x[] - 二维数组声明方式有三种
int[][] y int[] y[] int y[][] - 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同
本章的作业视频链接我放在这里：第六章数组作业讲解
总结
本篇文章是韩顺平老师课程P156-P189（第六章：数组排序和查找）重点内容的详细总结。
- 数组（语法、赋值机制、反转、扩容）
- 排序（冒泡）
- 查找
- 二维数组（杨辉三角）