20192321 2020-2021-1 《資料結構與面向物件程式設計》實驗七報告

阿新 • • 發佈：2020-11-29

20192321 實驗七《資料結構與面向物件程式設計》實驗報告

課程：《程式設計與資料結構》
班級：1923
姓名：李錦程
學號：20192321
實驗教師：王志強
實驗日期：2020年11月19日
必修/選修：必修

1.實驗內容

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程式對實現各種查詢與排序演算法進行測試
提交執行結果截圖
推送程式碼到碼雲（選做，加分）

2.實驗過程及結果

定義Searching和Sorting類並測試

Searching類

package cn.edu.besti.cs1923.G2321;

public class Searching
{

    public boolean order(int[] arr,int target){
        int i=0;
        int a = target;
        while(arr[i]!=target)
        {
            i++;
            if(i==arr.length)
                break;
        }
        return i==arr.length?false:true;
    }

    public void sort(int arr[]){
        for(int i =1;i<arr.length;i++) {
            for(int j=0;j<arr.length-i;j++) {
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];

                    arr[j]=arr[j+1];

                    arr[j+1]=temp;
                }
            }
        }
    }

    public boolean binary(int[] arr,int min,int max,int mid,int target){
        boolean found = false;
        mid = (min + max) / 2;
        int midd = mid;

        if(arr[midd]==target)
            found = true;
        else if (arr[midd]!=target)
        {
            if(target<arr[midd])
            {
                max = midd-1;
                midd--;
                found = binary(arr,min,max,midd,target);
            }
            else if(target>arr[midd])
            {
                min = midd+1;
                midd++;
                found = binary(arr,min,max,midd,target);
            }
        }
        return found;
    }

    public int binaryshow(int[] arr,int min,int max,int mid,int target){
        int found = 0;
        mid = (min + max) / 2;
        int midd = mid;

        if(arr[midd]==target)
            found = arr[midd];
        else if (arr[midd]!=target)
        {
            if(target<arr[midd])
            {

                max = midd-1;
                midd--;
                found = binaryshow(arr,min,max,midd,target);
            }
            else if(target>arr[midd])
            {
                min = midd+1;
                midd++;
                found = binaryshow(arr,min,max,midd,target);
            }
        }
        return found;
    }

    public int[] hash(int[] arr){
        int[] arr1 = {0,0,0,0,0,0,0,0,0,0,0,0};
        for(int i=0;i<arr.length;i++)
        {
            if(arr1[arr[i]%11] == 0)
                arr1[arr[i]%11] = arr[i];
            else
            {
                for(int j=2;j<arr.length;j++)
                    if(arr1[j-1] == 0)
                    {
                        arr1[j-1] = arr[i];
                        break;
                    }
            }
        }
        return arr1;
    }

    public int hashsearch(int[] result,int target){
        int k = target%11,i,re = 0;
        if(result[k]==target)
            re =  result[k];
        else
        {
            for(i=k;k<result.length;k++)
            {
                if(result[k]==target)
                {
                    re = result[k];
                    break;
                }
            }
        }
        return re;
    }

    public Linked[] linkedhash(Linked[] linked){
        Linked[] arr1 = new Linked[12];
        int i;
        for(i=0;i<12;i++)
            arr1[i] = new Linked(0);
        for(i=0;i<linked.length;i++)
        {
            if((arr1[linked[i].getnum()%11]).getnum() == 0)
                arr1[linked[i].getnum()%11] = linked[i];
            else
            {
                arr1[linked[i].getnum()%11].setNext(linked[i]);
            }
        }
        return arr1;
    }

    public int linkedsearch(Linked[] re1, int target){
        int k = target%11,i,re = 0;
        if(re1[k].getnum()==target)
            re = re1[k].getnum();
        else
        {
            Linked re2 = re1[k].getNext();
            //re2 = new Linked(0);
            if(re2.getnum()==target)
                re = re2.getnum();
        }
        return re;
    }

    public static boolean FibonacciSearch(int[] table, int keyWord) {
        //確定需要的斐波那契數
        int i = 0;
        while (getFibonacci(i) - 1 == table.length) {
            i++;
        }
        //開始查詢
        int low = 0;
        int height = table.length - 1;
        while (low <= height) {
            int mid = low + getFibonacci(i - 1);
            if (table[mid] == keyWord) {
                return true;
            } else if (table[mid] > keyWord) {
                height = mid - 1;
                i--;
            } else if (table[mid] < keyWord) {
                low = mid + 1;
                i -= 2;
            }
        }
        return false;
    }

    public static int getFibonacci(int n) {
        int res = 0;
        if (n == 0) {
            res = 0;
        } else if (n == 1) {
            res = 1;
        } else {
            int first = 0;
            int second = 1;
            for (int i = 2; i <= n; i++) {
                res = first + second;
                first = second;
                second = res;
            }
        }
        return res;
    }

    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 a[mid];
        if (a[mid] > value)
            return InsertionSearch(a, value, low, mid - 1);
        else
            return InsertionSearch(a, value, mid + 1, high);
    }

    public static int blocking(int[] arr,int target){
        int[] ar1 = new int[arr.length];
        int[] ar2 = new int[arr.length];
        int[] ar3 = new int[arr.length];
        int i=0,j=0,k=0,l=0;
        int result = 0;
        for(i=0;i<arr.length;i++)
        {
            if(0<=arr[i]&&arr[i]<=20)
            {
                ar1[j] = arr[i];
                j++;
            }
            else if (20<arr[i]&&arr[i]<=60)
            {
                ar2[k] = arr[i];
                k++;
            }
            else
            {
                ar3[l] = arr[i];
                l++;
            }
        }
        i=0;
        if(0<=target&&target<=20)
        {
            for(i=0;i<ar1.length;i++)
                if(ar1[i]==target)
                {
                    result = ar1[i];
                    break;
                }
        }
        else if (20<target&&target<=60)
        {
            for(i=0;i<ar2.length;i++)
                if(ar2[i]==target)
                {
                    result = ar2[i];
                    break;
                }
        }
        else
        {
            for(i=0;i<ar3.length;i++)
                if(ar3[i]==target)
                {
                    result = ar3[i];
                    break;
                }
        }
        return result;
    }

    public static void ShellSort(int[] data)
    {
        int i= 0, temp = 0, j = 2;
        for (int incr = data.length / j; incr > 0; incr /= j)
        {
            for (int x = incr; x < data.length; x++)
            {
                temp = (int) data[x];
                for (i = x - incr; i >= 0; i -= incr)
                {

                    if (temp < (int) data[i])
                        data[i + incr] = data[i];
                    else
                        break;
                }
                data[i + incr] = temp;
            }
        }
    }

    public String print(int[] arr){
        String result = "";
        for(int i=0;i<arr.length;i++)
            result += ""+arr[i]+" ";
        return result;
    }
}

Sorting類

package cn.edu.besti.cs1923.G2321;

public class Sorting {


    public void selectionSort(int[] data)
    {
        int min=0;//記錄最小的數
        for(int i=0;i<data.length;i++)
        {

            for (int j=i+1;j<data.length;j++)
            {
                if(data[i]>data[j])
                {min=data[j];
                data[j]=data[i];
                data[i]=min;}

            }

        }
        for(int i=0;i<data.length;i++)
        {
            System.out.println("test"+"["+i+"]"+": "+data[i]);
        }
    }
    public void insertSort(int []data)
    {
        int temp;
        int j ;
        for(int i=1;i<data.length;i++)
        {
            temp=data[i];//待插入的數
            for ( j=i-1;j>=0&&data[j]>=temp;j--)
            {
                data[j+1]=data[j];
            }
            data[j+1]=temp;

        }
        for(int i=0;i<data.length;i++)
        {
            System.out.println("test"+"["+i+"]"+": "+data[i]);
        }
    }

    public  void shellSort(int[] data)
    {
        int j = 0;
        int temp = 0;
        //每次將步長縮短為原來的一半
        for (int increment = data.length / 2; increment > 0; increment /= 2)
        {
            for (int i = increment; i < data.length; i++)
            {
                temp = data[i];
                for (j = i; j >= increment&&temp <data[j - increment]; j -= increment)
                {
                    data[j] = data[j - increment];
                }
                data[j] = temp;
            }

        }
        for(int i=0;i<data.length;i++)
        {
            System.out.println("test"+"["+i+"]"+": "+data[i]);
        }
    }

}

測試類

package cn.edu.besti.cs1923.G2321;

import java.util.Scanner;

public class SearchRunTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        Searching asl = new Searching();
        int target = 0,i,j=0;

        int[] arr = {20,19,23,21,68,20,84,27,55,11,10,79};
        System.out.println("列表:");
        System.out.println(asl.print(arr));

/*        asl.sort(arr);
        System.out.println("排序:"+asl.print(arr));*/

/*        System.out.println("順序查詢，輸入要查詢的數:");
        target = scan.nextInt();
        System.out.println("是否找到:"+asl.order(arr,target));
        target = scan.nextInt();
        System.out.println("是否找到:"+asl.order(arr,target));*/

        System.out.println("折半查詢，輸入要查詢的數:");
        target = scan.nextInt();
        System.out.println("是否找到:"+asl.binary(arr,0,11,5,target));
        System.out.println("找到的數是:"+asl.binaryshow(arr,0,11,5,target));

/*        System.out.println("線性探查法查詢，輸入要查詢的數:");
        target = scan.nextInt();
        int result[] = asl.hash(arr);
        int re = asl.hashsearch(result,target);
        if(re==0)
            System.out.println("查詢失敗！陣列中無此數！");
        else
            System.out.println("查詢成功！查詢到的數是:"+re);*/


/*        System.out.println("二叉排序樹查詢，輸入要查詢的數:");
        int a = scan.nextInt();
        Compareable target1;
        target1 = new Compareable(a);
        int[] b = new int[12];
        BinaryTree e=new BinaryTree();
        e.s(arr);
        Compareable tree = e.get();
        boolean k = treesearch.erchashu(tree,target1);
        System.out.println("是否找到:"+k);*/

/*        System.out.println("鏈地址法查詢，輸入要查詢的數:");
        target = scan.nextInt();
        Linked[] linked = new Linked[12];
        for(i=0;i<12;i++)
            linked[i] = new Linked(arr[i]);
        Linked[] re1 = asl.linkedhash(linked);
        int ree = asl.linkedsearch(re1,target);
        if(ree==0)
            System.out.println("查詢失敗！陣列中無此數！");
        else
            System.out.println("查詢成功！查詢到的數是:"+ree);*/

/*        System.out.println("插值查詢，輸入要查詢的數:");
        target = scan.nextInt();
        asl.sort(arr);
        System.out.println("查詢到的數是:"+asl.InsertionSearch(arr,target,0,11));*/

/*        System.out.println("斐波那契查詢，輸入要查詢的數:");
        target = scan.nextInt();
        System.out.println("是否找到:"+asl.FibonacciSearch(arr,target));*/

/*        System.out.println("分塊查詢，輸入要查詢的數:");
        target = scan.nextInt();
        int re1 = asl.blocking(arr,target);
        if(re1==0)
            System.out.println("查詢失敗！陣列中無此數！");
        else
            System.out.println("查詢成功！查詢到的數是:"+re1);
        target = scan.nextInt();
        int re2 = asl.blocking(arr,target);
        if(re2==0)
            System.out.println("查詢失敗！陣列中無此數！");
        else
            System.out.println("查詢成功！查詢到的數是:"+re2);*/
    }
}

執行結果截圖

3.實驗過程中遇到的問題和解決過程

問題1：不能理解雜湊查詢的方法
問題1解決方案：CSDN上查詢相關教程

其他（感悟、思考等）

在這次實驗過程中，我遇到了許多問題，其中既有知識上的漏洞，也有不細心導致的馬虎，這一切都補充，完善，豐富，擴充套件了我的計算機知識體系。在這個過程中，我還進一步熟悉了IDEA這個平臺的使用與執行方式，提高了自己自主學習的能力，為我接下來學習資料結構以及JAVA語言程式設計打下了堅實的基礎，並在不斷探索的過程中逐步提升了自己。