20172309 《Java软件结构与数据结构》实验三报告

课程：《程序设计与数据结构（下）》
班级：1723
姓名： 王志伟
学号：20172309
实验教师：王志强老师
实验日期：2018年11月2日
必修/选修： 必修

实验内容：

实验一：

实验二：

实验三：

• 参考链接

实验四：

实验五：

实验过程及结果：

实验一：

• 定义一个Searching和Sorting类，并在类中实现linearSearch（教材P162 ）,SelectionSort方法（P169）。
  • Searching类的实现linearSearch方法。

   public static <T> boolean linearSearch(T[] data, int min, int max, T target)
   {
       int index = min;
       boolean found = false;
  
       while (!found && index <= max)
       {
           found = data[index].equals(target);
           index++;
       }
  
       return found;
   }//顺序/线性查找
  

  这个算法的理念是一个一个查找，直到找到为止。不过个人觉得这个算法的缺点是当有两个目标值时，将不会查到第二个。比如：在数组{1，2，3，4, 5, 5,6 }中查找数字5时，将只能查找到索引为4的数字5，而不会查找到索引值为5的那个。
  • 测试代码：
    
  • 测试结果：
    
  • Sorting的selectsort方法：

  public static <T extends Comparable<T>>//选择排序
   String selectionSort(T[] data) {
   	int min;
   	T temp;
  
   	for (int index = 0; index < data.length - 1; index++) {
   		min = index;
   		for (int scan = index + 1; scan < data.length; scan++)
   			if (data[scan].compareTo(data[min]) < 0)
   				min = scan;
  
   		swap(data, min, index);
   	}
  
   	return Arrays.toString(data);
   }
  

  选择排序的理念就是把一排数列中的东西中的最大（最小）放到最前面并与之交换位置，之后又从剩下的算法中选择出最大（最小）的与第二个项目交换位置·····直至全部完成。这里值得说的一个重点是Arrays.toString(data);这个方法，这个方法的用处是把一个数组自动ToString（），也就是不用自己写toString方法。
  • 代码截图：
    
  • 结果截图：
    
• 要求不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位。
  • 这里要求测试用例需要正常、异常、边界、正序、逆序我感觉有点错误，比如线性查找哪来的正序、逆序测试，选择排序哪来的边界测试。不是很懂，感觉有问题~~~

实验二：

• 把Sorting.java，Searching.java放入cn.edu.besti.cs1723.（姓名首字母+四位学号）包中（例如：cn.edu.besti.cs1723.G2301）。并把测试代码放test包中。
  
  

一开始并不知道cn.edu.besti.cs1723.什么意思，其实到文件中去看就会发现他这并不是一个文件夹，而是cn的文件夹下有edu，edu的文件夹下有besti....

• 重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）
  • 用IDEA测试结果与实验一一样，因此在这不放图。
  • 用命令行进行测试：由于老师没有明确表达必须使用Junit测试，因此我选择了使用main函数测试（因为虚拟机使用命令行还得安装一个Junit.jar包~~~ 而安装包的什么命令都是上学期的事儿了，哪还记得 ？）。
    查找结果：
    
    排序结果：
    
• 开心的是好像IDEA也有命令行模式，不过这是在我做完实验之后才发现的o(╥﹏╥)o
  
  如果没有显示的话，可以手动开启：
  

实验三：

• 代码详情

• 参考http://www.cnblogs.com/maybe2030/p/4715035.html 在Searching中补充查找算法并测试提交运行结果截图。我们将一个个讲解下查找算法：以前在博客中讲过的一笔带过，没讲的是重点

  • 顺序查找：
    • 主要思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表。
    • 时间复杂度为：O(n)
    • 方法代码：

   public static <T extends Comparable<T>>
   boolean binarySearch(T[] data, int min, int max, T target)
   {
       boolean found = false;
       int midpoint = (min + max) / 2;  // determine the midpoint
  
       if (data[midpoint].compareTo(target) == 0)
           found = true;
  
       else if (data[midpoint].compareTo(target) > 0)
       {
           if (min <= midpoint - 1)
               found = binarySearch(data, min, midpoint - 1, target);
       }
  
       else if (midpoint + 1 <= max)
           found = binarySearch(data, midpoint + 1, max, target);
  
       return found;
   
   }//二分查找
  

  • 二分查找：
    • 主要思想：也称为是折半查找，属于有序查找算法。用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。元素必须是有序的，如果是无序的则要先进行排序操作。
    • 时间复杂度：O(log2n)
    • 方法代码:

       public static <T extends Comparable<T>>
   boolean binarySearch(T[] data, int min, int max, T target)
   {
       boolean found = false;
       int midpoint = (min + max) / 2;  // determine the midpoint
  
       if (data[midpoint].compareTo(target) == 0)
           found = true;
  
       else if (data[midpoint].compareTo(target) > 0)
       {
           if (min <= midpoint - 1)
               found = binarySearch(data, min, midpoint - 1, target);
       }
  
       else if (midpoint + 1 <= max)
           found = binarySearch(data, midpoint + 1, max, target);
  
       return found;
       
   }//二分查找
   
  

  • 插值查找：
    • 主要思想:
      1. 基于二分查找，属于有序查找，相对于二分查找有时能够提升效率。
      2. 对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。
      3. 个人觉得最重要的就是这个了：mid=low+(key-a[low])/(a[high]-a[low])*(high-low)为什么是这样？在下面的的问题中讲。
    • 时间复杂度：查找成功或者失败的时间复杂度均为O(log2(log2n))。
    • 方法代码：

    public static   boolean interpolationSearch(int[] data,int low,int high,int target){
     while (low<high) {
         int mid=low+(high-low)*((target-data[low])/(data[high]-data[low]));
         if (target<data[mid]) {
             interpolationSearch(data, low, mid-1, target);
         }
         else if (target>data[mid]) {
             interpolationSearch(data, mid+1, high, target);
         }
         else {
             return data[mid]==target;
         }
     }
     return false;
    

  }//插值查找，不能使用泛型
  ```

  • 斐波那契查找：
    • 主要思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。
    • 斐波那契查找算法
    • 时间复杂度：O(log2n)
    • 方法代码:

     public static boolean FibonacciSearch(int[] data,int target){
    int low = 0;
    int high = data.length - 1;
    int mid = 0;
    // 斐波那契分割数值下标
    int k = 0;
    // 序列元素个数
    int count = 0;
    // 获取斐波那契数列
    int[] f = new int[20];
    int m = 0;
    f[0] = 1;
    f[1] = 1;
    for (m = 2; m < 20; m++) {
        f[m] = f[m - 1] + f[m - 2];
    }
    // 获取斐波那契分割数值下标
    while (data.length > f[k] - 1) {
        k++;
    }
    // 创建临时数组
    int[] temp = new int[f[k] - 1];
    for (int j = 0; j < data.length;j++){
        temp[j] = data[j];
    

  }
  ```

  • 二叉树查找：
    • 主要思想：
      1. 二叉查找树是先对待查找的数据进行生成树，确保树的左分支的值小于右分支的值，然后在就行和每个节点的父节点比较大小，查找最适合的范围。
      2. 这个算法的查找效率很高，但是如果使用这种查找方法要首先创建树。
      3. 对二叉查找树进行中序遍历，即可得到有序的数列。
    • 时间复杂度：它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。
    • 方法代码：

    详情看上面链接
    

  • 分块查找：
    • 主要思想：将n个数据元素"按块有序"划分为m块（m ≤ n）。每一块中的结点不必有序，但块与块之间必须"按块有序"；即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；而第2块中任一元素又都必须小于第3块中的任一元素，……
    • 算法步骤：
    1. 先选取各块中的最大关键字构成一个索引表；
    2. 查找分两个部分：先对索引表进行二分查找或顺序查找，以确定待查记录在哪一块中；然后，在已确定的块中用顺序法进行查找。
    • 时间复杂度：
    • 方法代码：

    //详情看上面链接
    

  • 哈希查找：
    • 主要思想：哈希的思路很简单，如果所有的键都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。这是对于简单的键的情况，我们将其扩展到可以处理更加复杂的类型的键
    • 算法步骤：
      1. 用给定的哈希函数构造哈希表；
      2. 根据选择的冲突处理方法解决地址冲突；常见的解决冲突的方法：拉链法和线性探测法。详细的介绍可以参见：浅谈算法和数据结构: 十一 哈希表。
      3. 在哈希表的基础上执行哈希查找。
    • 时间复杂度：O(1)
    • 方法代码：

    //详情看上面链接
    

实验四：

• 补充实现课上讲过的排序方法：希尔排序，堆排序，二叉树排序等(至少3个)，测试实现的算法（正常，异常，边界）。
  • 希尔排序：
    • 主要思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
    • 举个例子：
      
  • 堆排序：
    • 这个因为以前就写好了最小堆，每次把最小的顶堆取出来，就完成了从小到大的排序。
  • 二叉排序：
    • 和上面一样，因为二叉查找树的左子树小于或等于父结点，父结点小于或等于右结点。所以使用中序遍历就可以完成从小到大的排序。
    • 代码截图：
      
    • 提交运行结果截图。
      

实验五：

• 编写Android程序对各种查找与排序算法进行测试
  • emmm·····本来看到这的时候就准备使用一个下拉列表的，但是做了四五个小时后发现出现了bug，所以为了提交作业只好提交了一种比较low的方法。
  • 运行结果：
    
  • 测试结果：
    
  • 不过在这里学到了一种比较好用的方法：
    • 在xml文件中编写按钮Button控件时，可以使用onclick属性。像这样：

    <Button
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:text="创建数据库"
     **android:onClick="creatDb"**<--这儿
     android:background="#ffbbff"
     />
    

    • 那么这个方法有什么用呢？
      个人总结就是当有很多按钮时，我们不必每个按钮都写点击事件了只要写一个就OK了，例:

    public void onclick(View view){
    switch (条件){
     case R.id.button1：
     ···逻辑代码···
     break；
     case R.id.button2:
     ···逻辑代码···
     break；
     ·····
    }
    
    

试样过程中遇到的问题：

• 问题一：如何进行Junit测试？

• 问题一解决方案：现在自己来总结下吧。

  • emmm·····，首先选中要进行Junit测试的类名并右击：Go to->Generate->Test
    
  • 之后点击Create new Test
    
  • 之后选择Junit4，其次选择要进行测试的方法。
    
  • 之后会看到自动生成的方法：例：

   @Test
   public void shellSort() {
      
   }
  

  • 然后使用assertEquals(参数一，参数二)方法，例：

  @Test
  public void shellSort() {
     assertEquals(预定结果，测试的方法)；
     //例：assertEquals("[2301, 2302, 2303, 2305, 2307, 2309]",Sorting.shellSort(list1,3));//正常
  }
  

• 问题二：插值查找中的mid=low+(key-a[low])/(a[high]-a[low])*(high-low)是怎么来的？

• 问题而解决方案：

• 先举两个例子

  • 打个比方，在英文字典里面查“apple”，你下意识翻开字典是翻前面的书页还是后面的书页呢？如果再让你查“zoo”，你又怎么查？很显然，这里你绝对不会是从中间开始查起，而是有一定目的的往前或往后翻。
  • 同样的，比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5， 我们自然会考虑从数组下标较小的开始查找。

• 经过以上分析，折半查找这种查找方式，不是自适应的（也就是说是傻瓜式的）。二分查找中查找点计算如下：
  　　mid=(low+high)/2, 即mid=low+1/2(high-low);

  • 通过类比，我们可以将查找的点改进为如下：
    　　mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，
  • 也就是将上述的比例参数1/2改进为自适应的，也就是将1/2改进为 (key-a[low])/(a[high]-a[low])。根据关键字在整个有序表中所处的位置，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。

收获感悟：

补博客可真是麻烦，拿起了好久都没动过的IDEA（因为最近在做实战项目）。

参考文献：

• IDEA_junit测试教程
• 希尔排序详解
• 斐波那契查找算法