1、比較陣列中，相鄰的元素，如果第一個比第二個數大，我們就交換他們的位置。

2、每一次的比較，都會產生出一個最大，或者最小的數字。

3、依次迴圈，直到結束。

例子：

 1 public class Demo8 {
 2     public static void main(String[] args) {
 3         int[] a = {1,35,35,124,5,3,3,6,4,2};
 4 
 5         //呼叫完我們自己寫的排序方法後，返回一個排序後的陣列
 6         int[] sort = sort(a);
 7         System.out
 
.println(Arrays.toString(sort));
 8 
 9     }
10     public static int[] sort(int[] array){
11         //定義第三方
12         //臨時變數
13         int temp = 0;
14         //外層迴圈： 判斷我們這個要走多少次
15         for (int i = 0; i < array.length-1; i++) {
16             //優化
17             //通過flag識別符號減少沒有意義的比較
18             boolean flag = false
 
;
19             //內層迴圈： 比價判斷兩個數，如果第一個數， 比第二個數大， 則交換位置
20             for (int j = 0; j < array.length-1-i; j++) {
21                 if (array[j+1] > array[j]){
22                     temp = array[j];
23                     array[j] = array[j+1];
24                     array[j+1] = temp;
25                     flag = true
 
;
26                 }
27             }
28             if (flag==false){
29                 break;
30             }
31         }
32         return array;
33     }
34 }

稀疏陣列：

 1 public class Demo9 {
 2     public static void main(String[] args) {
 3         //1、建立一個二維陣列11*11    0：又沒棋子    1：黑棋   2： 白棋
 4         int[][] array1 = new int[11][11];
 5         array1[1][2] = 1;
 6         array1[2][3] = 2;
 7 
 8         //輸出原始的陣列
 9         System.out.println("輸出原始陣列");
10 
11         //列印
12         for (int[] ints : array1) {
13             for (int anInt : ints) {
14                 System.out.print(anInt+" ");
15             }
16             System.out.println("\n");
17         }
18 
19         //轉換為稀疏陣列
20         //獲取有效值的個數
21         int sum = 0;
22         for (int i = 0; i < 11; i++) {
23             for (int j = 0; j < 11; j++) {
24                 if (array1[i][j] != 0){
25                     sum++;
26                 }
27             }
28         }
29         System.out.println("有效的個數："+sum);
30         System.out.println("==========================================");
31 
32         //2、建立一個稀疏陣列的陣列
33         int[][] array2 = new int[sum+1][3];
34         array2[0][0] = 11;
35         array2[0][1] = 11;
36         array2[0][2] = sum;
37 
38         //遍歷二維陣列， 將非零的值， 存放在稀疏陣列中
39         int count = 0;
40         for (int i = 0; i < array1.length; i++) {
41             for (int j = 0; j < array1[i].length; j++) {
42                 if (array1[i][j] != 0){
43                     count++;
44                     array2[count][0] = i;
45                     array2[count][1] = j;
46                     array2[count][2] = array1[i][j];
47                 }
48             }
49         }
50         //輸出稀疏陣列
51         System.out.println("稀疏陣列");
52         for (int i = 0; i < array2.length; i++) {
53             System.out.println(array2[i][0]+"\t"+
54                     array2[i][1]+"\t"+
55                     array2[i][2]);
56         }
57 
58         System.out.println("================================");
59         System.out.println("還原");
60         //1、讀取稀疏陣列
61         int[][] array3 = new int[array2[0][0]][array2[0][1]];
62         //2、給其中的元素還原它的值
63         for (int i = 1; i < array2.length; i++) {
64             array3[array2[i][0]][array2[i][1]] = array2[i][2];
65         }
66         //3、列印
67         for (int[] ints : array3) {
68             for (int anInt : ints) {
69                 System.out.print(anInt+" ");
70             }
71             System.out.println("\n");
72         }
73     }
74 }