Java.基礎知識篇.03 循環、數組、冒泡排序



一、循環：

     1.循環:反覆執行一段相同或相似的代碼
     2.循環三要素:
           1)循環變量的初始化
           2)循環的條件(以循環變量爲基礎)
           3)循環變量的改變(向着循環的結束變)

     3.三種循環的更佳適用情況:
          1)while:"當..."循環
          2)do...while:"直到..."循環
                       第1要素與第3要素相同時首選do...while
          3)for:固定次數循環，應用率最高

二、數組：

      1.相同數據類型元素的集合
      2.是一種數據類型(引用類型)
      3.數組的定義:
               int[] arr = new int[4];//4表示數組共有四個元素
      4.數組的初始化:
               int[] arr = new int[4]; //0,0,0,0
               char[] arr = {a,b,c,d}; //a,b,c,d
               int[] arr = new int[]{1,4,5,8}; //1,4,5,8

               int[] arr;
               arr = {1,4,5,8}; //編譯錯誤
               arr = new int[]{1,4,5,8}; //正確
      5.數組的訪問:
           5.1)通過(數組名.length)可以獲取數組的長度
                       int[] arr = new int[5];
                       System.out.println(arr.length); //5
           5.2)通過下標來訪問數組中的元素下標從0開始，最大到(數組.length-1)
                       int[] arr = new int[3];
                       arr[0] = 100; //給arr中第1個元素賦值爲100
                       arr[1] = 200; //給arr中第2個元素賦值爲200
                       arr[2] = 300; //給arr中第3個元素賦值爲300
                       arr[3] = 400; //數組下標越界異常
                       System.out.println(arr[arr.length-1]); //輸出arr中的最後一個元素
      6.數組的遍歷:
                int[] arr = new int[10];
                for(int i=0;i<arr.length;i++){
                      arr[i] = (int)(Math.random()*100);
                 }
                 for(int i=0;i<arr.length;i++){ //正序
                       System.out.println(arr[i]);
                  }
                for(int i=arr.length-1;i>=0;i--){ //倒序
                       System.out.println(arr[i]);
                  }
      7.數組的複製:
             ①  System.arraycopy(a,1,a1,0,4);
             ②  int[] a1 = Arrays.copyOf(a,6);
                  a = Arrays.copyOf(a,a.length+1); //擴容
      8.數組的排序:
            Arrays.sort(arr); //升序，效率高
    

三、冒泡排序（Bubble Sort）       

      1.排序步驟：

            ①比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

            ②對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。

            ③針對所有的元素重複以上的步驟，除了最後一個。

            ④持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

         簡單總結爲:逐一比較相鄰元素，每輪確定一個元素位置，直至所有元素位置確定。

      2.複雜度、穩定性：

              時間複雜度：O（n²） 

              穩定排序算法

   

     3.算法描述（Java）

public class BubbleSort
{
    public void sort(int[] a)
    {
        int temp = 0;
        for (int i = a.length - 1; i > 0; --i)
        {
            for (int j = 0; j < i; ++j)
            {
                if (a[j + 1] < a[j])
                {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}