学号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程序设计与数据结构教程（第二版）》学习指导