20202314 实验七 《数据结构与面向对象程序设计》实验报告

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

课程:《程序设计与数据结构》
班级: 2023
姓名: 王鑫垚
学号:20202314
实验教师:王志强
实验日期:2021年11月4日
必修/选修: 必修

一、实验内容

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程序对实现各种查找与排序算法进行测试提交运行结果截图推送代码到码云(选做,额外加分)

二、实验过程及结果

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

以下为Junit测试单元代码

 

 1 import junit.framework.TestCase;
 2 import org.junit.Test;
 3 public class LinkedTest extends TestCase {
 4     public  Linked linkedlist;
 5     public static boolean a,b,c,d,e,f,g;
 6     public Linked xuanze ;
 7     public Linked maopao ;
 8     public static String answer,x,y,ori,oan;
 9     static {
10         String[] ex={"03","20","51","81","06","44","23","14"};
11         int i;
12         Linked linkedlist = new Linked();
13         Linked xuanze = new Linked();
14         Linked maopao = new Linked();
15         linkedlist.addFirst(ex[0]);
16         for(i=1;i<7;i++){
17             linkedlist.add(ex[i],i);
18         }
19         linkedlist.addLast(ex[7]);
20         System.out.println(linkedlist);
21         a = linkedlist.Searching("51");
22         b = linkedlist.Searching("98");
23         c = linkedlist.Searching("03");
24         d = linkedlist.Searching("14");
25         e = linkedlist.Searching("06");
26         f = linkedlist.Searching("23");
27         g = linkedlist.Searching("01");
28         if (a){
29             System.out.println("yes");
30         }
31         oan="03->20->51->81->06->44->23->14->NULL";
32         ori=linkedlist.toString();
33         linkedlist.paixu();
34         xuanze=linkedlist;
35         linkedlist.sorting();
36         maopao=linkedlist;
37         answer="03->06->14->20->23->81->51->44->NULL";
38         x=xuanze.toString();
39         y=maopao.toString();
40     }
41     @Test
42     public void testNormal(){
43         assertEquals(true,a);
44     }
45     @Test
46     public void testNormal3(){
47         assertEquals(true,f);
48     }
49     @Test
50     public void testError(){
51         assertEquals(false,b);
52     }
53     @Test
54     public void testError2(){
55         assertEquals(false,g);
56     }
57     @Test
58     public void testBoundary1(){
59         assertEquals(true,c);
60     }
61     @Test
62     public void testBoundary2(){
63         assertEquals(true,d);
64     }
65     @Test
66     public void testNormal2(){
67         assertEquals(true,e);
68     }
69     @Test
70     public void testpaixu(){
71         assertEquals(answer,x);
72     }
73     @Test
74     public void testmaopao(){
75         assertEquals(answer,y);
76     }
77     @Test
78     public void testexample(){
79         assertEquals(oan,ori);
80     }
81 }

 

以下为测试结果通过截图

 

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

 

public boolean Searching(T t){
        Node cur = this.head;
        while(cur != null){
            if(cur.t.equals(t)){
                return true;
            }
            else cur = cur.next;
        }
        return false;
    }
/*以上代码为程序中的搜索方法*/
public void paixu() {
        int cap=this.getSize();
        Node cur ;
        Node a;
        Node b;
        int i;
        int ct=1;
        do {
            cur = this.head;
            a = this.head;
            b = this.head.next;
            i = 0;
            ct=1;
            if (compare(a.t, b.t)) {
                remove(b.t);
                addFirst(b.t);
                i++;
                ct=0;
            } else {
                cur = cur.next;
                i++;
                ct++;
            }
            while (cur.next.next != null) {
                a = cur;
                b = cur.next;
                if (compare(a.t, b.t)) {
                    remove(a.t);
                    remove(b.t);
                    add(b.t, i);
                    add(a.t, i + 1);
                    i++;
                    cur = cur.next;
                    ct=0;
                } else {
                    i++;
                    cur = cur.next;
                    ct++;
                }
            }
            a = cur;
            b = cur.next;
            if (compare(a.t, b.t)) {
                removeLast();
                add(b.t, i);
                ct=0;
            } else {
                ct++;
            }
        }while (ct!=cap);
    }
/*以上代码为程序中的选择排序方法*/
public void sorting(){
        int cap=this.getSize();
        Node a;
        Node b;
        Node temp;
        int i;
        int ct=1;
        int xunhuan=0;
        a=this.head;
        b=a.next;
        temp=this.head;
        // 确定最小的设为this.head
        if (compare(b.t,a.t)){
            temp=b;
            b=b.next;
        }
        else {
            b=b.next;
        }
        do {
            if (b == null) {
                break;
            }
            if (compare(b.t, temp.t)) {
                temp = b;
                b = b.next;
            } else {
                b = b.next;
            }
        }while (b!=null);
            //确定最小的为this.head
            remove(temp.t);
            addFirst(temp.t);
         //找 第2到n-1 小
        a=head.next;
        i=1;
            do{
            temp=a;
            b=a.next;
            do{
                if (b==null){
                    break;
                }
                if(compare(b.t,temp.t)){
                    temp=b;
                    b=b.next;
                }
                else {
                    b=b.next;
                }
            }while (b!=null);
            remove(temp.t);
            add(temp.t,i);
            i++;
            a=a.next;
        }while (a!=null);

    }
/*以上代码为程序中的冒泡排序方法*/

以上排序方法均在自己定义的链表方法中实现。

以下为在Ubuntu中实现的方法

 

结果与期望一致。 

3.参考http://www.cnblogs.com/maybe2030/p/4715035.html ,学习各种查找算法并在Searching中补充查找算法并测试

提交运行结果截图

顺序查找

基本思想:顺序查找也称为线形查找,属于无序查找算法。从数据结构线形表的一端开始,顺序扫描,依次将扫描到的结点关键字与给定值k相比较,若相等则表示查找成功;若扫描结束仍没有找到关键字等于k的结点,表示查找失败。

二分查找

基本思想:也称为是折半查找,属于有序查找算法。用给定值k先与中间结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点。

插值查找

基本思想:基于二分查找算法,将查找点的选择改进为自适应选择,可以提高查找效率。当然,插值查找也属于有序查找。

斐波那契查找

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

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

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

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

树表查找

算法思想:二叉查找树是先对待查找的数据进行生成树,确保树的左分支的值小于右分支的值,然后在就行和每个节点的父节点比较大小,查找最适合的范围。 这个算法的查找效率很高,但是如果使用这种查找方法要首先创建树。

分块查找

算法思想:将n个数据元素"按块有序"划分为m块(m ≤ n)。每一块中的结点不必有序,但块与块之间必须"按块有序",即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字;而第2块中任一元素又都必须小于第3块中的任一元素,以此类推。

哈希查找

算法思想:哈希查找思路:如果所有的键都是整数,那么就可以使用一个简单的无序数组来实现:将键作为索引,值即为其对应的值,这样就可以快速访问任意键的值。

以下展示顺序查找以及二分查找的测试

1.顺序查找

2. 二分查找

public class Bsearch {
    public static int search(int []a, int value, int low, int high)
    {
        int mid = low+(high-low)/2;
        if (a[low]>value||a[high]<value){
            return -1;}
        if(a[mid]>value)
            return search(a, value, low, mid-1);
        else if(a[mid]<value)
            return search(a, value, mid+1, high);
        else return mid;

    }   /*源代码*/
}
import junit.framework.TestCase;
import org.junit.Test;

public class BsearchTest extends TestCase {
     
    public static Bsearch exam;
    public static int[] a;
    public static int num1;
    static {
        exam=new Bsearch();
        int i;
        a=new int[5];
        for (i=0;i<5;i++){
            a[i]=i;                                        /*测试代码*/
        }
        num1=exam.search(a,3,0,4);
    }
    @Test
    public void testNormal(){
        assertEquals(3,num1);
    }
}

测试截图

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

这里我使用了两种排序的方法,即选择排序与冒泡排序

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

3. 实验过程中遇到的问题和解决过程
- 问题1:Junit疯狂报错
- 问题解决方案:对Junit的使用仍不够熟悉,没有将@Test写到正确的地方……

- 问题2:assertEquals()方法不能正确比较

- 问题解决方案:通过我的测试,在静态变量中定义一个变量来表示需要比较的字符串或者boolean型,就可以正确地使用此方法而不异常报错或测试不通过。

## 参考资料

-  [《Java程序设计与数据结构教程(第二版)》](https://book.douban.com/subject/26851579/)

-  [《Java程序设计与数据结构教程(第二版)》学习指导](http://www.cnblogs.com/rocedu/p/5182332.html)
-  ...

 

posted @ 2021-11-10 19:37  20202314王鑫垚  阅读(71)  评论(0编辑  收藏  举报