我眼中的數(shù)組和冒泡排序

一維數(shù)組

數(shù)組是一個定長的容器，可以放相同類型的數(shù)據(jù)。
數(shù)組中的元素可以是任何數(shù)據(jù)類型，包括基本數(shù)據(jù)類型和引用數(shù)據(jù)類型

專業(yè)解釋

數(shù)組（Array）是一種線性表數(shù)據(jù)結(jié)構(gòu)。它用一組連續(xù)的內(nèi)存空間，來存儲一組具有相同類型的數(shù)據(jù)。
線性表，顧名思義，線性表就是數(shù)據(jù)排成像一條線一樣的結(jié)構(gòu)。每個線性表上的數(shù)據(jù)最多只有前和后兩個方向。
數(shù)組具有連續(xù)的內(nèi)存空間和相同的數(shù)據(jù)類型

數(shù)組的聲明

dataType[] arrayName;
注：數(shù)組在聲明時不能指定數(shù)組長度，即dataType[n] arrayName；是不合法的

數(shù)組的創(chuàng)建

arrayName = new dataType[n];

動態(tài)創(chuàng)建（初始化）

dataType[] arrayName = new dataType[n];

靜態(tài)創(chuàng)建（初始化）

dataType[] arrayName = new dataType[]{value1,value2,......,valueN};

數(shù)組的內(nèi)存模型

數(shù)組的聲明即數(shù)組變量名存儲在棧中，數(shù)組的創(chuàng)建在堆中，即在堆中開辟連續(xù)的對應數(shù)組長度的空間（所有引用類型的創(chuàng)建都在堆中）

所有引用類型的變量名存的都是地址。

數(shù)組創(chuàng)建后的初始默認值

引用類型的數(shù)組元素默認初始值是null
字符類型的數(shù)組元素默認初始值是空格(0對應的字符)
整數(shù)類型的數(shù)組元素默認初始值是0
浮點數(shù)類型的元素默認初始值是0.0
布爾類型的元素默認初始值是false

為什么數(shù)組索引值從0開始呢?

從數(shù)組存儲的內(nèi)存模型上來看，“下標”最確切的定義應該是“偏移（offset）”。如果用 a 來表示數(shù)組的首地址，a[0] 就是偏移為 0 的位置，
也就是首地址，a[k] 就表示偏移 k 個 type_size 的位置，所以計算 a[k] 的內(nèi)存地址只需要用這個公式：

a[k]_address = base_address + k * type_size

但是，如果數(shù)組從 1 開始計數(shù)，那我們計算數(shù)組元素 a[k] 的內(nèi)存地址就會變?yōu)椋?/p>

a[k]_address = base_address + (k-1)*type_size
對比兩個公式，我們不難發(fā)現(xiàn)，從 1 開始編號，每次隨機訪問數(shù)組元素都多了一次減法運算，對于 CPU 來說，就是多了一次減法指令。數(shù)組作為非常基礎的數(shù)據(jù)結(jié)構(gòu)，通過下標隨機訪問數(shù)組元素又是其非常基礎的編程操作，效率的優(yōu)化就要盡可能做到極致。所以為了減少一次減法操作，數(shù)組選擇了從 0 開始編號，而不是從 1 開始。
也有可能是歷史原因
C 語言設計者用 0 開始計數(shù)數(shù)組下標，之后的 Java、JavaScript 等高級語言都效仿了 C 語言，或者說，為了在一定程度上減少 C 語言程序員學習 Java 的學習成本，因此繼續(xù)沿用了從 0 開始計數(shù)的習慣。實際上，很多語言中數(shù)組也并不是從 0 開始計數(shù)的，比如 Matlab。甚至還有一些語言支持負數(shù)下標，比如 Python。

數(shù)組與鏈表的區(qū)別

鏈表適合插入和刪除，時間復雜度是O(1),數(shù)組支持隨機訪問，根據(jù)下標隨機訪問的時間復雜度為O(1)。

增強for循環(huán)遍歷數(shù)組

按照數(shù)組下標順序，依次將冒號右邊數(shù)組中的每個元素賦值給冒號左邊的變量，數(shù)組長度為for循環(huán)的次數(shù)
for(數(shù)組元素類型 變量名 : 數(shù)組名){
語句;
}

編寫一個長度為5的整型數(shù)組，每個元素賦值為0-10的隨機整數(shù)，遍歷該數(shù)組，輸出每個元素。
int[] arr = new int[5];
Random r = new Random();
for(int i = 0; i < arr.length; i++){
arr[i] = r.nextInt(10);
}
for(int t : arr){
System.out.println(t);
}

多維數(shù)組

數(shù)據(jù)類型是數(shù)組的數(shù)組

動態(tài)初始化

數(shù)組名 = new 數(shù)據(jù)元素類型[ 行數(shù) ] [ 列數(shù) ] ;
行數(shù)不能為空

靜態(tài)初始化

數(shù)組類型 數(shù)組名[ ][ ] = new 數(shù)據(jù)類型[ ][ ] { {元素11，元素12，…} , {元素21，… } }

一維數(shù)組冒泡排序

int[] arr = new int[]{4,45,1,13,89,7};
            int temp;
            for(int i = 0; i < arr.length; i++){
                  for(int j = 0; j < arr.length - 1;j++){
                        if(arr[j] > arr[j+1]){
                              temp = arr[j];
                              arr[j] = arr[j+1];
                              arr[j+1] = temp;
                        }
                  }
            }

優(yōu)化

int[] arr = new int[]{4,45,1,13,89,7};
            int temp;
            boolean flag = false;
            for(int i = 0; i < arr.length; i++){
                  for(int j = 0; j < arr.length - i -1;j++){
                        if(arr[j] > arr[j+1]){
                              temp = arr[j];
                              arr[j] = arr[j+1];
                              arr[j+1] = temp;
                              flag = true;
                        }
                  }
                  //當沒有數(shù)據(jù)交換時，證明數(shù)組已排序完成，退出子循環(huán)
                  if(!flag){
                        break;
                  }
            }

二維數(shù)組冒泡排序（兩種方法）

創(chuàng)建二維數(shù)組

Random r = new Random();
            int[][] arr = new int[4][6];
            for(int i = 0; i < arr.length; i++){
                  for(int j = 0; j < arr[0].length;j++){
                        arr[i][j] = r.nextInt(100);
                        System.out.print(arr[i][j]+" ");
                  }
                  System.out.println();
            }
            int row = arr.length;
            int column = arr[0].length;

第一種方法

//二維數(shù)組轉(zhuǎn)化為一維數(shù)組
int[] array = new int[row * column];
for(int i = 0; i < row; i++){
            for(int j = 0; j < column; j++){
                        array[i*column+j] = arr[i][j];
            }
}

//對一維數(shù)組進行冒泡排序
int temp;
boolean flag = false;
for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array.length - i -1;j++){
                        if(array[j] > array[j+1]){
                                    temp = array[j];
                                    array[j] = array[j+1];
                                    array[j+1] = temp;
                                    flag = true;
                        }
            }
            if(!flag){
                        break;
            }
}
//輸出排序后的一維數(shù)組
for(int i : array){
            System.out.print(i + " ");
}
System.out.println();
//將排序后的一維數(shù)組轉(zhuǎn)化為二維數(shù)組
for(int i = 0; i < row; i++){
            for(int j = 0; j < column; j++){
                        arr[i][j] = array[i*column+j];
            }
}
//輸出二維數(shù)組
for(int i = 0 ; i < arr.length;i++){
            System.out.println(Arrays.toString(arr[i]));
}

第二種方法

int temp = 0;
            boolean flag = false;
            //所有子數(shù)組完成排序需要的冒泡次數(shù)總和
            for(int t = 0; t < row * column; t++){    
                  //遍歷父數(shù)組，即第一維數(shù)組（行）的遍歷
                  for(int z = 0; z < arr.length; z++){      
                        //每個數(shù)組完成排序需要的冒泡次數(shù)
                        for(int i = 0; i < arr[0].length; i++){
                              //遍歷子數(shù)組，并進行冒泡排序
                              for(int j = 0; j < arr[0].length - 1 -i;  j++){
                                    if(arr[z][j]>arr[z][j+1]){
                                          temp = arr[z][j];
                                          arr[z][j] = arr[z][j+1];
                                          arr[z][j+1] = temp;
                                          flag = true;
                                    }
                              }
                              //當沒有數(shù)據(jù)交換時，證明數(shù)組已排序完成，退出子循環(huán)
                              if(!flag){
                                    break;
                              }
                        }
                        //輸出每組的最大值
                        //System.out.println(arr[z][arr[0].length-1]);
                        //將每組的最大值與下一組的第一個值比較，若大于則交換
                        if(z < arr.length - 1 && arr[z][arr[0].length-1]  > arr[z+1][0]){
                              temp = arr[z][arr[0].length-1];
                              arr[z][arr[0].length-1] = arr[z+1][0];
                              arr[z+1][0] = temp;
                        }
                  }
            }
            //輸出二維數(shù)組
            for(int i = 0 ; i < arr.length;i++){
                  System.out.println(Arrays.toString(arr[i]));
            }