Java尚硅谷基础笔记-day4数组-数组常见算法

最新推荐文章于 2022-07-05 16:12:58 发布
最新推荐文章于 2022-07-05 16:12:58 发布
阅读量451 收藏 7
点赞数 3
分类专栏： java笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alyja/article/details/106975902
版权

第三章 数组

3.1 数组的概述
3.2 一维数组的使用
3.3 多维数组的使用
3.4 数组中涉及的常见算法
3.5 数组工具类的使用
3.6 数组使用中的常见异常

3.4 数组中涉及的常见算法

在这里插入图片描述
3.4.1数组元素的赋值

练习1：杨辉三角
使用二维数组打印一个 10 行杨辉三角
在这里插入图片描述
【提示】

  1. 第一行有 1 个元素, 第 n 行有 n 个元素
  2. 每一行的第一个元素和最后一个元素都是 1
  3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
    yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
public class arrayTest {
	public static void main(String[] args) {
		int[][] yanghui=new int[10][];
		for(int i=0;i<yanghui.length;i++) {
			yanghui[i]=new int[i+1];
			yanghui[i][0]=1;
			yanghui[i][i]=1;
			for(int j=1;j<yanghui[i].length-1;j++) {
				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]+" ");//不换行输出
			}
			System.out.println( );
		}
	}	
}

练习二：回形数

import java.util.Scanner;

public class arrayTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个数字");
		int len = scanner.nextInt();
		int[][] arr = new int[len][len];
		int maxX=arr.length-1;
		int maxY=arr.length-1;
		int minX=0;
		int minY=0;
		int count=1;
		while(minX<maxX) {
			for(int x=minX;x<=maxX;x++) {
				arr[minY][x]=count++;
			}
			minY++;
			for(int y=minY;y<=maxY;y++) {
				arr[y][maxX]=count++;
			}
			maxX--;
			for(int x=maxX;x>=minX;x--) {
				arr[maxY][x]=count++;
			}
			maxY--;
			for(int y=maxY;y>=minY;y--) {
				arr[y][minX]=count++;
			}
			minX++;
		}
		// 遍历
		for (int m = 0; m < arr.length; m++) {
			for (int n = 0; n < arr[m].length; n++) {
				System.out.print(arr[m][n] + "\t");
			}
			System.out.println();
		}	
	}	
}

3.4.2 数组元素得最大值，最小值，平均值和总和

练习1：定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值， 最小值，和值， 平均值， 并输出出来。
要求： 所有随机数都是两位数。

int[]arr=new int[10];
for(int i=0;i<arr.length;i++) {
	arr[i]=(int)(Math.random()*90+10);
}
for(int i=0;i<arr.length;i++) {
	System.out.println(arr[i]);
}
int max=arr[0];
int min=arr[0];
int sum=0;
for(int i=0;i<arr.length;i++) {
	sum+=arr[i];
	if(arr[i]>max) {
		max=arr[i];
	}
	if(arr[i]<max) {
		max=arr[i];
	}
}
double avg=sum/arr.length;
System.out.println(max);
System.out.println(min);
System.out.println(sum);
System.out.println(avg);

3.4.3 数组的复制，反转和查找
数组的复制

//1.错误的复制 arr1=arr2 赋值
int[]arr1=new int[] {1,2,3,4,5,6};
int[]arr2=new int[6];
for(int i=0;i<arr1.length;i++) {
	System.out.print(arr1[i]+"\t");
}
System.out.println( );
arr2=arr1;
for(int i=0;i<arr2.length;i++) {
	if (i%2==0) {
		arr2[i]=0;
	}
}
for(int i=0;i<arr1.length;i++) {
	System.out.print(arr1[i]+"\t");
}
//输出：1	2	3	4	5	6	
//输出：0	2	0	4	0	6	
//改变arr2值，可以改变arr1，这是因为arr2和arr1指向同一个地址

将arr1保存的数组地址值赋给了arr2，使得arr1和arr2共同指向堆空间中的同一个数组实体
在这里插入图片描述

//数组的复制
int[] arr1, arr2;
arr1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
//复制array1数组给array2
arr2 = new int[arr1.length];
for(int i=0;i<arr2.length;i++) {
	arr2[i]=arr1[i];
}

通过new的方式，给arr2在堆空间中新开辟了数组的空间。将arr1数组中的元素一个一个赋值到arr2数组中
在这里插入图片描述
数组的反转

//方法一
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
for(int i=0;i<arr1.length/2;i++) {
	String temp=arr1[i];
	arr1[i]=arr1[arr1.length-1-i];
	arr1[arr1.length-1-i]=temp;
}
for(int i=0;i<arr1.length;i++) {
	System.out.print(arr1[i]+"\t");
}
//方法二:
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
for(int i=0,j=arr1.length-1;i<j;i++,j--) {
	String temp=arr1[i];
	arr1[i]=arr1[j];
	arr1[j]=temp;
}

数组的查找

线性查找
方式一

//线性查找
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
String dest="bb";
boolean isFlag=true;
for(int i=0;i<arr1.length;i++) {
	if(arr1[i].equals(dest)) {
		System.out.print("找到了指定元素，位置为："+i);
		isFlag=false;
		break;
	}
}
if(isFlag) {
	System.out.print("没有找到");
}

方式二

//线性查找
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
String dest="bb";
int i;
for(int i=0;i<arr1.length;i++) {
	if(arr1[i].equals(dest)) {
		System.out.print("找到了指定元素，位置为："+i);
		break;
	}
}
if(i==arr1.length) {
	System.out.print("没有找到");
}

二分法：判断区间依次减半
前提：数组有序

int[]arr1=new int[] {-2,4,8,23,35,45,55,67,87,98};
int dest=55;
boolean isFlag=true;
int start=0;
int end=arr1.length-1;	
while(start<=end) {
	int mid=(start+end)/2;
	if(dest==arr1[mid]) {
		System.out.print("找到了指定元素，位置为："+mid);
		isFlag=false;
		break;
	}else if(dest<arr1[mid]) {
		end=mid-1;
	}else {
		start=mid+1;
	}
}
if(isFlag) {
	System.out.print("没有找到");
}

3.4.4 数组的排序
排序算法
衡量排序算法的优劣：1.时间复杂度2.空间复杂度 3.稳定性
十大排序算法：
选择排序：直接选择排序，堆排序
交换排序：冒泡排序，快速排序
插入排序：直接插入排序，折半插入排序，Shell排序
归并排序
桶式排序
基数排序
冒泡排序
时间复杂度： O(n^2)
排序思想：

  1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步
    做完后，最后的元素会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要
    比较为止。
int[]arr1=new int[] {-2,56,8,2,35,30,55,67,124,98};
	for(int i=1;i<arr1.length-1;i++) {
		for(int j=0;j<arr1.length-i;j++) {
			if(arr1[j]>arr1[j+1]) {
				int temp=arr1[j];
				arr1[j]=arr1[j+1];
				arr1[j+1]=temp;
			}
		}
	}
for(int i=0;i<arr1.length;i++) {
	System.out.print(arr1[i]+"\t");
}

快速排序
时间复杂度： O(nlogn）
排序思想：

  1. 从数列中挑出一个元素，称为"基准"（pivot），
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准
    值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，
    该基准就处于数列的中间位置。这个称为分区（partition）操作。
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数
    列排序。
  4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好
    了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代
    （iteration）中，它至少会把一个元素摆到它最后的位置去。
public class arrayTest {
	public  static void main(String[] args) {
		int[]arr1=new int[] {20,80,14,-2,56,8,2,35,20,30,10,67};	
		int low=0;
		int high=arr1.length-1;
		Quick_short(arr1,low,high);
		for(int i=0;i<arr1.length;i++) {
			System.out.print(arr1[i]+"\t");
		}
    }
	 //进行分区，大于arr[pivot]的在右边，小于其的在左边
	public static int partition(int[] arr, int low, int high) {		
		int pivot=low;
		int temp=arr[pivot];
		while(low<high) {
			while(low<high&&arr[high]>temp) {//如果右边的值一直比temp大，则high一直往中间推。当<=时，暂停
				high--;}
			//暂停之后将值赋给arr[low]，开始从左边继续看
			if(low<high) {arr[low]=arr[high];low++;}
			while(low<high&&arr[low]<temp) {//如果左边的值一直比temp小，则low一直往中间推。当>=时，暂停
				low++;
			}
			//暂停之后将值赋给arr[high]，开始从右边继续看
			if(low<high) {arr[high]=arr[low];high--;}		
		}
		//退出循环：low=high，交换low所在位置和pivot的值，并且返回此时low的值
		arr[low]=temp;
		return low;//返回arr[pivot]所在位置	
	 }
	 //递归过程
	public static int[] Quick_short(int[] arr,int s,int t) {
		if(s<t) {
			int i=partition(arr,s,t);
			Quick_short(arr,i+1,t);
			Quick_short(arr,s,i-1);
			
		}
		return arr;		
	}
}

分区部分的图解过程：
在这里插入图片描述
堆排序
堆排序（Heapsort） 是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。（大于或等于：大顶堆，小于或等于：小顶堆）
算法描述（大顶堆）：
int arr=new int[]{30,60,8,40,70,12,10}
步骤1：将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
在这里插入图片描述
步骤2：将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
步骤3：无序区(R1,R2,……Rn-1)重新建堆。然后再次将R[1]与Rn-1交换，再将(R1,R2….Rn-2)重新建堆。不断重复此过程，直到重新建堆元素为一个。

在这里插入图片描述

归并排序
将已有序的子序列合并，得到完全有序的序列；即先使用每个子序列有序，再使得子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
算法描述：
步骤1：把长度为n的输入序列分成两个长度为n/2的子序列；
步骤2：对这两个子序列分别采用归并排序；
步骤3：将两个排序好的子序列合并成一个最终的排序序列。
在这里插入图片描述

alyja
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
03-python-numpy-简介-基础-数组-数组类型
02-09
这篇学习笔记将深入探讨NumPy的基础知识，包括其简介、数组概念以及数组类型。 首先，我们来看一下NumPy的简介。NumPy（Numerical Python）是一个开源库，它提供了一个强大的N维数组对象，还包含了一些用于处理数组...
尚硅谷—初级—数组，算法（161~171）
张老师的博客
04-24 188
https://www.bilibili.com/video/BV1Kb411W75N?p=163 数组中常见的 算法： 1）数组元素的赋值（杨辉三角，回型数等） 2）求 数值型数组中元素的（最大值，最小值，平均值，总和等） 3）数组的 创建，复制，反转，查找（线性查找，二分查找） 4）数组元素的 排序算法（） 4）互相转换 （数组-&g...
java中常用的数组工具类
qq_47888755的博客
03-14 614
在java编程中，有一些针对数组的操作需要经常使用，但是系统又不提供现成的让用户可以直接调用。所以，总是需要用户进行手写。 在这里，对于java编程中经常用到的一些数组操作，进行了总结，并封装进一个自定义数组工具类中： 主要包含的操作有： 求数组元素的最大值、最小值、和、平均值 反转数组 对数组进行排序（冒泡排序） 遍历数组 在数组中查找指定元素（线性查找） 具体的代码实现如下： /* * 自定义数组的工具类 * */ public class ArrayUtil { // 求数组的最大值
手写工具类随便
weixin_30491641的博客
07-16 177
方法类： package com.example.learn.Student; public class ArrayUtil { // 求数值的最大值 public int getMax(int[] arr) { int maxValue = arr[0]; for (int i = 1; i < arr.length; i...
打印杨辉三角
qq_43610925的博客
03-17 92
题目： 使用二维数组打印一个10行的杨辉三角 1.第一行有1个元素，第n行有n个元素 2.每一行的第一个元素和最后一个元素都是1 3.从第三行开始，对于非第一个元素和最后一个元素的元素。 即： yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j]; 考察二维数组的使用 代码实现： ...
JAVA基础——数组
m0_53586574的博客
08-17 335
一、数组概述 1.数组的理解：数组（Array），是多个相同类型数据按一定顺序排列的集合。使用一个名字命名 ,并通过编号的方式对这些数据进行统一管理。 2.数组相关的概念 ①数组名 ②元素 ③角标 、下标、索引 ④数组的长度：存储元素的个数 3.数组的特点： ①数组是有序排列的。 ②数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 ③创建数组对象会在内存中开辟一整块连续的空间。 ④数组长度一旦确定就不可以去修改。 4. 数组的分类：...
Java-笔记-数组和排序-全
04-19
Java-笔记-数组和排序-全
尚硅谷JAVA基础笔记吐血整理
02-03
“尚硅谷JAVA基础笔记”涵盖了Java语言的基础知识，包括语言概述、基本语法、面向对象概念、封装、继承和多态，以及一些关键概念如形参与实参、属性与局部变量、构造器、this关键字、包和MVC设计模式的使用。...
Java 面对对象思想。自定义数组工具包：获取数组最大值、最小值、总和、平均值、复制数组、反转数组
qq_51369065的博客
09-13 304
工具类代码如下： public class ArrayUtils { public int getMax(int []arr) { //获取最大值 int max = 0; for (int i = 0; i < arr.length; i++) { if(max<arr[i]) { max = arr[i]; } } return ma.
Leetcode118.杨辉三角
qq_43753862的博客
08-03 189
给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。 在「杨辉三角」中，每个数是它左上方和右上方的数的和。 示例 1: 输入: numRows = 5 输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]] 示例 2: 输入: numRows = 1 输出: [[1]] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/pascals-triangle 著作权归领扣网络所有。商业转载请联系官方
java练习案例--定义数组工具类
小库里的学习记录
07-05 1452
利用简单案例学习定义与调用数组工具类---java
Java尚硅谷基础笔记-day12集合
alyja的博客
07-18 1693
第十一章 集合Java集合框架概述Collection接口方法Ilterator迭代器接口Collection子接口一：ListCollection子接口一：SetMap接口Collections工具类 Java集合框架概述 集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中） 2.1 数组在存储多个数据方面的特点： 一旦初始化以后，其长度就确定了。 数组一旦定义好，其元素的类型也就确定了
Java尚硅谷基础笔记-day10Java常用类
alyja的博客
07-15 834
第九章 Java常用类9.1 字符串相关的类9.2 JDK8之前的日期时间API9.3 JDK8中新日期时间API9.4 Java比较器9.5 System类9.6 Math类9.7 BigInteger与BigDecimal 9.1 字符串相关的类 String特性 String:字符串，使用一对""引起来表示。 1.String声明为final的，不可被继承 2.String实现了Serializable接口：表示字符串是支持序列化的。 实现了Comparable接口：表示String可以比较大小 3.
Java尚硅谷基础笔记-day11枚举类与注解
alyja的博客
07-18 772
第十章 枚举类与注解10.1 枚举类的使用10.2 注解(Annotation)的使用 10.1 枚举类的使用 一、枚举类的使用 1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类 2.当需要定义一组常量时，强烈建议使用枚举类 3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式。 二、如何定义枚举类 方式一：jdk5.0之前，自定义枚举类 方式二：jdk5.0，可以使用enum关键字定义枚举类 自定义枚举类 属性：private final 对象：private static fina
Java尚硅谷基础笔记-day14 IO流
alyja的博客
07-22 715
第十三章 IO流File类的使用IO流原理及流的分类节点流缓冲流转换流标准输入、输出流打印流数据流对象流随机存取文件流NIO.2中Path、Paths，Files类的使用 File类的使用 IO流原理及流的分类 节点流 缓冲流 转换流 标准输入、输出流 打印流 数据流 对象流 随机存取文件流 NIO.2中Path、Paths，Files类的使用 ...
Java尚硅谷基础笔记-day17 java8新特性
alyja的博客
07-23 688
第十五章 java8新特性Lambda表达式函数式（Functional）接口方法引用与构造器引用强大的Stream APIOptional类 Lambda表达式 Lambda表达式的使用 1.举例： (o1,o2) -> Integer.compare(o1,o2); 2.格式： -> :lambda操作符 或 箭头操作符 ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表） ->右边：lambda体 （其实就是重写的抽象方法的方法体） 3. Lambda表达式的
Java尚硅谷基础笔记-day5面向对象（一）
alyja的博客
06-30 606
第四章 面向对象（一）4.1 面向过程与面向对象4.2 Java基本元素：类和对象4.3 对象的创建和使用4.4 类的成员之一：属性4.5 类的成员之二：方法4.6 OOP特征一：封装和隐藏4.7 类的成员之三：构造器4.8 关键字：this4.9 关键字：package，import 学习面向对象的三条主线： 1.Java类及类的成员：属性，方法，构造器，代码块，内部类 2.面向对象的三大特征：封装性，继承性，多态性，（抽象性） 3.其它关键字：this，super，final 4.1 面向过程与面向对象
Python笔记6----数组
最新发布
06-11
好的，我会为你介绍Python中的数组。 在Python中，数组是一种存储元素的数据结构。与列表不同，数组是固定大小的，且元素类型必须相同。 要使用数组，需要先导入array模块。下面是一个创建数组的示例： ```python import array as arr # 创建一个整数类型的数组 a = arr.array('i', [1, 2, 3, 4, 5]) # 打印数组 print(a) ``` 在上面的示例中，我们使用了`array`模块创建了一个整数类型的数组，并初始化了它。要注意的是，第一个参数是一个字符，用于指定数组元素的类型。在本例中，我们使用了`i`，表示整数类型。 除了整数类型之外，还有其他类型可以使用，如`f`表示浮点数，`d`表示双精度浮点数，`b`表示布尔类型等。 在数组中，可以使用索引来访问元素，如下所示： ```python import array as arr # 创建一个整数类型的数组 a = arr.array('i', [1, 2, 3, 4, 5]) # 访问数组中的第一个元素 print(a[0]) # 修改数组中的第二个元素 a[1] = 6 # 打印数组 print(a) ``` 在上面的示例中，我们使用了索引`0`来访问数组中的第一个元素，使用索引`1`来修改数组中的第二个元素。 除了使用索引来访问和修改元素外，还可以使用循环来遍历数组中的所有元素，如下所示： ```python import array as arr # 创建一个整数类型的数组 a = arr.array('i', [1, 2, 3, 4, 5]) # 遍历数组中的所有元素 for i in a: print(i) ``` 在上面的示例中，我们使用了`for`循环来遍历数组中的所有元素，并打印每个元素的值。 这就是Python中数组的基本用法。希望对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值