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

課程：《程式設計與資料結構》

班級： 1923

姓名： 楊坤

學號：20192320

實驗教師：王自強

實驗日期：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.實驗結果與執行截圖

sorting程式碼

package Chapter13;

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]);
        }
    }
    //快速排序
    public void quickSort(int[] data)
    {
            subQuickSort(data, 0, data.length - 1);
        for(int i=0;i<data.length;i++)
        {
            System.out.println("test"+"["+i+"]"+": "+data[i]);
        }
    }

    private void subQuickSort(int[] data, int start, int end)
    {
        if (start >= end)
        {
                return;
        }
        int middleIndex = subQuickSortCore(data, start, end);
        subQuickSort(data, start, middleIndex - 1);
        subQuickSort(data, middleIndex + 1, end);
    }

    private int subQuickSortCore(int[] data, int start, int end)//返回中軸值
    {
        int middleValue = data[start];
        while (start < end)
        {
            while (data[end] >= middleValue && start < end)
            {
                end--;
            }
            data[start] = data[end];
            while (data[start] <= middleValue && start < end)
            {
                start++;
            }
            data[end] = data[start];
        }
        data[start] = middleValue;
        return start;

    }
    //快速排序2
    public void QuickSort(int[] array,int start,int end)
    {
        if(start<end)
        {
            int key=array[start];//初始化儲存基元
            int i=start,j;//初始化i,j
            for(j=start+1;j<=end;j++)
            {
                if(array[j]<key)//如果此處元素小於基元，則把此元素和i+1處元素交換，並將i加1，如大於或等於基元則繼續迴圈
                {
                    int temp=array[j];
                    array[j]=array[i+1];
                    array[i+1]=temp;
                    i++;
                }

            }
            array[start]=array[i];//交換i處元素和基元
            array[i]=key;
            QuickSort(array, start, i-1);//遞迴呼叫
            QuickSort(array, i+1, end);

        }



    }




}

 

search程式碼

package Chapter13;

import java.util.Arrays;

public class Searching<T> {

    public void   linear(int[] data, int target)
    {
        int count=0;
        for(int i = 0; i < data.length; i++) {
            if(data[i]==target){//如果資料存在
                count++;
                System.out.println("找到目標數的下標："+i);//返回資料所在的下標，也就是位置
            }
        }
        if (count==0)
            System.out.println("沒有找到目標數");
        else
            System.out.println("共有"+count+"個");
    }
    public void binarySearch(int[] data,int target)
    {
        int count=0;
        int low,high,mid;
        low=0;
        high=data.length-1;

        while (low<=high)
        {
            mid=(low+high)/2;
            if(data[mid]==target)
            { count++;
                System.out.println("找到目標數的下標："+mid);
                break;//不加這個會死迴圈
            }
            else if (data[mid]>target)
            {
                high=mid-1;
            }
            else
                low=mid+1;
        }
        if (count==0)
            System.out.println("沒有找到目標數");
        else
            System.out.println("共有"+count+"個");

    }
    //使用遞迴
    public  int binSearch(int srcArray[], int start, int end, int target) {
        int mid = (end - start) / 2 + start;
        if (srcArray[mid] == target) {
            return mid;
        }
        if (start >= end) {
            return -1;
        } else if (target > srcArray[mid]) {
            return binSearch(srcArray, mid + 1, end, target);
        } else if (target < srcArray[mid]) {
            return binSearch(srcArray, start, mid - 1, target);
        }
        return -1;
    }
    //插值查詢
    public    int insertSearch(int []data,int  left,int right,int target){
        //注意，不然mid可能會越界
        if(left>right || target<data[0] ||target>data[data.length-1]){
            return -1;
        }

        int mid = left +(right - left) * (target - data[left])/ (data[right] -data[left]);
        int midVal =data[mid];
        if(target > midVal){//向右遞迴
            return insertSearch(data, mid+1, right, target);

        }else if(target < midVal){//向左遞迴
            return insertSearch(data, left, mid-1, target);
        }else {
            return mid;
        }
    }
    //建立斐波那契函式
    //斐波那契數列
    public static int[] fib(int []data) {
        int[] f = new int[data.length];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < data.length; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f;
    }
    //斐波那契查詢
    public  int fibSearch(int[] a, int target) {
        int low = 0;
        int high = a.length - 1;
        int k = 0;
        int mid = 0;
        int f[] = fib(a);
        while (high > f[k] - 1) {
            k++;
        }
        int[] temp = Arrays.copyOf(a, f[k]);
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = a[high];
        }
        while (low <= high) {
            mid = low + f[k - 1] - 1;
            if (target < temp[mid]) {
                high = mid - 1;
                k--;
            } else if (target > temp[mid]) {
                low = mid + 1;
                k -= 2;
            } else {
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }
}
 

測試程式碼：

package Chapter13;

import java.util.Stack;

public class SearchSortTest {
    public static void main(String[] args) {

       int []test=new int[10];
       test[0]=1;
        test[1]=1;
        test[2]=1;
        test[3]=1;
        test[4]=1;
        test[5]=1;
        test[6]=2;
        test[7]=3;
        test[8]=2;
        test[9]=0;

     /* Searching searching=new Searching();
     System.out.println("線性查詢： ");
        searching.linear(test, 1);
       Sorting sorting=new Sorting();
        sorting.selectionSort(test);
        System.out.println("二分查詢： ");
        searching.binarySearch(test, 2);
     System.out.println("遞迴二分查詢： ");
        System.out.println("找到目標數的下標："+searching.binSearch(test, 0, test.length-1, 1));
     System.out.println("插值查詢： ");
        System.out.println("找到目標數的下標："+searching.insertSearch(test, 0, test.length-1, 1));
     System.out.println("斐波那契查詢： ");
     System.out.println("找到目標數的下標："+ searching.fibSearch(test,3));

     *//*Sorting sorting=new Sorting();*//*
        System.out.println("希爾排序： ");
     sorting.shellSort(test);
        *//*Sorting sorting=new Sorting();*//*
        System.out.println("直接插入排序： ");
        sorting.insertSort(test);*/
        Sorting sorting=new Sorting();
        System.out.println("快速排序: ");
        sorting.QuickSort(test,0, test.length-1);
        for(int i=0;i<test.length;i++)
        {
            System.out.println("test"+"["+i+"]"+": "+test[i]);
        }
        }
}

截圖：

3.實驗心得體會

自身的自學能力還要提升，大多數的實驗程式碼都在同學的幫助下完成，在運到困難時，容易感到沮喪，還要多鍛鍊自己。平時也要多加練習。
這是一個新的軟體，一切都是陌生的，在遇到這種問題的時候，多上網蒐集資料是非常必要的，同時多家運用學習的app在上面觀看相關的視訊能夠更好的掌握