20192303 2020-2021-1 《資料結構與面向物件程式設計》實驗七報告
課程：《程式設計與資料結構》
班級： 1923
姓名： 楊佳寧
學號：20192303
實驗教師：王志強
實驗日期：2020年11月19日

一、實驗內容
1、定義一個Searching和Sorting類，並在類中實現linearSearch,SelectionSort方法，最後完成測試。
要求不少於10個測試用例，提交測試用例設計情況（正常，異常，邊界，正序，逆序），用例資料中要包含自己學號的後四位
提交執行結果圖。
2、重構你的程式碼
把Sorting.java Searching.java放入 cn.edu.besti.cs1823.（姓名首字母+四位學號） 包中（例如：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方法。使用測試用例進行檢測。

編寫Searching.java

public class Searching {
    public static Comparable linearSearch(Comparable[] data,Comparable target){
        Comparable result = null;
        int index = 0;
        while(result == null && index < data.length){
            if(data[index].compareTo(target)==0)
                result = data[index];
            index++;
        }
        return result;
    }

}
 

編寫Sorting.java

public class Sorting {
    public static void selectionSort(Comparable[] data) {
        int min;
        for(int index=0;index<data.length-1;index++){
            min=index;
            for(int scan=index+1;scan<data.length;scan++)
                if(data[scan].compareTo(data[min])<0)
                    min=scan;
            swap(data,min,index);
        }
    }
    private static void swap(Comparable[] data,int index1,int index2){
        Comparable temp=data[index1];
        data[index1]=data[index2];
        data[index2]=temp;
    }

}
 

public class Contact implements Comparable
{
    private String firstName, lastName, phone;

    public Contact (String first, String last, String telephone)
    {
        firstName = first;
        lastName = last;
        phone = telephone;
    }

    public String toString ()
    {
        return lastName + ", " + firstName + ":  " + phone;
    }

    public int compareTo (Object other)
    {
        int result;
        result = phone.compareTo(((Contact)other).phone);
        return result;
    }


}

編寫測試程式碼

public class Test {
    public static void main(String[] args) {
       Contact[] a=new Contact[5];
        Contact[] b=new Contact[5];

        a[0]=new Contact("a","b","2303");
        a[1]=new Contact("c","d","2019");
        a[2]=new Contact("e","f","2000");
        a[3]=new Contact("g","h","1999");
        a[4]=new Contact("i","j","1923");
        b[0]=new Contact("k","l","123");
        b[1]=new Contact("m","n","234");
        b[2]=new Contact("o","p","345");
        b[3]=new Contact("q","r","456");
        b[4]=new Contact("s","t","567");
        Contact target1 = new Contact("","","123");//小邊界
        Contact target2 = new Contact("","","2303");//大邊界
        Contact target3 = new Contact("","","1923");//正常
        Contact target4 = new Contact("","","234");//正常
        Contact target5 = new Contact("","","345");//正常
        Contact target6 = new Contact("","","0010");//異常
        Contact target7 = new Contact("","","999");//異常


        Contact found[]=new Contact[10];
        found[0] = (Contact)Searching.linearSearch(b,target1);
        found[1] = (Contact)Searching.linearSearch(a,target2);
        found[2] = (Contact)Searching.linearSearch(a,target3);
        found[3] = (Contact)Searching.linearSearch(b,target4);
        found[4] = (Contact)Searching.linearSearch(b,target5);
        found[5] = (Contact)Searching.linearSearch(b,target6);
        found[6] = (Contact)Searching.linearSearch(a,target7);
        found[7] = (Contact)Searching.linearSearch(b,target7);
        found[8] = (Contact)Searching.linearSearch(a,target6);
        found[9] = (Contact)Searching.linearSearch(a,target1);
        for(int i=1;i<=10;i++){
            System.out.println("Test"+i+":");
            if(found[i-1] == null)
                System.out.println("Can't found it!");
            else
                System.out.println("Found:  "+ found[i-1]);
        }

        Sorting.selectionSort(a);//逆序
        Sorting.selectionSort(b);//正序

        System.out.println("Test11:");
        for(Comparable play :a)
            System.out.println(play);
        System.out.println("Test12:");
        for(Comparable play :b)
            System.out.println(play);

    }
}

執行結果截圖：

程式碼截圖：

（2）把Sorting.java和Searching.java放入cn.edu.besti.cs1923.yjn2303包中並重新進行測試。

實驗二的程式碼與實驗一的程式碼基本一致，只需在測試程式碼中匯入包即可

Part1:使用IDEA
執行結果截圖：

Part2:使用命令列

（3）參考http://www.cnblogs.com/maybe2030/p/4715035.html ，學習各種查詢演算法並在Searching中補充查詢演算法並測試

public class Searching2 {
    public static Comparable LinearSearch(Comparable[] data,Comparable target)
    {
        Comparable result=null;
        int index=0;

        while(result==null&&index<data.length)
        {
            if(data[index].compareTo(target)==0)
                result=data[index];
            index++;
        }
        return result;
    }

    //二分查詢
    public static Comparable binarySearch(Comparable[] data,Comparable target)
    {
        Comparable result=null;
        int first=0,last=data.length,mid;

        while(result==null&&first<=last)
        {
            mid=(first+last)/2;
            if(data[mid].compareTo(target)==0)
                result=data[mid];
            else
            if(data[mid].compareTo(target)>0)
                last=mid-1;
            else
                first=mid+1;
        }
        return result;
    }

    //順序查詢
    public static<T>
    boolean linearSearch(T[] data,int min,int max,T target)
    {
        int index=min;
        boolean found=false;

        while(!found&&index<=max)
        {
            found=data[index].equals(target);
            index++;
        }
        return found;
    }
    // 插值查詢
    public static int InsertionSearch(int[] a, int value, int low, int high) {
        int mid = low + (value - a[low]) / (a[high] - a[low]) * (high - low);
        if (a[mid] == value) {
            return mid;
        }
        if (a[mid] > value) {
            return InsertionSearch(a, value, low, mid - 1);
        } else {
            return InsertionSearch(a, value, mid + 1, high);
        }
    }

    // 斐波那契查詢
    public static int Fibonacci(int n) {
        if(n == 0) {
            return 0;
        }
        if(n == 1) {
            return 1;
        }
        return Fibonacci(n - 1) + Fibonacci(n - 2);
    }

    public static int FibonacciSearch(int[] data,int n,int key) {
        int low = 1;
        int high = n;
        int mid;

        int k = 0;
        while (n > Fibonacci(k) - 1) {
            k++;
        }
        int[] temp = new int[Fibonacci(k)];
        System.arraycopy(data, 0, temp, 0, data.length);
        for (int i = n + 1; i <= Fibonacci(k) - 1; i++) {
            temp[i] = temp[n];
        }

        while (low <= high) {
            mid = low + Fibonacci(k - 1) - 1;
            if (temp[mid] > key) {
                high = mid - 1;
                k = k - 1;
            }

            else if (temp[mid] < key) {
                low = mid + 1;
                k = k - 2;
            } else {
                if (mid <= n) {
                    return mid;
                }

                else {
                    return n;
                }
            }
        }
        return 0;
    }
}

測試程式碼

import junit.framework.TestCase;

public class Searching2Test extends TestCase {


    Integer[] a = {20, 19, 23, 3, 2303, 20, 11, 22, 26, 45, 11, 19};
    Integer[] b = {13, 14, 15, 11, 19, 20, 3,23,2303,24,47,56};
    Searching2 searching = new Searching2();

    @org.junit.Test
    public void testLinearSearch() {
        assertEquals(2303, searching.LinearSearch(a, 2303));//大邊界
        assertEquals(2303, searching.LinearSearch(b, 2303));//大邊界
        assertEquals(null, searching.LinearSearch(a, 0));//異常
        assertEquals(null, searching.LinearSearch(b, 0));//異常
        assertEquals(3, searching.LinearSearch(a, 3));//小邊界
        assertEquals(3, searching.LinearSearch(b, 3));//小邊界
        assertEquals(22, searching.LinearSearch(a, 22));//正常
        assertEquals(11, searching.LinearSearch(b, 11));//正常
        assertEquals(23, searching.LinearSearch(a, 23));//正常
        assertEquals(23, searching.LinearSearch(b, 23));//正常
    }

    @org.junit.Test
    public void testbinarySearch() {
        // 正常測試
        Comparable list[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2303};
        // 元素在所查詢的範圍內
        assertEquals(2, Searching2.binarySearch(list, 2));
        assertEquals(2303, Searching2.binarySearch(list, 2303)); //邊界測試
        //異常
        assertEquals(null, Searching2.binarySearch(list, 0));
    }

    @org.junit.Test
    public void testinsertionSearch() {
        int list[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2303};
        // 元素在所查詢的範圍內
        assertEquals(1, Searching2.InsertionSearch(list, 2, 0, 10));
        assertEquals(10, Searching2.InsertionSearch(list, 2303, 0, 10)); //邊界測試
    }

    @org.junit.Test
    public void testfibonacciSearch() {
        // 正常測試
        int list[] = {2, 23, 42,456, 2303};
        // 元素在所查詢的範圍內
        assertEquals(3, Searching2.FibonacciSearch(list, 4, 456));
        assertEquals(4, Searching2.FibonacciSearch(list, 4, 2303)); //邊界測試
    }
}

執行結果截圖：

（4）補充排序演算法：

public class Sorting3 {

    //選擇排序
    public static void selectionSort(Comparable[] data) {
        int min;
        for (int index = 0; index < data.length - 1; index++) {
            min = index;
            for (int scan = index + 1; scan < data.length; scan++)
                if (data[scan].compareTo(data[min]) < 0)
                    min = scan;

            swap(data, min, index);
        }
    }

    private static void swap(Comparable[] data, int index1, int index2) {
        Comparable temp = data[index1];
        data[index1] = data[index2];
        data[index2] = temp;
    }




    public static void ShellSort(int[] data)
    {
        int m = 0;
        int temp = 0;
        //  每次將步長縮短為原來的一半
        for (int gap = data.length / 2; gap > 0; gap =gap/2)
        {
            for (int i = gap; i < data.length; i++)
            {   //temp儲存索引為初始gap的值
                temp = data[i];
                //從i開始，
                for (m = i; m >= gap; m = m-gap)
                {  //將按步長分好的同組元素進行比較
                    if(temp < data[m - gap])
                    {//升序
                        data[m] = data[m - gap];
                    }
                    else
                    {
                        break;
                    }
                }
                data[m] = temp;
            }

        }
    }
}

測試程式碼：

import org.junit.Test;
import junit.framework.TestCase;
public class Sorting3Test extends TestCase {

    @org.junit.Test
    public void testshellSort() {
        int list[] = {1,2,3,4,19,20,23};
        // 正常測試+邊界測試
        int list1[] = {4,3,2,1,23,20,19};
        Sorting3.ShellSort(list1);
        assertEquals(list1[0], list[0]);//邊界
        assertEquals(list1[3],list[3]);//正常
        // 異常測試
        /*int listerror[] = {1,2,3,4,19,20,23};
        Sorting3.ShellSort(listerror);
        assertEquals(list[9],list[9]);*/


    }
}

三、實驗中遇到的問題及解決過程
問題1：使用命令列進行編譯時，出現“編碼GDK的不可對映字元（0x8c）”
問題1解決方法：在需要進行編譯的程式前加“-encoding UTF-8”即可

四、其他（感悟、思考等）
這次的實驗學習了眾多的查詢以及排序演算法，在編碼過程中，我們需要先弄清每種演算法的原理。雖然最終得出的結果是相同的，但不同的程式碼在效率上是有差別的。

五、參考資料
《JAVA程式設計與資料結構教程（第二版）》
《JAVA程式設計與資料結構教程（第二版）學習指導》