陣列、冒泡、稀疏陣列
阿新 • • 發佈：2021-06-23
遞迴：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][0]