20162303 实验三 查找与排序

北京电子科技学院（BESTI）

实 验 报 告

课程：程序设计与数据结构
班级： 1623
姓名： 石亚鑫
学号：20162303

成绩： 2分
指导教师：娄嘉鹏 王志强
实验日期：11月6日

实验密级： 非密级
预习程度： 已预习
实验时间：15:25-17:15

必修/选修： 必修
实验序号： cs_03

实验内容

1. 完成教材P302 Searching.Java ,P305 Sorting.java中方法的测试
   不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位
   提交运行结果图（可多张）

2. 重构你的代码
   把Sorting.java Searching.java放入 cn.edu.besti.cs1623.（姓名首字母+四位学号） 包中
   把测试代码放test包中
   重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）
   提交测试代码运行截图，要全屏，包含自己的学号信息
   课下把代码推送到代码托管平台

3. 参考http://www.cnblogs.com/maybe2030/p/4715035.html 在Searching中补充查找算法并测试
   提交运行结果截图

4. 补充实现课上讲过的排序方法：希尔排序，堆排序，桶排序，二叉树排序等
   测试实现的算法（正常，异常，边界）
   提交运行结果截图
   推送相关代码到码云上

实验步骤

(1) 实验一

代码

• 首先定义10个数组用来排序和查找

Integer []arr1= {90,8,7,56,123,235,9,1,653,2303};
        Integer []arr2 = {100,7,37,41,55,21,87,64,258,2303};
        Integer []arr3 = {1,3,5,7,9,11,13,15,17,2303};
        Integer []arr4 = {2303,10,9,8,7,6,5,4,3,2};
        Integer []arr5 = {6,6,6,8,8,8,66,66,88,2303};
        Integer []arr6 = {3,33,333,3333,33333,333333,3333333,33333333,333333333,2303};
        Integer []arr7 = {23,233,2333,23333,233333,32,322,3222,32222,2303};
        Integer []arr8 = {1,2,3,4,5,6,7,8,9,2303};
        Integer []arr9 = {2,0,1,6,2,3,0,3,2,2303};
        Integer []arr10 = {2017,11,6,15,46,21,87,64,258,2303};

• 排序测试关键代码（其他排序代码与此相似）

        System.out.println("90,8,7,56,123,235,9,1,653,2303");
        Sorting.quickSort(arr1,0,9);
        System.out.print("快速排序后：");
        for (int a = 0; a < arr1.length; a++) {
            System.out.print(arr1[a]);
            System.out.print(" ");
        }
        Sorting.selectionSort(arr1);
        System.out.println("");
        System.out.print("选择排序后：");
        for (int a = 0; a < arr1.length; a++) {
            System.out.print(arr1[a]);
            System.out.print(" ");
        }
        Sorting.insertionSort(arr1);
        System.out.println("");
        System.out.print("插入排序后：");
        for (int a = 0; a < arr1.length; a++) {
            System.out.print(arr1[a]);
            System.out.print(" ");
        }
        Sorting.merge(arr1,0,5,9);
        System.out.println("");
        System.out.print("归并排序后：");
        for (int a = 0; a < arr1.length; a++) {
            System.out.print(arr1[a]);
            System.out.print(" ");
        }
        Sorting.bubbleSort(arr1);
        System.out.println("");
        System.out.print("冒泡排序后：");
        for (int a = 0; a < arr1.length; a++) {
            System.out.print(arr1[a]);
            System.out.print(" ");
        }

• 查找测试关键代码（其他代码与此相似）

            Integer found1 = (Integer) Searching.linearSearch(arr1,45);
            if (found1==null)
                System.out.println ("Number1 was not found.");
            else
                System.out.println ("Found1: " + found1);

实现

(2) 实验二

• 创建包 cn.edu.besti.cs1623.syx2303

• 把测试代码放test包中

  截图

  
  

(3) 实验三

• 根据老师所给参考博客思路修改补充代码

参考博客

代码

public static Comparable InsertionSearch (int[] data,
                                           int target)
    {
        Comparable result = null;
        int first = 0, last = data.length-1, mid;
        while (result == null && first <= last)
        {
            mid = first+(target-data[first])/(data[last]-data[first])*(last-first);  // determine midpoint
            if (data[mid]==(target))
                result = data[mid];
            else
            if (data[mid]-(target) > 0)
                last = mid - 1;
            else
                first = mid + 1;
        }
        return result;
    }
    public static Comparable SequenceSearch (Comparable[] data,
                                             Comparable target)
    {
        int i;
        for(i=0; i<data.length; i++)
            if(data[i]==target)
                return target;
        return -1;
    }
    public static Comparable FibonacciSearch (int[] data,
                                             int target)
    {
    /*构造一个斐波那契数组*/
        int max_size=20;//斐波那契数组的长度
        int []F=new int[max_size];
        F[0]=0;
        F[1]=1;
        for(int i=2;i<max_size;++i)
            F[i]=F[i-1]+F[i-2];
    /*定义斐波那契查找法*/
        int low=0;
        int high=data.length-1;
        int k=0;
        while(data.length>F[k]-1)//计算n位于斐波那契数列的位置
            ++k;
        int  [] temp=new int [F[k]-1];;//将数组a扩展到F[k]-1的长度
        for(int i=data.length;i<F[k]-1;++i)
            temp[i]=data[data.length-1];
        while(low<=high)
        {
            int mid=low+F[k-1]-1;
            if(target<temp[mid])
            {
                high=mid-1;
                k-=1;
            }
            else if(target>temp[mid])
            {
                low=mid+1;
                k-=2;
            }
            else
            {
                if(mid<data.length)
                    return mid; //若相等则说明mid即为查找到的位置
                else
                    return data.length-1; //若mid>=n则说明是扩展的数值,返回n-1
            }
        }
        return -1;
    }

实现

(4) 实验四

参考博客

实现

统计自己的PSP(Personal Software Process)时间

步骤	耗时	百分比
需求分析	60min	13.6%
代码实现	300min	68.1%
测试	60min	13.6%
分析总结	20min	4.5%

转载于:https://www.cnblogs.com/syx390234975/p/7821724.html