Day9 陣列 氣泡排序及稀疏陣列！
阿新 • • 發佈：2021-07-18
-
陣列是相同型別資料的有序集合。
-
陣列描述的是相同型別的若干個資料，按照一定的先後次序排列組合而成。
-
其中，每一個數據稱作一個數組元素，每個陣列元素可以通過一個下標來訪問它們。（下標從0開始）
陣列宣告建立
首先必須宣告陣列變數，才能在程式中使用陣列。下面是宣告陣列變數的語法：
dataType[] arrayRefVar; // 首選的方法
或
dataType arrayRefVar[]； // 效果相同 但不是首選方法
Java語言使用new操作符來建立陣列，語法如下：
dataType[] arrayRefVar = new dataType[arraySize]；
陣列元素是通過索引訪問的，素組索引從0開始。
獲取陣列的長度： arrays.length
package com.xiaoming.array;
public class ArrayDemo01 {
// 變數的型別 變數的名字 = 變數的值；
//陣列型別
public static void main(String[] args) {
int[] nums;//1.宣告一個數組
nums = new int[10];// 2.建立一個數組
// int[] nums = new int[10];
//3.給陣列中元數賦值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
System.out.println(nums[9]);//int預設為0 string預設為null
//計算所有元素的和
int sum = 0;
//獲取陣列長度：arrays.length
for(int i = 0;i<nums.length;i++){
sum = sum + nums[i];
}
System.out.println("總和為:"+sum);
}
}
三種初始化
靜態初始化：
int a = {1，2，3}；
動態初始化：
int[] a = new int[2];
陣列的預設初始化：
陣列是引用型別，它的元素相當於類的例項變數，因此陣列已經分配空間，其中的每個元素也被按照例項變數同樣的方式被隱式初始化。
package com.xiaoming.array;
public class ArrayDemo02 {
public static void main(String[] args) {
// 靜態初始化: 建立+賦值
int [] a = {1,2,3,4,5,6,7,8};
for (int i = 0; i <a.length ; i++) {
System.out.println(a[i]);
}
//動態初始化 包含預設初始化
int[] b = new int [10];
b[0] = 10;
b[2] = 5;
System.out.println(b[0]);
System.out.println(b[1]); //預設0
System.out.println(b[2]);
}
}
陣列的四個基本特點
-
長度是確定的 一旦被建立，大小是不能改變的。
-
元素必須是相同型別，不允許出現混合型別。
-
元素可以是任意型別，包括引用型別和基本型別。
-
陣列變數屬引用變數型別，陣列也可以看成物件，陣列中每個元素相當於物件成員的變數。
陣列本身就是物件，Java中物件是在堆中的，因此陣列無論儲存原始型別還是其它物件型別，陣列物件本身是在堆中的。
陣列邊界
下標合法區間：[0,length-1],如果越界就會報錯；
ArrayIndexOutOfBoundsException：陣列下標越界異常
陣列的使用
-
普通的for迴圈
-
For-Each迴圈
-
陣列作方法入參
-
陣列作返回值
package com.xiaoming.array;
public class ArrayDemo03 {
public static void main(String[] args) {
int [] arrays = {1,2,3,4,5};
//列印全部的陣列元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println("========================");
//計算所有元素的總和
int sum = 0;
for (int i = 0;i < arrays.length;i++){
sum = sum + arrays[i];
}
System.out.println("sum="+sum);
System.out.println("========================");
//查詢最大元素
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if (arrays[i] > max) {
max = arrays[i];
}
}
System.out.println("max="+max);
}
}
package com.xiaoming.array;
public class ArrayDemo04 {
public static void main(String[] args) {
int [] arrays = {1,2,3,4,5};
//JDK1.5 沒有下標
// for (int array : arrays) {
// System.out.println(array);
// }
// printArray(arrays);
int[] reverse = reverse(arrays);
printArray(reverse);
}
//反轉陣列 難點！！
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[] = arrays[i];
result[j] = arrays[i];
}
return result;
}
//列印陣列元素
public static void printArray(int[] arrasys) {
for (int i = 0; i < arrasys.length; i++) {
System.out.print(arrasys[i]+" ");
}
}
}
多維陣列
多維陣列可以看作陣列的陣列，比如二維陣列是一個特殊的一維陣列，其每一個元素都是一個一維陣列。
-
二維陣列
int a[ ] [ ] = new int [2 ] [ 5];
可以看成一個2行5列的陣列
package com.xiaoming.array;
public class ArrayDemo05 {
public static void main(String[] args) {
//4行兩列
/* [4][2] 面向物件
1，2 array[0]
2，3 array[1]
3，4 array[2]
4，5 array[3]
*/
int[][] array = {{1,2},{2,3},{3,4},{4,5}};
printArray(array[0]);
System.out.println("=======================");
System.out.println(array[0][0]);
System.out.println(array[0][1]);
System.out.println("=======================");
System.out.println(array.length); //陣列長度
System.out.println(array[0].length);
System.out.println("=======================");
for (int i = 0; i < array.length ; i++){
for (int j = 0; j < array[i].length;j++){
System.out.println(array[i][j]);
}
}
}
//列印陣列元素
public static void printArray(int[] arrasys) {
for (int i = 0; i < arrasys.length; i++) {
System.out.print(arrasys[i] + " ");
}
}
}
Arrays 類
-
陣列的工具類java.until.Arrays
-
由於陣列物件本身並沒有什麼方法可以供我們呼叫，但API中提供了一個工具類Arrays供我們使用，從而可以對資料物件進行一些基本操作。
-
檢視JDK幫助文件
-
Array類中的方法都是static修飾的靜態方法，在使用的時候可以直接使用類名進行呼叫，而“不用”使用物件來呼叫（注意：是“不用”而不是“不能”）
以下常用功能：
-
給陣列賦值：通過fill方法。
-
對陣列排序：通過sort方法，按升序。
-
比較陣列：通過equals方法比較陣列中的元素值是否相等。
-
查詢陣列元素：通過binarySearch 方法對排序好的陣列進行二分查詢法操作。
package com.xiaoming.array;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,2,3,4,55441,7895,1364,321,21,1412};
//System.out.println(a); // [I@1b6d3586
// 列印陣列元素
//System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 55441, 7895, 1364, 321, 21, 1412]
// printArray(a);
Arrays.sort(a); //進行陣列排序 :升序
System.out.println(Arrays.toString(a));
}
/* public static void printArray(int[] a){
for (int i = 0; i < a.length;i++){
if(i==0){
System.out.print("[");
}
if(i==a.length-1){
System.out.print(a[i]+"]");
}
else{
System.out.print(a[i]+", ");
}
*/
} -
氣泡排序 重點
-
氣泡排序無疑是最為出名的排序演算法之一， 一共有八大排序方法。
-
氣泡排序的程式碼還是相當簡單的，兩層迴圈，外層氣泡排序輪數，裡層依次比較，江湖中人盡皆知。
-
我們看到巢狀迴圈，應該立馬可以得到這個演算法的時間複雜度O（ n2）。
package com.xiaoming.array;
//氣泡排序
//1.比較陣列中兩個相鄰的元素，如果第一個大於第二個我們就交換他們的位置。
//2.每一次比較都會產生出一個最大或最小的數字；
//3.下一輪則可以少一輪排序
//4.依次迴圈 直到結束！！
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,6,7,15,54,23,16,48,29,5};
int[] sort = sort(a);//呼叫我們自己寫排序方法以後，返回一個排序後的陣列
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
//臨時變數
int temp = 0;
//外層迴圈，判斷我們要走多少次；
for (int i = 0; i < array.length-1; i++) {
//內層迴圈，比較兩個數，如果第一個數比第二個大，則交換位置。
for (int j = 0; j < array.length-1-i; j++) {
if(array[j+1] > array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
return array;
}
}
思考如何優化？
通過flag標識位減少沒有意義的比較
package com.xiaoming.array;
//氣泡排序
//1.比較陣列中兩個相鄰的元素，如果第一個大於第二個我們就交換他們的位置。
//2.每一次比較都會產生出一個最大或最小的數字；
//3.下一輪則可以少一輪排序
//4.依次迴圈 直到結束！！
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,6,7,15,54,23,16,48,29,5};
int[] sort = sort(a);//呼叫我們自己寫排序方法以後，返回一個排序後的陣列
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
//臨時變數
int temp = 0;
//外層迴圈，判斷我們要走多少次；
for (int i = 0; i < array.length-1; i++) {
boolean flag = false; // 通過flag標識位減少沒有意義的比較
//內層迴圈，比較兩個數，如果第一個數比第二個大，則交換位置。
for (int j = 0; j < array.length-1-i; j++) {
if(array[j+1] > array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if (flag==false){
break;
}
}
return array;
}
}
稀疏陣列 （資料結構）
當一個數組中大部分元素為0，或者為同一值的陣列時，可以使用稀疏陣列來儲存該陣列。
稀疏陣列的處理方式：
-
記錄陣列有幾行幾列，有多少不同值
-
把具有不同值的元素和行列及值記錄在一個小規模陣列中，從而縮小程式的規模
如圖：左邊是原始陣列，右邊為稀疏陣列
package com.xiaoming.array;
public class ArrayDemo08 {
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] = 2;
//輸出原始陣列
System.out.println("輸出原始的陣列");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
System.out.println("============================");
//轉化為稀疏陣列
//獲取有效值的個數
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[j][i] != 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]+"\t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
System.out.println("============================");
System.out.println("還原");
//1.讀取稀疏陣列
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.給其中元素還原值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3.列印
System.out.println("輸出還原的陣列");
for(int[] ints : array3 ) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}