数组的简单应用

oh Yes

已于 2023-05-22 20:27:33 修改

阅读量118

点赞数

文章标签：算法 java 数据结构

于 2023-05-22 20:25:21 首次发布

本文链接：https://blog.csdn.net/wqertyuu/article/details/130814437

版权

数组

一.一维数组

1.1数组应用案例

创建一个 char 类型的 26 个元素的数组，分别放置’A’-‘Z’。使用 for 循环访问所有元素并打印出来。提示：char 类型数据运算 ‘A’+2 -> ‘C’

package com.company.wq.one;

public class ArrayExercise01 {
    //编写一个main方法
    public static void main(String[] args) {

      /*
      创建一个char类型的26个元素的数组，分别 放置'A'-'Z'。
      使用for循环访问所有元素并打印出来。
      提示：char类型数据运算 'A'+1 -> 'B'

      思路分析
      1. 定义一个 数组  char[] chars = new char[26]
      2. 因为 'A' + 1 = 'B' 类推，所以使用for来赋值
      3. 使用for循环访问所有元素
       */
        char[] chars = new char[26];
        for( int i = 0; i < chars.length; i++) {//循环26次
            //chars 是 char[]
            //chars[i] 是 char
            chars[i] = (char)('A' + i); //'A' + i 是int , 需要强制转换
        }

        //循环输出
        System.out.println("===chars数组===");
        for( int i = 0; i < chars.length; i++) {//循环26次
            System.out.print(chars[i] + " ");
        }

    }
}

请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标

package com.company.wq.one;

public class ArrayExercise02 {
    //编写一个main方法
    public static void main(String[] args) {

        //请求出一个数组int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标
        //思路分析
        //1. 定义一个int数组 int[] arr = {4,-1,9, 10,23};
        //2. 假定 max = arr[0] 是最大值 , maxIndex=0;
        //3. 从下标 1 开始遍历arr， 如果max < 当前元素，说明max 不是真正的
        //   最大值, 我们就 max=当前元素; maxIndex=当前元素下标
        //4. 当我们遍历这个数组arr后 , max就是真正的最大值，maxIndex最大值
        //   对应的下标

        int[] arr = {4,-1,9,10,23};
        int max = arr[0];//假定第一个元素就是最大值
        int maxIndex = 0; //

        for(int i = 1; i < arr.length; i++) {//从下标 1 开始遍历arr

            if(max < arr[i]) {//如果max < 当前元素
                max = arr[i]; //把max 设置成 当前元素
                maxIndex = i;
            }
        }
        //当我们遍历这个数组arr后 , max就是真正的最大值，maxIndex最大值下标
        System.out.println("max=" + max + " maxIndex=" + maxIndex);
    }
}

1.2数组赋值机制

基本数据类型赋值，这个值就是具体的数据，而且相互不影响。

int n1 = 2; int n2 = n1;

数组在默认情况下是引用传递，赋的值是地址。

看一个案例，并分析数组赋值的内存图(重点, 难点. )。

int[] arr1 = {1,2,3};

int[] arr2 = arr1;

1.3数组拷贝

将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 要求数据空间是独立的

package com.company.wq.one;

public class ArrayCopy {
    //编写一个main方法
    public static void main(String[] args) {

        //将 int[] arr1 = {10,20,30}; 拷贝到 arr2数组,
        //要求数据空间是独立的.

        int[] arr1 = {10,20,30};

        //创建一个新的数组arr2,开辟新的数据空间
        //大小 arr1.length;
        int[] arr2 = new int[arr1.length];

        //遍历 arr1 ，把每个元素拷贝到arr2对应的元素位置
        for(int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }

        //修改 arr2， 不会对arr1有影响.
        arr2[0] = 100;

        //输出arr1
        System.out.println("====arr1的元素====");
        for(int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);//10,20,30
        }

        //
        System.out.println("====arr2的元素====");
        for(int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);//
        }

    }
}

1.4数组反转

要求：把数组的元素内容反转。

方式 1：通过找规律反转 【思路分析】

ackage com.company.wq.one;

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
        }
    }
}

方式 2：使用逆序赋值方式

package com.company.wq.one;

public class ArrayReverse02 {
    //编写一个main方法
    public static void main(String[] args) {

        //定义数组
        int[] arr = {11, 22, 33, 44, 55, 66};
        //使用逆序赋值方式
        //思路
        //1. 先创建一个新的数组 arr2 ,大小 arr.length
        //2. 逆序遍历 arr ,将 每个元素拷贝到 arr2的元素中(顺序拷贝)
        //3. 建议增加一个循环变量 j -> 0 -> 5
        int[] arr2 = new int[arr.length];
        //逆序遍历 arr
        for(int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
            arr2[j] = arr[i];
        }
        //4. 当for循环结束，arr2就是一个逆序的数组 {66, 55, 44,33, 22, 11}
        //5. 让 arr 指向 arr2数据空间, 此时 arr原来的数据空间就没有变量引用
        //   会被当做垃圾，销毁
        arr = arr2;
        System.out.println("====arr的元素情况=====");
        //6. 输出 arr 看看
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }

    }
}

2.排序

2.1冒泡排序法

package com.company.wq.one;

public class BubbleSort {
    //编写一个main方法
    public static void main(String[] args) {

        // 化繁为简，先死后活
        //
        //



      /*
         数组 [24,69,80,57,13]
         第1轮排序: 目标把最大数放在最后
         第1次比较[24,69,80,57,13]
         第2次比较[24,69,80,57,13]
         第3次比较[24,69,57,80,13]
         第4次比较[24,69,57,13,80]

       */
        int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110};
        int temp = 0; //用于辅助交换的变量

        //将多轮排序使用外层循环包括起来即可
        //先死后活 =》 4就是 arr.length - 1
        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");
            }

        }

        // for( int j = 0; j < 4; j++) {//4次比较
        //     //如果前面的数>后面的数，就交换
        //     if(arr[j] > arr[j + 1]) {
        //        temp = arr[j];
        //        arr[j] = arr[j+1];
        //        arr[j+1] = temp;
        //     }
        // }

        // System.out.println("==第1轮==");
        // for(int j = 0; j < arr.length; j++) {
        //     System.out.print(arr[j] + "\t");
        // }
        // /*
        // 第2轮排序: 目标把第二大数放在倒数第二位置
        // 第1次比较[24,69,57,13,80]
        // 第2次比较[24,57,69,13,80]
        // 第3次比较[24,57,13,69,80]
        //  */

        // for( int j = 0; j < 3; j++) {//3次比较
        //     //如果前面的数>后面的数，就交换
        //     if(arr[j] > arr[j + 1]) {
        //        temp = arr[j];
        //        arr[j] = arr[j+1];
        //        arr[j+1] = temp;
        //     }
        // }

        // System.out.println("\n==第2轮==");
        // for(int j = 0; j < arr.length; j++) {
        //     System.out.print(arr[j] + "\t");
        // }


        // 第3轮排序: 目标把第3大数放在倒数第3位置
        // 第1次比较[24,57,13,69,80]
        // 第2次比较[24,13,57,69,80]


        // for( int j = 0; j < 2; j++) {//2次比较
        //     //如果前面的数>后面的数，就交换
        //     if(arr[j] > arr[j + 1]) {
        //        temp = arr[j];
        //        arr[j] = arr[j+1];
        //        arr[j+1] = temp;
        //     }
        // }

        // System.out.println("\n==第3轮==");
        // for(int j = 0; j < arr.length; j++) {
        //     System.out.print(arr[j] + "\t");
        // }

        // /*
        // 第4轮排序: 目标把第4大数放在倒数第4位置
        // 第1次比较[13,24,57,69,80]
        //  */

        // for( int j = 0; j < 1; j++) {//1次比较
        //     //如果前面的数>后面的数，就交换
        //     if(arr[j] > arr[j + 1]) {
        //        temp = arr[j];
        //        arr[j] = arr[j+1];
        //        arr[j+1] = temp;
        //     }
        // }

        // System.out.println("\n==第4轮==");
        // for(int j = 0; j < arr.length; j++) {
        //     System.out.print(arr[j] + "\t");
        // }

    }
}

3.查找

顺序查找 SeqSearch.java

有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否

包含此名称【顺序查找】要求: 如果找到了，就提示找到，并给出下标值。


import java.util.Scanner;
public class SeqSearch { 
//编写一个main方法
public static void main(String[] args) {
	/*
	有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：
	从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】 
	要求: 如果找到了，就提示找到，并给出下标值

	思路分析
	1. 定义一个字符串数组
	2. 接收用户输入, 遍历数组，逐一比较，如果有，则提示信息，并退出
	 */
	
	//定义一个字符串数组
	String[] names = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
	Scanner myScanner = new Scanner(System.in); 

	System.out.println("请输入名字");
	String findName = myScanner.next();

	//遍历数组，逐一比较，如果有，则提示信息，并退出
	//这里老师给大家一个编程思想/技巧, 一个经典的方法
	int index = -1;
	for(int i = 0; i < names.length; i++) {
		//比较 字符串比较 equals, 如果要找到名字就是当前元素
		if(findName.equals(names[i])) {
			System.out.println("恭喜你找到 " + findName);
			System.out.println("下标为= " + i);
			//把i 保存到 index
			index = i;
			break;//退出 
		} 
	}

	if(index == -1) { //没有找到
		System.out.println("sorry ,没有找到 " + findName);
	}

}
}

二.二维数组

1.1

看一个需求：动态创建下面二维数组，并输出

i = 0: 1

i = 1: 2 2

i = 2: 3 3 3

一个有三个一维数组, 每个一维数组的元素是不一样的

public class TwoDimensionalArray03 { 
//编写一个main方法
public static void main(String[] args) {

	/*
	看一个需求：动态创建下面二维数组，并输出
	
	 i = 0:	1		
	 i = 1:	2	2	
	 i = 2:	3	3	3

	 一个有三个一维数组, 每个一维数组的元素是不一样的
	 */
	
	//创建 二维数组，一个有3个一维数组，但是每个一维数组还没有开数据空间
	int[][] arr = new int[3][]; 
	
	for(int i = 0; i < arr.length; i++) {//遍历arr每个一维数组
		//给每个一维数组开空间 new
		//如果没有给一维数组 new ,那么 arr[i]就是null
		arr[i] = new int[i + 1]; 

		//遍历一维数组，并给一维数组的每个元素赋值
		for(int j = 0;  j < arr[i].length; j++) {
			arr[i][j] = i + 1;//赋值
		}

	}

	System.out.println("=====arr元素=====");
	//遍历arr输出
	for(int i = 0; i < arr.length; i++) {
		//输出arr的每个一维数组
		for(int j = 0; j < arr[i].length; j++) {
			System.out.print(arr[i][j] + " ");
		}
		System.out.println();//换行
	}

}
}

1.2二维数组的应用案例

使用二维数组打印一个 10 行杨辉三角

public class YangHui { 
//编写一个main方法
public static void main(String[] args) {
	/*
	使用二维数组打印一个 10 行杨辉三角
	1
	1 1
	1 2 1
	1 3 3  1
	1 4 6  4  1
	1 5 10 10 5 1

	规律
	 1.第一行有 1 个元素, 第 n 行有 n 个元素
	 2. 每一行的第一个元素和最后一个元素都是 1
	 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j] 
	  arr[i][j]  =  arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律

	 */
	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();//换行.
	}
	
}
}

++) {//遍历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();//换行.
}

}
}

oh Yes

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
数组的简单应用

1.1数组应用案例请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标1.2数组赋值机制看一个案例，并分析数组赋值的内存图(重点, 难点. )。1.3数组拷贝将 int[] arr1 = {10,20,30};拷贝到 arr2 数组, 要求数据空间是独立的1.4数组反转要求：把数组的元素内容反转。【思路分析】方式 2：使用逆序赋值方式2.排序2.1冒泡排序法3.查找顺序查找 SeqSearch.java。
复制链接

扫一扫