java基础 day14 数组 二维数组 冒泡排序 例题（正则表达式）

最新推荐文章于 2022-09-08 19:42:07 发布
最新推荐文章于 2022-09-08 19:42:07 发布
阅读量373 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21694049/article/details/102922641
版权

数组：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
数组静态初始化及遍历

package wwl.array;

import java.util.Arrays;
/**
 * 数组的静态初始化及数组遍历
 *
 */
public class Test04 {

	public static void main(String[] args) {
//		定义数组，存储10个double类型数据
		double [] data = new double[10];
		//给元素赋值：
		data[0] = 3.11;
		data[4] = 78.11;
		data[8] = 88.99;
		//通过for循环遍历打印数组的每个元素
		for (int i = 0; i < data.length; i++) {
			System.out.println(data[i]);
		}
		/*
		 * 定义数组，数组会给元素进行默认初始化
		 * 整数数组为0
		 * 小数数组0.0
		 * 布尔类型 false
		 * char \u0000
		 * 引用类型 null
		 */
		//如果在定义数组的时候已经知道数组元素的值，可以在定义数组的同时给数组元素赋值。叫数组的静态初始化
		//数组静态初始化时，不需要指定数组长度，数组的长度由数组初始化元素个数决定
		int [] data2 = new int [] {34, 65 ,123 ,78 ,66};
		
//		遍历元素时，还可以使用增强的for循环，也叫foreach循环
		for (int xx : data2) {
//			依次把data2数组的每个元素赋值给局部变量xx
			System.out.print(xx + "\t");
		}
		System.out.println();
		
		//数组名的相互赋值：
		int[] data3 = data2; //把data2的值赋值给data3，data2的值是一个数组的引用（起始地址）
		//现在data3与data2保存了同一个数组的引用，data2//data3指向了堆中同一个数组
		//data3数组的元素打印
		for (int yy : data3) {
			System.out.print( yy + "\t");
		}
		System.out.println();
		data3[0] = 666;
		//打印data2数组元素；
		
		//java.util.Arrays中toString()方法可以把数组的元素转化为字符串
		System.out.print(Arrays.toString(data2));
	}

}

数组是引用数据类型
在这里插入图片描述

可变长参数：

在这里插入图片描述

package wwl.array;
/**
 * 演示可变长参数
 *
 */
public class Test07 {

	public static void main(String[] args) {
		//再调用方法时可以传递任意整数,也可以传任意数组
		sum();
		sum(1);
		sum(1,2);
		sum(1,2,3,4,5,6,7,8,9,10);
		int [] data = {56,34,76,34,786,32,78};
		sum(data);
	}
	//定义一个方法，可以计算任意个整数的和
	public static void sum( int ... data) {
		//******在方法体中，把可变长参数当作数组使用
		int sum = 0;
		for (int xx : data) {
			sum += xx;
		}
		System.out.println("sum = " + sum);
	}
}

插入元素

package wwl.array;

import java.util.Arrays;

/**
 * 在数组中插入元素分析分析！
 *
 */
public class Test09 {

	public static void main(String[] args) {
		//数组的静态初始化
		int [] data = {21,34,65,87,90,123};
		//需求在索引值为2的位置插入一个数组456
		int [] newdata = new int[data.length + 1];
		for(int i = 0; i< 2 ; i++) {
			newdata[i] = data[i];
		}
		newdata[2] = 456;
		for(int i = 2; i<data.length;i++) {
			newdata[i+1] = data[i];
		}
		data = newdata;
		System.out.println(Arrays.toString(data));
	}

}
数组本质上就是堆中一块连续的存储空间

数组扩容：

package wwl.array;

import java.util.Arrays;

/**
 * 数组的扩容
 *
 */
public class test01 {

	public static void main(String[] args) {
//		定义数组直接赋值
		m1();//完全手动扩容
		m2();//调用System.arrayCopy实现数组元素的复制
		m3();//调用Arrays工具类的copyof()方法，以后方便直接使用
	}

	private static void m1() {
		int [] data = {1,2,3,4,5,6,7};
		//1.定义更大的数组
		int [] NewData = new int[data.length * 2];//按2倍大小扩容
		//2.把原来数组的内容复制到新数组中
		for (int i = 0; i < data.length; i++) {
			NewData[i] = data[i];
		}
		//3.让原来的数组指向新的数组：
		data = NewData;
		System.out.println(Arrays.toString(data));
	}
	private static void m2() {
		int [] data = {1,2,3,4,5,6,7};
		//1.定义更大的数组
		int [] NewData = new int[data.length * 2];//按2倍大小扩容
		//2.把原来数组的内容复制到新数组中
		//把src数组从srcPos开始的length个元素复制到dest数组的destPos位置
//		System.arraycopy(src, srcPos, dest, destPos, length);
		System.arraycopy(data, 0, NewData, 0, data.length);
		/*
		 * 该方法使用native修饰，没有方法体
		 * JNI（Java Native Interface）可以在Java中调用其它语言编写的代码！！
		 */
		//3.让原来的数组指向新的数组：
		data = NewData;
		System.out.println(Arrays.toString(data));
	}
	private static void m3() {
 		int [] data = {1,2,3,4,5,6,7};
		//Arrays.copyof(原来的数组，新的数组长度)---->实现数组的扩容
		data = Arrays.copyOf(data, data.length * 2);//主要扩容方法！
		System.out.println(Arrays.toString(data));
	}

}

tip: data = newData:
由于数组是引用数据类型，传递的是内存使用权，是一块内存空间，它可以由多个单位同时使用。而” = “并不是赋值而是把a数组的使用权与b共享。

数组的特点：

在这里插入图片描述

定义一个方法删除数组中指定的元素：

具体：
static是属于类的，非static是属于对象。static方法可以通过类名访问，也可以通过类的实例访问。static方法不能访问类中非static的数据。主要区别就是有了static可以直接类名点方法调用或直接调用方法。没有的话则必须创建对象调用！

package wwl.array;

import java.util.Arrays;

/**
 * 定义一个方法，实现数组元素的删除
 * @param data
 * @param i
 */
public class Test02 {

	public static void main(String[] args) {
		int [] data = {1,2,3,4,5,6,7};
		data = delete(data,3);
		System.out.println(Arrays.toString(data)); 
	}
	//定义方法，删除数组中指定元素，删除data数组中第i个元素
		public static int[] delete(int [] data,int i) {
			//1.定义较小的数组：
			int[] newDAta = new int[data.length-1];
			//2.把[0,1) 范围的元素复制到新数组中
			for(int x = 0;x < i;x++) {
				newDAta[x] = data[x];
			}
			//3.把[i+1,data.length)范围的元素复制到新数组[i,data.length-1中)
			for(int x = i+1;x < data.length;x++) {
				newDAta[x-1] = data[x];
			}
			//4.把新的数组返回
			return newDAta;
			//形参data = newDAta;不是实参
			//System.out.println(Arrays.toString(data));
		}
		
}
对象数组：

在这里插入图片描述在这里插入图片描述
购物车例子：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二维数组在这里插入图片描述

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

Arrays工具类：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

对象数组排序：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

冒泡排序分析：

在这里插入图片描述
最基本：

package wwl.array;

import java.util.Arrays;

public class arraymaopaopaixu {

	public static void main(String[] args) {
		int [] data = {21,34,65,8,90,12};
		System.out.println(Arrays.toString(data));
		System.out.println("------------------------------------------");
		//第一轮：
		for (int i = 0; i < data.length - 1; i++) {
			if (data[i] > data[i+1]) {
				int t = data[i+1];
				data[i+1] = data[i];
				data[i] = t;
			}
			System.out.println(Arrays.toString(data));
		}
		System.out.println("------------------------------------------");
		//第二轮：
		for (int i = 0; i < data.length - 2; i++) {
			if (data[i] > data[i+1]) {
				int t = data[i+1];
				data[i+1] = data[i];
				data[i] = t;
			}
			System.out.println(Arrays.toString(data));
		}
		System.out.println("------------------------------------------");
		//第三轮：
		for (int i = 0; i < data.length - 3; i++) {
			if (data[i] > data[i+1]) {
				int t = data[i+1];
				data[i+1] = data[i];
				data[i] = t;
			}
			System.out.println(Arrays.toString(data));
		}
		System.out.println("------------------------------------------");
		//第四轮：
		for (int i = 0; i < data.length - 4; i++) {
			if (data[i] > data[i+1]) {
				int t = data[i+1];
				data[i+1] = data[i];
				data[i] = t;
			}
			System.out.println(Arrays.toString(data));
		}
		System.out.println("------------------------------------------");
		//第五轮：
		for (int i = 0; i < data.length - 5; i++) {
			if (data[i] > data[i+1]) {
				int t = data[i+1];
				data[i+1] = data[i];
				data[i] = t;
			}
			System.out.println(Arrays.toString(data));
		}
		System.out.println("------------------------------------------");
	}

}

运行结果：

[21, 34, 65, 8, 90, 12]
------------------------------------------
[21, 34, 65, 8, 90, 12]
[21, 34, 65, 8, 90, 12]
[21, 34, 8, 65, 90, 12]
[21, 34, 8, 65, 90, 12]
[21, 34, 8, 65, 12, 90]
------------------------------------------
[21, 34, 8, 65, 12, 90]
[21, 8, 34, 65, 12, 90]
[21, 8, 34, 65, 12, 90]
[21, 8, 34, 12, 65, 90]
------------------------------------------
[8, 21, 34, 12, 65, 90]
[8, 21, 34, 12, 65, 90]
[8, 21, 12, 34, 65, 90]
------------------------------------------
[8, 21, 12, 34, 65, 90]
[8, 12, 21, 34, 65, 90]
------------------------------------------
[8, 12, 21, 34, 65, 90]
------------------------------------------

改进

package wwl.array;
import java.util.Arrays;
/**
 * 改进：冒泡排序从小到大
 */
public class arraymaopaopaixu {

	public static void main(String[] args) {
		int [] data = {21,34,65,8,90,12};
		System.out.println(Arrays.toString(data));
		System.out.println("------------------------------------------");
		//第一轮：
		for(int j = 0;j < data.length-1 ;j++) {
			for (int i = 0; i < data.length - 1 - j; i++) {
				if (data[i] > data[i+1]) {
					int t = data[i+1];
					data[i+1] = data[i];
					data[i] = t;
				}	
				System.out.println(Arrays.toString(data));
			}
			System.out.println("------------------------------------------");
		}
		
	}
}


[21, 34, 65, 8, 90, 12]
------------------------------------------
[21, 34, 65, 8, 90, 12]
[21, 34, 65, 8, 90, 12]
[21, 34, 8, 65, 90, 12]
[21, 34, 8, 65, 90, 12]
[21, 34, 8, 65, 12, 90]
------------------------------------------
[21, 34, 8, 65, 12, 90]
[21, 8, 34, 65, 12, 90]
[21, 8, 34, 65, 12, 90]
[21, 8, 34, 12, 65, 90]
------------------------------------------
[8, 21, 34, 12, 65, 90]
[8, 21, 34, 12, 65, 90]
[8, 21, 12, 34, 65, 90]
------------------------------------------
[8, 21, 12, 34, 65, 90]
[8, 12, 21, 34, 65, 90]
------------------------------------------
[8, 12, 21, 34, 65, 90]
------------------------------------------

由大到小：

data[i] < data[i+1]

Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值
在这里插入图片描述
2.使用方法：
例：

int  num = (int)(Math.random()*2+1)

以上代码即设置一个随机1到3(取不到3)的变量num。
例如：
首先Math.random()*52 //这样我们就能得到一个 >=0 且 <52的数
然后加1：Math.random()*52 + 1 //现在这个数就 >=1 且 <53

【应用场景描述：】
用Math类的random()方法产生一个字符，若该字符是一个大写英文字母，则输入 “Yes!”，否则输出“NO”。
random()方法产生的随机数在0.0和1.0之间，乘以128后，其值在0.0和128.0之间，将它转换为char类型后，用if来判断是否在’A’ 和’Z’之间。

【程序如下：】

public class IsUpper{
public static void main(String [] args){
char ch;
ch = ( char ) ( Math.random() * 128);
if ( ch >= 'A' && ch <= 'Z'){
    System.out.println("Yes!");}else{
        System.out.println("No!");}
}
}

例题：定义一个方法，返回长度为10的整数数组，对数组的元素进行随机初始化100内的正整数，要求数组中的元素不重复

package wwl.array;

import java.util.Arrays;

/**
 * 定义一个方法，返回长度为10的整数数组，对数组的元素进行随机初始化100内的正整数，要求数组中的元素不重复
 *
 */
public class test03 {
	public static void main(String[] args) {
		int [] mydata = getArray();
		System.out.println(Arrays.toString(mydata));//和下边那句一样
		System.out.println(Arrays.toString(getArray()));
	}
	
	public static int[] getArray(){
		int [] data = new int[10];
		for(int i = 0;i < data.length;i++) {
		int xx = (int)(Math.random() * 100 + 1);
		//判断xx是否在 数组中，如果xx在数组中，需要重新生成
		while( exist(data, xx) ) {
			xx = (int)(Math.random() * 100 + 1);
		}
		data[i] = xx;
		
		}
		Arrays.sort(data);//排序
		return data;
	}
	//判断key元素是否在myarray数组中，存在返回true值
	public static boolean exist(int [] myarray,int key) {
		for(int i = 0;i < myarray.length;i++) {
			if(key == myarray[i]) {
				return true;
			}
		}
		return false;
	}
}

练习用户登录

package wwl.array;

/**
 * 测试类
 */
import java.util.Scanner;

import javax.security.auth.x500.X500Principal;

public class test08 {
	static Scanner sc = new Scanner(System.in);
	static UserManager manager = new UserManager();
	public static void main(String[] args) {

		while (true) {
			System.out.println("请选择你的操作");
			System.out.println("\t1.用户操作,2.用户登录,3.退出程序");
			int choise = sc.nextInt();
			switch (choise) {
			case 1:
				register();
				break;
			case 2:
				login();
				break;
			default:
				return;// 直接结束main方法执行；
			}
		}
	}

//用户登录
	private static void login() {
		System.out.println("请输入用户名");
		String username = sc.next();
		System.out.println("请输入密码：");
		String password = sc.next();
		User user = new User();
		user.setUsernameString(username);
		user.setPassword(password);
		if (manager.userExit(user)) {
			System.out.println("登陆成功");
		} else {
			System.out.println("用户名或密码不正确");
		}
	}
	
//用户注册
	private static void register() {
		System.out.println("请输入用户名");
		String username = sc.next();
		// 如果用户名存在，需要重新输入
		while (manager.usernameExist(username)) {
			System.out.println("用户名已存在，需重新输入");
			username = sc.next();
		}
		// 对用户输入进行验证，验证用户名长度必须大于6个字符
		if (username.length() <= 6) {
			System.out.println("用户名长度必须大于6个字符");
			return;
		}
		System.out.println("请输入密码：");
		String password = sc.next();
		// 对密码验证，要求既有字母又有数字，长度大于6
		
//		if (password.length() <= 6) {
//			System.out.println("密码长度必须大于6");
//			return;
//		}
        
		while(!password.matches("(?![0-9]+$)(?![a-zA-Z]+$)\\w{6,}")) {      //正则表达式！！
			System.out.println("密码格式错误");
			return;
		}
		// 创建User对象，设置User用户名和和密码，然后把user添加到数组里
		User user = new User();
		user.setUsernameString(username);
		user.setPassword(password);
		manager.add(user);
		System.out.println("注册成功");
	}
	}

正则表达式：

package wwl.Class;
/**
 * 正则表达式
 * 就是一个模式串，常用于判断字符串是否匹配指定的模式
 * [abc]   匹配abc中的一个，要么是a,要么是b，要么是c
 * .       任意字符
 * \d      数字
 * \s      空白字符
 * \w      单词字符[a-zA-Z0-9]
 * X?      0次或一次
 * X*      任意次
 * X+      至少一次
 * X{n}    正好n次
 * X{n,}   至少n次
 * x{n,m}  至少n次最多m次
 *
 */
public class zhengzebiaoda {

	public static void main(String[] args) {
//		1.matches()判断字符串是否匹配正则表达式格式
		String emailString = "gasd54h@163.com";
		//判断是否为邮箱格式
		String pattern = "\\w{6,}@\\w{2,}\\.(com|net|cn)";
		System.out.println(emailString.matches(pattern));
		
//		2.replaceAll
		String text  = "王123";
		text = text.replaceAll("\\d", "*");
		System.out.println(text);
		
//		3.split()字符串分割
		text = "Good good study,day           day up!";
		//把字符串中的单词分离出来，英文单词之间使用空格，tab，英文标点符号
		String[] words = text.split("[\\s,.!?]+");
		for (String string : words) {
			System.out.println(string);
		}
		text = "name:lisi,age:18;name:angwu,age:20;name:feifei,age:28";
		//把字符串中的人的信息分离出来，创建Person对象，把这三个人的信息保存到数组中
		//创建一个Person类包含姓名年龄两个字段
		//把字符串的信息分离出来，  split("[:,;]");   ---->4个一组
		//Person[] personsss = new Person[3]----->类似前边的一个题
	}

}


package wwl.array;
/**
 * 用户类
 */
public class User {
	 private String usernameString;
	 private String password;
	public String getUsernameString() {
		return usernameString;
	}
	public void setUsernameString(String usernameString) {
		this.usernameString = usernameString;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((password == null) ? 0 : password.hashCode());
		result = prime * result + ((usernameString == null) ? 0 : usernameString.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (password == null) {
			if (other.password != null)
				return false;
		} else if (!password.equals(other.password))
			return false;
		if (usernameString == null) {
			if (other.usernameString != null)
				return false;
		} else if (!usernameString.equals(other.usernameString))
			return false;
		return true;
	}
	
}


package wwl.array;

import java.util.Arrays;

/**
 用户管理类，定义数组保存用户信息，定义add方法向数组添加用户，
 定义一个方法usernameExist(String)判断用户名是否存在。
 定义方法userExit(User)判断用户是否存在。
 *
 */
public class UserManager {
	private User[] usersss;//定义数组保存用户信息
	private int size;//数组中用户的数量
	
	//无参构造对用户数组初始化
	public UserManager() {
		usersss = new User[5];//默认长度为5
	}
	//通过构造方法指定用户初始化的大小,在使用数组中尽量避免频繁扩容
	public UserManager(int capacity) {
		usersss = new User[capacity];
	}
	
	//定义数组保存用户信息，定义add方法向数组添加用户
	public void add(User u) {
		//判断用户数组是否已满,
		if(size >= usersss.length) {
			usersss = Arrays.copyOf(usersss, usersss.length*2);
		}
		usersss[size] = u;
		size++;
	}
	//定义一个方法usernameExist(String)判断用户名是否存在。
	public boolean usernameExist(String username) {
		for(int i = 0;i < size;i++) {
			if(usersss[i].getUsernameString().equals(username)) {
				return true;
			}
		}
		return false;
	}
	
	// 定义方法userExit(User)判断用户是否存在。
	public boolean userExit(User u) {
		for (int i = 0; i < size; i++) {
			if(usersss[i].equals(u)) {
				return true;
			}
		}
		return false;
		
	}
}

选择排序算法：

package wwl.array;

import java.util.Arrays;
/**
 * 选择最小的元素交换到前面
 * 选择法排序，与冒泡排序相比交换次数减少！
 */
public class arraychoose {

	public static void main(String[] args) {
		int [] data = {21,34,65,8,90,12};
		System.out.println(Arrays.toString(data));
		System.out.println("------------------------------------------");
		
		//找数组最小的元素交换到0位置：
		for(int x = 0; x < data.length-1; x++) {
			int min = x;
			for (int i = min + 1; i < data.length; i++) {
				if(data[i] < data[min]) {
					min = i;
				}
			}
			//把min元素交换到0位置
			if(min != x) {
				int t = data[x];
				data[x] = data[min];
				data[min] = t;
			System.out.println(Arrays.toString(data));
			System.out.println("------------------------------------------");
			}
		}
		
//		//找数组第二小的元素交换到1位置：
//		min = 1;
//		for (int i = min + 1; i < data.length; i++) {
//			if(data[i] < data[min]) {
//				min = i;
//			}
//		}
//		//把min元素交换到0位置
//		t = data[1];
//		data[1] = data[min];
//		data[min] = t;
//		System.out.println(Arrays.toString(data));
//		System.out.println("------------------------------------------");
	}
		//。。。。。。。。。。。。。。。。第三第四第五等一样的操作
}

在这里插入图片描述
二分查找
在这里插入图片描述

package wwl.array;
/**
 * 二分查找（折半查找）
 * 二分查找的前提是数组由小到大排序
 *
 */
public class Test05 {

	public static void main(String[] args) {
		int [] data = {8,12,21,34,65,90};
		
		int index = binarysearch(data, 21);
		System.out.println( index );
		System.out.println(binarysearch(data, 8));
		System.out.println(binarysearch(data, 90));
		System.out.println(binarysearch(data, 100));
		System.out.println(binarysearch(data, 5));
	}
	//在data数组中采用二分查找法，返回key元素在数组中的索引值，如果数组中不存在该元素返回-1

	private static int binarysearch(int[] data, int key) {
		int begin = 0;
		int end = data.length - 1;//小心越界
		int mid = (begin + end)/2;
		while(begin <= end) {
			if(data[mid] == key) {
				return mid;
			}else if (data[mid] < key){//查找的元素key比中间数大，说明在又半
				begin = mid + 1;
				mid = (begin + end)/2;
			}else {//查找的元素比中间元素小，在左一半
				end = end - 1;
				mid = (begin + end)/2;
			}
		}
		return -1;
	}
	
}

== 数组练习==

package wwl.array;

import java.util.Scanner;

/**
 * 定义一个存储10个int类型的数组，从键盘上输入10个整数给数组元素赋值
 * 把数组的元素打印到屏幕上，要求for循环/foreach循环
 * 找出数组中最大值元素的下标，打印出来
 */
public class Test06 {

	public static void main(String[] args) {
		//定义数组存储10个int数据
		int [] data = new int[10];
		Scanner input = new Scanner(System.in);
		for(int i = 0; i < data.length; i++) {
			System.out.println("请输入第" + (i+1) + "个数");
			data[i] = input.nextInt();
		}
		for (int xx : data) {
			System.out.print(xx);
		}
		//找出数组中最大值元素的下标，打印出来
		int max = 0;
		for(int x = max + 1 ; x < data.length;x++) {
			if(data[max] < data[x]) {
				max = x;
			} 
		}
		System.out.println("最大值的下标为" + max);
		System.out.println("最大值的为" + data[max]);
	}
}
龙是我吗？
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二维数组的冒泡排序
Dai_Yue的博客
03-13 1万+
#include <stdio.h> int main() { int a[4][4]={{1,4,3,2}, {8,6,5,7}, {3,7,2,5}, {4,8,6,1}}; int i,j,k,t; for(i=0;i<4;i++) for(j=0;j<3;j++) for(k=j+1;k<4;k++)
冒泡排序的介绍，以及对二维数组进行排序
m0_48087498的博客
02-22 4632
文章目录一、冒泡排序的简单介绍二、用冒泡排序对二维数组进行排序方法一方法二 一、冒泡排序的简单介绍 冒泡排序（英语：Bubble Sort）又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 具体步骤如下： 比较相邻的元素。如果第一个比第二个大，就交换它们两个。 对每一对相邻元素作同样的工作，
二维数组用冒泡算法排序
Boxzhang的博客
12-12 955
#include "stdio.h" int main(){ int i,j,a,b,temp,*p; /*定义二维数组并赋值*/ int arr[3][4]={ {1,3,2,8}, {5,4,9,12}, {19,51,18,25}, }; /*二维数组看成一维数组，每个元素...
11.冒泡排序和二维数组
baaa111的博客
09-08 477
带你走进冒泡排序，Arrays类的使用以及二维数组的世界。
【C语言数组】一、二维数组&冒泡排序
weixin_66672501的博客
05-01 6935
目录1. 一维数组的创建和初始化1.1 一维数组的创建1.2 数组的初始化1.3 一维数组在内存中的存储2. 二维数组的创建和初始化2.1 二维数组的使用2.2 二维数组在内存中的存储3. 数组越界4. 数组作为函数参数总结 1. 一维数组的创建和初始化 如果说想要定义10个相同类型的变量，单个定义的话会太麻烦，因此下面就引出了数组的概念。 1.1 一维数组的创建 数组是一组相同类型元素的集合。 数组的创建方式： type_t arr_name [const_n]; //type_t 是指数组的元
Java基础复习day03数组
12-11
数组 的定义，创建，访问，长度属性，遍历，常用Arrays类 二维数组，方法递归调用经典案例 变量源码教程
day002 JAVA语法基础-数组加强.doc
08-16
day002 JAVA语法基础-数组加强.doc
day002 JAVA语法基础-数组入门.doc
08-16
day002 JAVA语法基础-数组入门.doc
Java开发零基础篇：day04 数组.pdf
11-05
Java开发零基础篇Day04资料文档
Java开发零基础篇：day07 数组高级.pdf
11-10
Java开发零基础篇Day07资料文档
java_二维数组冒泡行列排序源代码
08-15
使用冒泡排序实现的java语言编写的关于二维数组的排序，实现了行、列的排序输出。
java简单二维数组的冒泡排序
Biubiubiu!
09-11 3377
运行结果为： 张三56李四66王五76赵六86田七96 田七96赵六86王五76李四66张三56 public class Demo02 { public static void main(String[] args) { // 1、定义一个二维数组String [][]student = new String[5][2]; // 二维数组内存放五个学生姓名和成绩，使用一种排序方式将数组根据...
Java二维数组冒泡排序
不懂编程的程序员都是在耍流氓
08-09 4105
以前都是将二维转换成一维数组排序，今天老师要求不转换试了一下，仔细分析了一下冒泡，写了这个大家可以试试其他的排序方法，应该都可以用 import java.util.Arrays; class Test { public static void main(String[] args) { int[][] arr={{11,15,32,21},{2,3},{4,5,6}}; int
Java基础---二维数组、冒泡排序法
m0_37561864的博客
03-01 1939
声明数组： 数据类型[][] 数组名 例：int[][] intArr； 数组初始化： 数组类型 数组名[][]={{值1，值2，值3}，{值1，值2，值3}}； 使用二维数组： 数组名[ 外层下标 ][ 内层下标 ]冒泡排序： 速记口诀：n个数字来排队
java中的二维数组,冒泡排序
ckw__xyy的博客
07-16 1569
一. 二维数组的语法格式如下: 数据类型 [ ][ ] 数组名 或者 数据类型 数组名 [ ][ ]; int [ ][ ]scores=new int[ 5 ][10]; *需要强调的是,虽然从语法上看java支持多维数组,但是从内存分配原理的角度看.java中只有一维数组,没有多维数组,或者说表面上是多维数组,实质上是一维数组. 二.位数组的遍历 示例:分别计算每个班学生的总成绩 实现步骤如下: 1.初始化二维数组 2.定义保存总成绩的变量 3.使用for循环遍历二维数组 代码如下: 三 .
python-Day5-深入正则表达式--冒泡排序-时间复杂度 --常用模块学习:自定义模块--random模块:随机验证码--time & datetime模块...
weixin_30924239的博客
02-18 1221
正则表达式 语法: mport re #导入模块名 p = re.compile("^[0-9]") #生成要匹配的正则对象 ， ^代表从开头匹配，[0-9]代表匹配0至9的任意一个数字， 所以这里的意思是对传进来的字符串进行匹配，如果这个字符串的开头第一个字符是数字，就代表匹配上了 m = p.match('14534Abc...
JAVA-第七课-二维数组和选择排序、插入排序以及冒泡排序
giantleech的博客
01-12 356
二维数组和简单排序 一、选择排序 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 代码实现 package com.sort; import java.util.Arrays; public class ChooseSort { static int[] array = {3,2,4,1,5,0}; public static void chooseSort(int[] a {
C++/C>补充知识点，数组，数组传参,二维数组传参打印三种发方法,正则表达式
qq_42069216的博客
09-11 368
C>补充知识点，数组，数组传参,正则表达式
从零开始学java（17）--- 冒泡排序和二维数组
Muyaaa的博客
02-18 189
Day7 今天了解了一下冒泡排序和二维数组 ，着重学习了java中类与方法的初步构建。 1.冒泡排序： 从底部找到两个相邻的元素，比较，找到较小的，往上放 经过一次交换，最小的就在最上面 示例： public class BubbleSort { public static void main(String[] args) { int[] nums = { 1, 5, 8, 3, 4, ...
二维数组与类的定义_DAY06
最新发布
06-03
二维数组是一个由多个一维数组组成的数组，每个一维数组又由多个元素组成，可以通过行和列的索引来访问元素。在C++中，可以使用以下方式定义一个二维数组： ```c++ int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值