學號20182317 2019-2020-1 《數據結構與面向對象程序設計》第八週學習總結

學號20182317 2019-2020-1 《數據結構與面向對象程序設計》第八週學習總結

教材學習內容總結

三種經常使用的查找算法(順序查查找，折半查找，二叉排序樹查找)

1. 順序查找

對於數組，按順序比較給定的值，時間複雜度0(n),，如下是實現：

public static int Linear_Search(int[] data, int key) {
        if (data == null || data.length <= 0) {
            return -1;
        }
        for (int i = 0; i < data.length; i++) {
            if (data[i] == key) {
                return i;
            }
        }
        return -1;
    }

二分查找

二分查找是針對已有序的序列進行的高效查找，時間複雜度0(n),，如下是實現：

public static int binarySearch(int[] data, int key) {
        if (data == null || data.length <= 0) {
            return -1;
        }
        int low = 0;
        int high = data.length - 1;
        while (low < high) {
            int mid = (low + high) / 2;
            if (data[mid] == key) {
                return mid;
            } else if (data[mid] > key) {
                high = mid - 1;
            } else if (data[mid] < key) {
                low = mid + 1;
            }
        }
        return -1;
    }
 
    /**
     * 二分查找的前提是有序,遞歸
     * 
     * @param data
     * @param key
     * @return
     */
    public static int recursiveBinarySearch(int[] data, int low, int high, int key) {
        if (data == null || data.length <= 0) {
            return -1;
        }
        if (low < high) {
 
            int mid = (low + high) / 2;
            if (data[mid] == key) {
                return mid;
            } else if (data[mid] > key) {
                recursiveBinarySearch(data, low, mid - 1, key);
            } else if (data[mid] < key) {
                recursiveBinarySearch(data, mid + 1, high, key);
            }
 
        }
        return -1;
    }

冒泡排序

冒泡排序：就是每趟從待排序的數組中比較相鄰兩個數字的大小，將數字小的放在前面，數字大的放在後面；重複第一趟的操做，直到完成排序爲止。

• 冒泡排序的排序方法以下圖

public class BubbleSort {

  public static void main(String[] args) {
      int[] myArray = {18,91,38,77,36,55,74,30,2,41};
      System.out.println("排序前的數組爲:");
      for(int i=0;i<myArray.length;i++) {
          System.out.print(myArray[i]+" ");
      }
      
      //冒泡排序算法
      for(int i=0;i<myArray.length-1;i++) {
          for(int j=0;j<myArray.length-1-i;j++) {
              if(myArray[j]>myArray[j+1]) {
                  int temp = myArray[j];
                  myArray[j] = myArray[j+1];
                  myArray[j+1] = temp;
              }
          }
      }
      System.out.println();
      System.out.println("排序後的數組爲:");
      for(int i=0;i<myArray.length;i++) {
          System.out.print(myArray[i]+" ");
      }
  }

}

選擇排序

選擇排序：就是每次從一組待排序的數組中找到最小值（或最大值）而後與該序列的起始位置進行替換，以此類推，直到待排序的數組排序好爲止。

• 選擇排序的演示以下圖

public class SelectionSort {
 
    public static void main(String[] args) {
        int[] myArray = {18,91,38,77,36,55,74,30,2,41};
        System.out.println("排序前的數組爲:");
        for(int i=0;i<myArray.length;i++) {
            System.out.print(myArray[i]+" ");
        }
        //選擇排序算法
        for(int i=0;i<myArray.length;i++) {
            for(int j=i+1;j<myArray.length;j++) {
                int min = myArray[i];
                if(min>myArray[j]) {
                    int temp = myArray[i];
                    myArray[i] = myArray[j];
                    myArray[j] = temp;
                }
            }
        }
        System.out.println();
        System.out.println("排序後的數組爲:");
        for(int i=0;i<myArray.length;i++) {
            System.out.print(myArray[i]+" ");
        }
    }
 
}

插入排序

插入排序
- a、默認從第二個數據開始比較。

- 　b、若是第二個數據比第一個小，則交換。而後在用第三個數據比較，若是比前面小，則插入(交換)。不然，退出循環

　- 　c、說明：默認將第一數據當作有序列表，後面無序的列表循環每個數據，若是比前面的數據小則插入（交換）。不然退出。

　- 　d、代碼實現

插入排序的運行方式以下圖

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4};

        //插入排序
        for (int i = 1; i < arr.length; i++) {
            //外層循環，從第二個開始比較
            for (int j = i; j > 0; j--) {
                //內存循環，與前面排好序的數據比較，若是後面的數據小於前面的則交換
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = temp;
                } else {
                    //若是不小於，說明插入完畢，退出內層循環
                    break;
                }
            }
        }
    }

---

教材學習中的問題和解決過程

• 問題1：二分查找是否是必定要比順序查找效率更高一點呢

• 問題1解決方案：二分查找有它自身的限制,就是必定要在有序數組中查找,不然會出現錯誤.
  所以應該在有序數組中使用二分查找,無序數組中使用順序查找更好

• 問題2：在二分搜索中，會從中間開始分段，就像數學中的二分法同樣，可是若是全部的排列數是偶數，這樣的話，中間就沒有數字，這種狀況下該怎麼辦？

• 問題2解決方案：這個問題是我看書不夠仔細，後來在書中找到了這種狀況下該怎麼辦。應該忽略小數部分，取兩個中點的第一個爲新的中點。而後繼續搜索。

代碼調試中的問題和解決過程

• 問題1：快速排序卡死i=j=5的進程中
  

• 問題1解決方案：
  把while(i <= j)改爲while(i!=1)

代碼託管

（statistics.sh腳本的運行結果截圖）

---

上週考試錯題總結

上週無考試
____

結對及互評

評分標準

• 基於評分標準，我給本博客打分：14分。得分狀況以下：

1. 正確使用Markdown語法（加1分）：

   • 不使用Markdown不加分

   • 有語法錯誤的不加分（連接打不開，表格不對，列表不正確...）

   • 排版混亂的不加分

2. 模板中的要素齊全（加1分）
   • 缺乏「教材學習中的問題和解決過程」的不加分
   • 缺乏「代碼調試中的問題和解決過程」的不加分
   • 代碼託管不能打開的不加分
   • 缺乏「結對及互評」的不能打開的不加分
   • 缺乏「上週考試錯題總結」的不能加分
   • 缺乏「進度條」的不能加分
   • 缺乏「參考資料」的不能加分

3. 教材學習中的問題和解決過程, 一個問題加1分

4. 代碼調試中的問題和解決過程, 一個問題加1分

5. 本週有效代碼超過300分行的（加2分）
   • 一週提交次數少於20次的不加分
6. 其餘加分：
   • 感想，體會不假大空的加1分
   • 排版精美的加一分
   • 進度條中記錄學習時間與改進狀況的加1分
   • 有動手寫新代碼的加1分
   • 課後選擇題有驗證的加1分
   • 代碼Commit Message規範的加1分
   • 錯題學習深刻的加1分
   • 點評認真，能指出博客和代碼中的問題的加1分
   • 結對學習狀況真實可信的加1分

• 參考示例

點評過的同窗博客和代碼

• 本週結對學習狀況
  • 20182318
  • 20182333
  • 結對學習內容
    • 對一些程序漸進複雜度的計算
    • 對棧的一些討論和學習。包括出棧，入棧，刪除等等
• 對隊列的一些討論和學習。包括鏈表和數組實現隊列，入隊、出隊等等
• 上週博客互評狀況
  • 20182333

  • 20182318

    其餘（感悟、思考等，可選）

通過本週的學習,我對曾經學過的知識有了更深一步的瞭解同時對數據查找和排序等方法的應用也更加熟悉，同時也弄懂了一些過去不是很懂的知識點可謂是受益不淺。

學習進度條

	代碼行數（新增/累積）	博客量（新增/累積）	學習時間（新增/累積）	重要成長
目標	5000行	30篇	400小時
第一週	126/126	2/2	20/20
第二週	0/126	2/2	20/40
第三週	353/479	2/6	20/60
第四周	1760/2239	2/8	30/90
第五週	1366/3615	2/10	20/110
第六週	534/4149	2/12	20/130
第七週	2800/6949	2/12	20/150
第八週	883/7832	2/12	20/170

參考資料

• 《Java程序設計與數據結構教程（第二版）》

• 《Java程序設計與數據結構教程（第二版）》學習指導