二维数组冒泡排序 java_013 JAVA 多维数组及数组的拷贝、冒泡排序、二分法查找...

1.多维数组

多维数组的元素又是数组，可以有二维、三维、甚至更多维数组

1.1二维数组的声明：

数据类型 [][] = new 数据类型[一维长度][二维长度]

public class Test01 {

public static void main(String[] args) {

//一维数组的静态初始化 数据类型[] 数组名 = {值1，值2，...};int [] arr1 = {11,22,33,44};

int [] arr2 = new int[4];

arr2[0] = 44;

arr2[1] = 33;

arr2[2] = 22;

arr2[3] = 11;

System.out.println("arr1:"+arr1+"\tarr2:"+arr2);

//二维数组int [][] arrA= new int[2][];

arrA[0] = arr1;//引用arrA[1] = arr2;

System.out.println("arrA:"+arrA);

}

}

1.2 二维数组的初始化：(动态初始化和静态初始化)

public class Test02 {

public static void main(String[] args) {

//二维数组不是规则的矩阵

//二维数组的静态初始化 数据类型[][] 数组名 = new{{值1，值2，...},{值1，值2，...},{值1，...}...}

int [][] arrA = {{1,2},{12,13,14},{1,2,3,4,5}};

System.out.println(arrA);

//声明一个二维数组，存储3个一维数组，每个一维数组长度不清楚

int [] arrB[] = new int[3][];

arrB[0] = new int[2];// 2个 null

arrB[1] = new int[]{1,2,3,4};

arrB[2] = new int[3];

System.out.println(arrB);

//声明一个二维数组，同时创建出一维数组，每个一维数组长度相同

int arrC[][] = new int[3][4];//存储3个一维数组，每个一维数组长度为4

System.out.println(arrC);

}

}

1.3 数组的遍历：

1)普通for循环

2)加强for循环

3)普通for循环+加强for循环

public class Test03 {

public static void main(String[] args) {

int [][] arrA = {{1,2},{2,3,4},{1,2,3,4,5}};

//普通for循环

for(int i=0;i<3;i++) {

for(int j=0;j

System.out.print(arrA[i][j]+"\t");

}

System.out.println();

}

System.out.println("--------####----------------");

//加强for循环

for(int[] arr:arrA) {

for(int i:arr) {

System.out.print(i+"\t");

}

System.out.println();

}

System.out.println("-----------****--------------");

//普通for循环与加强for循环混搭

for(int[] arr:arrA) {//加强for

for(int i=0;i

System.out.print(i+"\t");

}

System.out.println();

}

System.out.println("===================&*&========");

//

for(int i=0;i

for(int j:arrA[i]) {//加强for

System.out.print(j+"\t");

}

System.out.println();

}

}

}

1.4 数组的实例实现：(杨辉三角)---------数组及循环嵌套

public class YangHui {

public static void main(String[] args) {

int [][] arr = new int[6][6];

for(int i=0;i

arr[i][0] = 1;//第一列数字为1

arr[i][i] = 1;//对角线元素为1

}

//其它各元素的值

for(int i=2;i

//for(int j=1;j

for(int j=1;j

arr[i][j] = arr[i-1][j] + arr[i-1][j-1];

}

}

//遍历数组，进行打印

for(int i=0;i

//for(int j=0;j

for(int j=0;j

System.out.print(arr[i][j]+"\t");

}

System.out.println();

}

}

}

1.5 数组存储表格数据

public class Person {

private String name;

private int age;

private char sex;

//构造函数

public Person(String name, int age, char sex) {

super();

this.name = name;

this.age = age;

this.sex = sex;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return name+"\t"+age+"\t"+sex;

}

public static void main(String[] args) {

//创建Person类型的数组，用于存储3个Person类型的对象，用于封装信息

Person[] pers = new Person[3];

//创建Person类的对象

Person p1 = new Person("张三",37,'男');

pers[0] = p1;//将p1对象存储到Person类型的数组中去

pers[1] = new Person("王五",16,'男');

pers[2] = new Person("李梅",15,'女');

for(int i=0;i

System.out.println(pers);//对象数组中存储的是对象的引用(内存地址)

System.out.println(pers[i]);

}

}

}

内存分析：

1.6 数组的拷贝

在System类里也包含了一个

static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，

该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素

public class Test03 {

public static void main(String[] args) {

int [] arrA = {11,22,33,44};

int [] arrB = new int[5];

System.out.println("数组拷贝之前：");

for(int num:arrB) {

System.out.print(num+"\t");

}

System.arraycopy(arrA, 0, arrB, 0, 4);

System.out.println("\n数组拷贝之后：");

for(int num:arrB) {

System.out.print(num+"\t");

}

}

}

另外，数组的拷贝方法还有：

a.引用(地址)的拷贝

public class Test01 {

public static void main(String[] args) {

int[] arrA ={11,22,33,44};

int [] arrB = new int[5];

//拷贝地址(引用)之前

System.out.println("拷贝之前：");

System.out.println("arrA:"+arrA);

System.out.println("arrB:"+arrB);

//拷贝地址之后

arrB = arrA;

System.out.println("拷贝之后：");

System.out.println("arrA:"+arrA);

System.out.println("arrB:"+arrB);

}

}

b.值的拷贝

public class Test02 {

public static void main(String[] args) {

int [] arrA = {11,22,33,44};

int [] arrB = new int[5];

//赋值

//arrB[0] = arrA[0];

//arrB[1] = arrA[1];

//arrB[2] = arrA[2];

//arrB[3] = arrA[3];

System.out.println("赋值之前：");

for(int i=0;i

System.out.print(arrB[i]+"\t");

}

//赋值

int length = Math.min(arrA.length,arrB.length);

for(int i=0;i

arrB[i] = arrA[i];

}

System.out.println("\n赋值之后");

for(int i=0;i

System.out.print(arrB[i]+"\t");

}

}

}

c.Arrays.copyOf方法，如下：

1.7 java.util.Arrays类

在java.util.Arrays类中，包含了常用的数组操作(排序、查找、填充、打印内容等)

package com.sxt.arrays;

import java.util.Arrays;

public class Test01 {

public static void main(String[] args) {

int[] arrA = {11,16,6,154,36};

int[] arrB = {11,16,6,154,36};

//Arrays.toString 打印数组元素

System.out.println(Arrays.toString(arrA));

System.out.println("------------------------");

System.out.println(arrA.equals(arrB));//比较引用地址

//Arrays.equals 比较内容是否一致

System.out.println(Arrays.equals(arrA,arrB));//比较内容

System.out.println("=========================");

int [] arrC = new int[5];

System.out.println("拷贝前："+arrC);

System.out.println("-------------------------");

//Arrays.copyOf 开辟新的数组来复制指定的数组

arrC = Arrays.copyOf(arrA, 7);

System.out.println("拷贝后："+arrC);

System.out.println(Arrays.toString(arrC));

System.out.println("=========================");

//Arrays.fill 将数组中所有元素都已指定元素填充

Arrays.fill(arrC, 88);

System.out.println(Arrays.toString(arrC));

System.out.println("--------------------------");

//sort 将数组中元素按照升序进行排序

Arrays.sort(arrA);

System.out.println("arrA的升序排列："+Arrays.toString(arrA));

System.out.println("==============");

int [] arr = {5,13,19,21,37,56,64,75,80,88,92};

//折半查找并返回找到元素的下标；未找到则返回值(-插入点-1)

System.out.println(Arrays.binarySearch(arr,21));

System.out.println(" ");

//对Person类型的数组进行排序

Person [] pers = new Person[3];

pers[0] = new Person("张弎",29,'男');

pers[1] = new Person("张大",19,'女');

pers[2] = new Person("张五",49,'男');

System.out.println("按照年龄的升序排列：");

Arrays.sort(pers);

for(Person p:pers) {

System.out.println(p);

}

}

}

class Person implements Comparable {

private String name;

private int age;

private char sex;

//构造函数

public Person(String name, int age, char sex) {

super();

this.name = name;

this.age = age;

this.sex = sex;

}

@Override

public String toString() {

return name+"\t"+age+"\t"+sex;

}

@Override

public int compareTo(Person o) {//大于 正数，小于负数，等于0

return this.age -o.age ;

}

}

2. 冒泡排序及冒泡排序的优化

2.1冒泡排序算法大致思路：

1. 比较相邻的元素。如果第一个比第二个大，就交换顺序；

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数；

3. 每一趟循环都从数列的第一个元素开始比较，依次比较相 邻的两个元素，比较到数列的最后；

4. 循环往复，即可得到升序的数组。

图示：

package com.sxt.bubble;

import java.util.Arrays;

//冒泡排序

public class Bubble01 {

public static void main(String[] args) {

int [] arr = {45,13,56,94,16,2,90};

System.out.println("排序前："+Arrays.toString(arr));

for(int i=0;i

for(int j=0;j

//相邻两数比较

if(arr[j]>arr[j+1]) {

//通过变量交换

int temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

System.out.println("排序后："+Arrays.toString(arr));

}

}

2.2 冒泡排序的优化算法

将整个数组分成两部分：有序数列和无序数列，因此：

1.不必每一趟都比较到数组结束，到有序数列即可

2.定义一个 boolean 类型的变量 flag,默认有序 true;发生交换，置为 false，一趟循环结束后，根据 flag 的值判断是否有序，有序，则退出循环

3.设置成员变量，放在大循环外部，不必每次都开辟空间

图例：

package com.sxt.bubble;

import java.util.Arrays;

//冒泡排序的优化

public class Bubble02 {

public static void main(String[] args) {

int [] arr = {2,13,16,56,45,90,94};

int temp;

boolean flag;

int count = 0;

System.out.println("排序前："+Arrays.toString(arr));

for(int i=0;i

flag = true;//默认有序

count++;//统计比较的次数

for(int j=0;j

//相邻两数比较

if(arr[j]>arr[j+1]) {

//通过变量交换

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

flag = false;//数组中的元素无序，发生了交换

}

}

if(flag) {

System.out.println(flag);

break;//数组有序，退出循环，证明数组有序

}

}

System.out.println("排序后："+Arrays.toString(arr));

System.out.println("一共比较了"+count+"轮");

}

}

3.折半查找(二分法)