《程序设计与数据结构》实验三报告

学号 2017-2018-2 《程序设计与数据结构》实验三报告

课程：《程序设计与数据结构》

班级： 1723

姓名： 康皓越

学号：20172326

实验教师：王志强

实验日期：2018年11月19日

必修/选修： 必修

1.实验内容

• 实验1：
  定义一个Searching和Sorting类，并在类中实现linearSearch（教材P162）,SelectionSort方法（P169），最后完成测试。要求不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位
  提交运行结果图。
• 实验2：
  重构你的代码。把Sorting.java Searching.java放入cn.edu.besti.cs1723.（姓名首字母+四位学号）包中（例如：cn.edu.besti.cs1723.G2301）把测试代码放test包中，重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）。
• 实验3：
  参考
  博客，补充查找算法，提交运行结果截图。
• 实验4：
  补充实现课上讲过的排序方法：希尔排序，堆排序，二叉树排序等(至少3个)测试实现的算法（正常，异常，边界），提交运行结果截图。
• 实验5：
  编写Android程序对各种查找与排序算法进行测试，提交运行结果截图，推送代码到码云。

2. 实验过程及结果

实验一

• 利用JUnit进行测试，所需的linearSearch、SelectionSort之前已经写好，只需要根据要求进行测试即可。可以提前设置好需要传入equals方法的参数，也可以直接在方法中写。
• 以下是各种测试的情况：
• 
  
  

实验二

• 在虚拟机Linux上进行相关操作，代码都是已经写好的，但是虚拟机出了很多问题，费了一番功夫后就弄好了。
• 这些是在虚拟机上进行建包、测试的结果截图：
• 
  
  
  

实验三

• 除了书上介绍过的查找算法外，这篇博客还介绍了插值查找和斐波那契查找，虽然给出的是C语言代码，但是我们依旧可以理解，并在此基础上给出Java的代码。其中斐波那契查找是二分查找的一种变形，将黄金比例的思想运用在分割数组中，从而提高了效率。
• 实验代码与实验结果：
• 

 public void Fibonacci(int a[]) {
        a = b;
        a[0] = 0;
        a[1] = 1;
        for (int i = 2; i < a.length; i++)
            a[i] = a[i - 1] + a[i - 2];
    }

    public int FibonacciSearch(int array[],int key)  //a为要查找的数组,n为要查找的数组长度,key为要查找的关键字
    {
        if (array == null || array.length == 0) {
            return -1;
        } else {
            int length = array.length;
            int[] fb = makeFbArray(length + 2);
            int k = 0;
            while (length > fb[k] - 1) {// 找出数组的长度在斐波数列（减1）中的位置，将决定如何拆分
                k++;
            }
            int[] temp = Arrays.copyOf(array, fb[k] - 1);
            for (int i = length; i < temp.length; i++) {
                if (i >= length) {
                    temp[i] = array[length - 1];
                }
            }
            int low = 0;
            int hight = array.length - 1;
            while (low <= hight) {
                int middle = low + fb[k - 1] - 1;
                if (temp[middle] > key) {
                    hight = middle - 1;
                    k = k - 1;
                } else if (temp[middle] < key) {
                    low = middle + 1;
                    k = k - 2;
                } else {
                    if (middle <= hight) {
                        return middle;// 此时mid即为查找到的位置
                    } else {
                        return hight;// 此时middle的值已经大于hight,进入扩展数组的填充部分,即最后一个数就是要查找的数。
                    }
                }
            }
            return -1;
        }
    }

实验四

• 补充排序方法，并进行测试。
• 在之前已经实现的二叉查找树和堆的基础上，进行排序。希尔排序，是插入排序的一种变形，我们可以发现，插入排序每次将两个相邻的元素进行比较，然后再根据大小调整。而希尔排序通过将设置一个值，并不断减小其大小，使得一个无序数组不断趋于有序，这样一来，在初始值变为1时，也就是最终执行插入排序时，整个数组已经较为有序，从而提高排序的效率。
• 以下是补充的代码和测试结果：
  

 public String HeapSort(Object a[]){
        String res="";
        HeapSort heapSort= new HeapSort();
        heapSort.HeapSort(a);

        for(int i2 =a.length-1;i2>=0;i2--){
            res += a[i2]+" ";
        }
        return res;
    }

    public <T extends Comparable<T>> String BinaryTreeSort(T a[]){
        Comparable[] B = a;
        LinkedBinarySearchTree lbst = new LinkedBinarySearchTree();
        String res="";
        for(int i=0;i<a.length;i++){
            lbst.addElement(B[i]);
        }

        Object[] sortarray = new Object[a.length];
        for (int i =0;i<a.length;i++){
            sortarray[i]=lbst.removeMin();
        }

        for(int i2 =0;i2<sortarray.length;i2++){
            res += sortarray[i2]+" ";
        }
        return res;
    }


    public  <T extends Comparable<T>> String ShellSort(T[] data, int i){
        int gap = i;
        int length = data.length;
        String res="";

        while(gap>=1){

            for(int index=0;index<length-gap;index++){
                if(data[index].compareTo(data[index+gap])>0)
                    swap(data,index,index+i);
                count2++;
            }
            gap=gap-1;
            ShellSort(data,gap);
        }
        for(int i2 =0;i2<data.length;i2++){
            res += data[i]+" ";
        }
        return res;
    }

实验五

• 将查找排序代码在安卓上实现，很久没有接触安卓，很多操作、方法都已经遗忘，所以从头复习了一遍一些基本的方法，然后将其移植在了安卓上。
• 实验结果，因为较多，就不一一展示，在此节选了部分：

3. 实验过程中遇到的问题和解决过程

• 类转化抛出异常

• 

• 在进行测试时，需要传入参数，因此，将代码部分进行了修改，将方法头申明的泛型改为了具体的数据类型。之后就抛出了异常。按理说，Object类是所有类的父类，但是却不能转化为comparable。为了使前后数据类型相同，我将数组申明为了Object型，但是，我们知道子类可以继承父类的性质，但是，子类的性质父类不一定会有，所以，将我们可以将传入一个comparable的数组，而不是一个object型的。

其他（感悟、思考等）

• 这次实验主要是增强了对相关算法的理解，同时熟悉了AndroidStudio的部分基础操作

参考资料

• http://www.cnblogs.com/maybe2030/p/4715035.html