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

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

课程：《程序设计与数据结构》

班级： 1923

姓名： 邓子彦

学号：20192317

实验教师：王志强

实验日期：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个)
  测试实现的算法（正常，异常，边界）
  提交运行结果截图（如果编写多个排序算法，即使其中三个排序程序有瑕疵，也可以酌情得满分）

2. 实验过程及结果

一、实验一

• 1.实验代码

//Searching类
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;
    }
}

//Sorting类
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 sort(int[] arrays){
        if(arrays == null || arrays.length <= 1){
            return;
        }
        //增量
        int incrementNum = arrays.length/2;
        while(incrementNum >=1){
            for(int i=0;i<arrays.length;i++){
                //进行插入排序
                for(int j=i;j<arrays.length-incrementNum;j=j+incrementNum){
                    if(arrays[j]>arrays[j+incrementNum]){
                        int temple = arrays[j];
                        arrays[j] = arrays[j+incrementNum];
                        arrays[j+incrementNum] = temple;
                    }
                }
            }
            //设置新的增量
            incrementNum = incrementNum/2;
        }

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

}

//Searching测试
public class SearchingTest {
    public static void main(String[] args) {

        int a[]=new int[]{0,1,2,3,4,5,6,7,8,23,17};
        Searching b = new Searching();
        b.linear(a,23);
        b.linear(a,10000);
        b.linear(a,0);
        b.linear(a,17);
    }
}

//Sorting测试
public class SortingTest {
    public static void main(String[] args) {
        int a[]=new int[]{0,1,2,3,4,5,6,7,8,23,17};
        Sorting b = new Sorting();
        b.selectionSort(a);
    }
}

• 2.运行截图
  
  

• 二、实验二

• 1.实验代码

//把Searching类放进 cn.edu.besti.cs1823.（姓名首字母+四位学号） 包中
package cn.edu.besti.cs1923.D2317;

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;
    }
}

//把Sorting类放进 cn.edu.besti.cs1823.（姓名首字母+四位学号） 包中
package cn.edu.besti.cs1923.D2317;

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 sort(int[] arrays){
        if(arrays == null || arrays.length <= 1){
            return;
        }
        //增量
        int incrementNum = arrays.length/2;
        while(incrementNum >=1){
            for(int i=0;i<arrays.length;i++){
                //进行插入排序
                for(int j=i;j<arrays.length-incrementNum;j=j+incrementNum){
                    if(arrays[j]>arrays[j+incrementNum]){
                        int temple = arrays[j];
                        arrays[j] = arrays[j+incrementNum];
                        arrays[j+incrementNum] = temple;
                    }
                }
            }
            //设置新的增量
            incrementNum = incrementNum/2;
        }

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

}

• 2.运行截图
  
  
  

• 三、实验三

• 1.实验代码

//实现二分查找
import cn.edu.besti.cs1923.D2317.Searching;

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

        int a[]=new int[]{0,1,2,3,4,5,6,7,8,23,17};
        Searching b = new Searching();
      //  b.linear(a,23);
      //  b.linear(a,10000);
      //  b.linear(a,0);
      //  b.linear(a,17);
        b.binarySearch(a,23);
        b.binarySearch(a,17);
        b.binarySearch(a,0);
        b.binarySearch(a,10000);
    }
}

• 2.运行截图
  
  

• 四、实验四

• 1.实验代码

//实现希尔排序
import cn.edu.besti.cs1923.D2317.Sorting;

public class SortingTest {
    public static void main(String[] args) {
        int a[]=new int[]{0,1,2,3,4,5,6,7,8,23,17};
        Sorting b = new Sorting();
       // b.selectionSort(a);
        b.sort(a);
    }
}

• 2.运行截图
  

3. 实验过程中遇到的问题和解决过程

• 问题1：太久没有使用命令行操作，把IDEA的文件放进虚拟机之后不知道该怎么运行，一直显示无法识别的命令

• 解决办法：询问已经完成的同学该怎么在命令行中编译和运行从IDEA搬运过去的文件。回答是把文件里面的引用包删去，因为在命令行操作里面没有包可以引用。

• 问题2：把包删去之后依然无法运行程序

• 解决办法：想起之前学命令行操作的时候遇到的问题，尝试把Searching、Sorting的java文件和SearchingTest、SortingTest的java文件放在同一个文件夹里面，然后就可以正常编译和运行了。

4. 实验体会

• 这次的实验刚开始感觉很难，但只要去博客园还有CSDN上搜一搜就能找到很多的实验代码，所以实验进行得不算很艰难，加上这次的实验给的时间很充裕，不知道以后的实验会不会还是这样。这次也复习了一下命令行的知识，果然知识是需要不断温习的，再次打开虚拟机，甚至有些懵，反应了一会才能想起来之前学过的知识和操作。