#202023142021-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)
- ...