数组、冒泡、稀疏数组
递归：A方法调用A方法，即自己调用自己
递归结构包括两个部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法
范例：
package base.method;
public class Demo1 {
public static void main(String[] args) {
// 5! 5*4*3*2*1
System.out.println(f(5)); //120
}
//1! 1
//2! 2*1
public static int f(int n){
if(n==1){
return 1;
}else{
return n*f(n-1);
}
}
}
冒泡排序
冒泡排序是最为出名的排序算法之一，总共有八大排序
冒泡：两层循环，外层冒泡轮数，里层依次比较
方式：比较数组中，两个相邻的元素，如果第一个数比第二数大，则交换他们的位置
冒泡排序时间复杂度：O(n2)
package base.method;
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
int[] a={1,2,3,4,5,13,6,123,999,434};
int[] sort=sort(a);
System.out.println(Arrays.toString(sort));
// [1, 2, 3, 4, 5, 6, 13, 123, 434, 999]
}
// 冒泡排序
public static int[] sort(int[] arrays){
int temp=0;
// 外层循环，判断轮数
for (int i = 0; i <arrays.length-1 ; i++) {
//内层循环，依次比较，判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j <arrays.length-1-i ; j++) {
if (arrays[j+1]<arrays[j]){ // 如果后一个数比前一个数大，则交换位置
temp=arrays[j];
arrays[j]=arrays[j+1];
arrays[j+1]=temp;
}
}
}
return arrays;
}
}
内存分析
Java内存分析
| 堆 | （1）存放new的对象和数组（2）可以被所有的线程共享，不会存放别的对象引用 |
|---|---|
| 栈 | （1）存放基本变量类型（会包含这个基本类型的具体数值）（2）引用对象的变量（会存放这个引用在堆里面的具体地址） |
| 方法区 | （1）可以被所有的线程共享（2）包含了所有的class和static变量 |
范例：（数组）--反转
package base.method;
public class Demo1 {
public static void main(String[] args) {
int[] array={1,2,3,4,5,6};
int[] reverse=reverse(array);
for (int a:reverse) {
System.out.print(a +" "); // 6 5 4 3 2 1
}
}
// 反转数组
public static int[] reverse(int[] arrays){
int[] result=new int[arrays.length];
for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {
result[j]=arrays[i];
}
return result;
}
}
数组的工具类：java.util.Arrays
Arrays类中的方法都是static修饰的静态方法，可以直接使用类名进行调用。
具有如下常用功能：
（1）给数组赋值：通过fill方法
（2）对数组排序：通过sort方法，按序
（3）比较数组：通过equals方法比较数组中元素是否相等
（4）查找数组元素：通过binarySearch方法对排序的数组进行二分查找法操作
package base.method;
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
int[] a={1,2,3,4,5,13,6,123,999,434};
// 打印数组元素 Arrays.toString
//System.out.println(Arrays.toString(a));
// [1, 2, 3, 4, 5, 13, 6, 123, 999, 434]
//数组进行排序
//Arrays.sort(a);
//System.out.println(Arrays.toString(a));
// [1, 2, 3, 4, 5, 6, 13, 123, 434, 999]
Arrays.fill(a,0);
System.out.println(Arrays.toString(a));
// [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
}
}
冒泡排序
冒泡排序是最为出名的排序算法之一，总共有八大排序
冒泡：两层循环，外层冒泡轮数，里层依次比较
冒泡排序时间复杂度：O(n2)
package base.method;
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
int[] a={1,2,3,4,5,13,6,123,999,434};
int[] sort=sort(a);
System.out.println(Arrays.toString(sort));
// [1, 2, 3, 4, 5, 6, 13, 123, 434, 999]
}
// 冒泡排序
public static int[] sort(int[] arrays){
int temp=0;
// 外层循环，判断轮数
for (int i = 0; i <arrays.length-1 ; i++) {
//内层循环，依次比较，判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j <arrays.length-1-i ; j++) {
if (arrays[j+1]<arrays[j]){
//如果后一个数比前一个数大，则交换位置
temp=arrays[j];
arrays[j]=arrays[j+1];
arrays[j+1]=temp;
}
}
}
return arrays;
}
}
稀疏数组
当一个数组中大部分元素为0，或者同一值的数组时，可以使用稀疏数组保存该数组。
稀疏数组的处理方式：
（1）记录数组一共有几行几列，有多少个不同值
（2）把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
package base.method;
public class ArraysDemo2 {
public static void main(String[] args) {
// 1、创建一个二维数组 11*11 0：没有棋子，1：围棋，2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 1;
// 输出原始数组
System.out.println("输出原始的数组：");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
// 转换为稀疏数组保存
// 1、获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("有效值的个数：" + sum);
// 2、创建一个稀疏数组
int[][] array2 = new int[sum + 1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
// 遍历二维数组，将非零的值，存放稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
// 输出稀疏数组
System.out.println("稀疏数组：");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][