20202302 2021-2022-1 《数据结构与面向对象程序设计》实验七报告

课程：《程序设计与数据结构》
班级： 2023
姓名：吉相融
学号：20202302
实验教师：王志强
实验日期：2021年11月6日
必修/选修：必修

一、实验内容

1.定义一个Searching和Sorting类，并在类中实现linearSearch,SelectionSort方法，最后完成测试。要求不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位提交运行结果图。

2.重构你的代码把Sorting.java Searching.java放入 cn.edu.besti.cs2023.（姓名首字母+四位学号）包中（例如：cn.edu.besti.cs1823.G2301）把测试代码放test包中重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）

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

4.实现排序方法等(至少3个)测试实现的算法（正常，异常，边界）提交运行结果截图（如果编写多个排序算法，即使其中三个排序程序有瑕疵，也可以酌情得满分）

5.编写Android程序对实现各种查找与排序算法进行测试提交运行结果截图推送代码到码云（选做，额外加分）

二、实验过程及结果

码云地址：https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/Searching.java

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/SearchingTest.java

代码：

public class Searching {
    public static <T>

    boolean linearSearch(T[] date,T target){
        int index;
        date[0] = target;

        for(index = date.length-1; !date[index].equals(target); --index){

        }
        return index == 0 ? false : true;
    }import junit.framework.TestCase;

import org.junit.Test;

public class SearchingTest extends TestCase {
    @Test
    public void test1(){                                                            
        String[] t1 = {" ", "1", "2", "2302", "3", "4"};
        assertEquals(true, Searching.linearSearch(t1, "2"));         //正常
        assertEquals(false, Searching.linearSearch(t1, "0"));        //异常
        assertEquals(true, Searching.linearSearch(t1, "1"));         //边界
    }

    @Test
    public void test2(){
        String[] t1 = {"", "nice", "02", "2302", "20", "20"};
        assertEquals(true, Searching.linearSearch(t1, "2302"));      //正常
        assertEquals(false, Searching.linearSearch(t1, "111"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "nice"));      //边界
    }

    @Test
    public void test3(){
        String[] t1 = {"", "2302", "2323", "2020", "456", "654"};
        assertEquals(true, Searching.linearSearch(t1, "2020"));      //正常
        assertEquals(false, Searching.linearSearch(t1, "222"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "2302"));      //边界
    }

    @Test
    public void test4(){
        String[] t1 = {"", "11", "22", "33", "44", "2302"};
        assertEquals(true, Searching.linearSearch(t1, "2302"));      //正常
        assertEquals(false, Searching.linearSearch(t1, "333"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "11"));        //边界
    }

    @Test
    public void test5(){
        String[] t1 = {"", "9", "8", "7", "2302", "6"};
        assertEquals(true, Searching.linearSearch(t1, "7"));         //正常
        assertEquals(false, Searching.linearSearch(t1, "444"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "9"));         //边界
    }
    @Test
    public void test6(){
        String[] t1 = {"", "44", "789", "26", "2302", "321"};
        assertEquals(true, Searching.linearSearch(t1, "26"));        //正常
        assertEquals(false, Searching.linearSearch(t1, "555"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "44"));        //边界
    }
    @Test
    public void test7(){
        String[] t1 = {"", "23", "66", "2302", "22", "9"};
        assertEquals(true, Searching.linearSearch(t1, "66"));        //正常
        assertEquals(false, Searching.linearSearch(t1, "666"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "23"));        //边界
    }
    @Test
    public void test8(){
        String[] t1 = {"", "2323", "16", "2302", "20", "19"};
        assertEquals(true, Searching.linearSearch(t1, "2302"));      //正常
        assertEquals(false, Searching.linearSearch(t1, "777"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "2323"));      //边界
    }
    @Test
    public void test9(){
        String[] t1 = {"", "566", "665", "1", "2", "2302"};
        assertEquals(true, Searching.linearSearch(t1, "2"));         //正常
        assertEquals(false, Searching.linearSearch(t1, "888"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "566"));       //边界
    }

    @Test
    public void test10(){
        String[] t1 = {"", "33", "3", "abc", "0", "2302"};
        assertEquals(true, Searching.linearSearch(t1, "2302"));      //正常
        assertEquals(false, Searching.linearSearch(t1, "999"));      //异常
        assertEquals(true, Searching.linearSearch(t1, "33"));        //边界
    }
}

2.重构你的代码把Sorting.java Searching.java放入 cn

.edu.besti.cs2023.（姓名首字母+四位学号）包中（例如：cn.edu.besti.cs1823.G2301）把测试代码放test包中重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）

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

顺序查找

基本思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。
复杂度分析：查找成功时的平均查找长度为：（假设每个数据元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;当查找不成功时，需要n+1次比较，时间复杂度为O(n);所以，顺序查找的时间复杂度为O(n)。

二分查找

基本思想：也称为是折半查找，属于有序查找算法。用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。
复杂度分析：最坏情况下，关键词比较次数为log2(n+1)，且期望时间复杂度为O(log2n)；
注：折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，折半查找能得到不错的效率。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。——《大话数据结构》

插值查找

基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，插值查找也属于有序查找。
复杂度分析：查找成功或者失败的时间复杂度均为O(log2(log2n))。
注：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。

斐波那契查找

基本思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。一般将待比较的key值与第mid=（low+high）/2位置的元素比较，比较结果分三种情况。

相等，mid位置的元素即为所求；
大于，low=mid+1;
小于，high=mid-1。
要求开始表中记录的个数为某个斐波那契数小1，及n=F(k)-1;

开始将k值与第F(k-1)位置的记录进行比较(及mid=low+F(k-1)-1),比较结果也分为三种

相等，mid位置的元素即为所求
大于，low=mid+1,k-=2;
小于，high=mid-1,k-=1。

复杂度分析：最坏情况下，时间复杂度为O(log2n)，且其期望复杂度也为O(log2n)。

分块查找

算法思想：将n个数据元素"按块有序"划分为m块（m ≤ n）。每一块中的结点不必有序，但块与块之间必须"按块有序"；即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；而第2块中任一元素又都必须小于第3块中的任一元素，……

哈希查找

算法思想：哈希的思路很简单，如果所有的键都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。这是对于简单的键的情况，我们将其扩展到可以处理更加复杂的类型的键。
复杂度分析：
单纯论查找复杂度：对于无冲突的Hash表而言，查找复杂度为O(1)。

代码码云地址：https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/Searching3.java

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/Searching3Test.java

顺序：

二分：

斐波那契：

分块：

哈希：

4.实现排序方法等(至少3个)测试实现的算法（正常，异常，边界）提交运行结果截图

代码码云地址：https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/Searching3.java

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/Searching3Test.java

5.编写Android程序对实现各种查找与排序算法进行测试提交运行结果截图推送代码到码云

码云地址：https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/AndroidManifest.xml

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/MainActivity.java

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/Node.java

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/Select.java

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/ShowActivity.java

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/activity_main.xml

https://gitee.com/jixiangrong/jxr20202302/blob/master/%E5%AE%9E%E9%AA%8C%E4%B8%83/activity_show.xml

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

1.编写测试类时，Junit总是发生错误，导致无法测试成功。最终在IDEA中重写导入Junit包，才使得测试类成功运行。

2.在用命令行把程序放入包中时，命令行的繁琐操作令我眼花缭乱。最终在虚拟机登录码云后粘贴，减少了很大一部分工作量！体会到了码云的好处，码云yyds！！！！！！

3.还是安卓的使用太太太不熟练了，耗费了很多很多时间，最终也是在学长和同学的帮助下完成，但是自己对于其的熟练度和掌握能力有待提高。

## 其他（感悟、思考等）

安卓太难了太难了太难了，排序的几种方法太难了太难了太难了，命令行太麻烦了太麻烦了太麻烦了。不过，码云yyds！！！！！！

这次实验让我对于排序的实现更多一分了解，但是也认识到自己在实践方面的不足和有待提高，希望自己可以在实践上做得更好。

## 参考资料

- [《Java和Andriod开发学习指南（第二版）人民邮电出版社》]

- [《Java软件结构与数据结构（第三版）清华大学出版社》]

- https://www.cnblogs.com/maybe2030/p/4715035.html

-CSDN

posted @ 2021-11-11 18:39 20202302吉相融阅读(73) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

20202302吉相融