20172333 2017-2018-2 《程序设计与数据结构下》实验1报告

Posted 2021-01-10 yanyujun527

20172333 2017-2018-2 《程序设计与数据结构下》实验1报告

课程：《程序设计与数据结构》
班级： 1723
姓名： 严域俊
学号：20172333
实验教师：王志强
实验日期：2018年9月30日
必修/选修： 必修

1.实验内容

任务1：

• 链表练习，要求实现下列功能：
• （1）通过键盘输入一些整数，建立一个链表；这些数是你学号中依次取出的两位数，再加上今天的时间。
• 例如你的学号是 20172301
• 今天时间是 2018/10/1， 16：23：49秒
• 数字就是：20， 17，23，1， 20， 18，10，1，16，23，49
• 打印所有链表元素， 并输出元素的总数。
• 在你的程序中，请用一个特殊变量名来纪录元素的总数，变量名就是你的名字。 例如你叫 张三， 那么这个变量名就是：int nZhangSan = 0; //初始化为 0.
• 做完这一步，把你的程序签入源代码控制（git push）。

任务2：

• 链表练习，要求实现下列功能：
• （2）实现节点插入、删除、输出操作
• 继续你上一个程序， 扩展它的功能，每做完一个新功能，或者写了超过10行新代码，就签入代码，提交到源代码服务器；
• 从磁盘读取一个文件， 这个文件有两个数字。
• 从文件中读入数字1， 插入到链表第 5 位，并打印所有数字，和元素的总数。 保留这个链表，继续下面的操作。
• 从文件中读入数字2， 插入到链表第 0 位，并打印所有数字，和元素的总数。 保留这个链表，并继续下面的操作。
• 从链表中删除刚才的数字1. 并打印所有数字和元素的总数。
• 签入所有代码。

任务3：

• 链表练习，要求实现下列功能：
• （3）使用冒泡排序法或者选择排序法根据数值大小对链表进行排序；
• 如果你学号是单数， 选择冒泡排序， 否则选择选择排序。
• 在排序的每一个轮次中， 打印元素的总数，和目前链表的所有元素。
• 在（2）得到的程序中继续扩展， 用同一个程序文件，写不同的函数来实现这个功能。 仍然用 nZhangSan （你的名字）来表示元素的总数。

任务4：

• 数组练习，要求实现下列功能：
• （1）通过键盘输入一些整数，建立一个链表；
• 这些数是你学号中依次取出的两位数。 再加上今天的时间，例如你的学号是 20172301，今天时间是 2018/10/1， 16：23：49秒，
• 数字就是20， 17，23，1， 20， 18，10，1，16，23，49
• 打印所有数组元素， 并输出元素的总数。
• 在你的程序中，请用一个特殊变量名来纪录元素的总数，变量名就是你的名字。 例如你叫 张三， 那么这个变量名就是 int nZhangSan = 0; //初始化为 0.
• 做完这一步，把你的程序签入源代码控制（git push）。
• （2）实现节点插入、删除、输出操作；
• 继续你上一个程序， 扩展它的功能，每做完一个新功能，或者写了超过10行新代码，就签入代码，提交到源代码服务器；
• 从磁盘读取一个文件， 这个文件有两个数字。
• 从文件中读入数字1， 插入到数组第 5 位，并打印所有数字，和元素的总数。 保留这个数组，继续下面的操作。
• 从文件中读入数字2， 插入到数组第 0 位，并打印所有数字，和元素的总数。 保留这个数组，并继续下面的操作。
• 从数组中删除刚才的数字1. 并打印所有数字和元素的总数。
• 签入所有代码。

任务5：

• 数组练习，要求实现下列功能：
• （3）使用冒泡排序法或者选择排序法根据数值大小对数组进行排序；
• 如果你学号是单数， 选择选择排序， 否则选择冒泡排序。
• 在排序的每一个轮次中， 打印元素的总数，和目前数组的所有元素。
• 在（2）得到的程序中继续扩展， 用同一个程序文件，写不同的函数来实现这个功能。 仍然用 nZhangSan （你的名字）来表示元素的总数。

2.实验过程及结果（一共五个实验。）

- 第一个提交点

过程： 第一个任务就是简单的建立一个链表，使用Scanner类来从键盘获得整数以用于建立链表，然后 由于想要不调换输入整数的数据，我需要编写一个后插的方法：

public void add(int num)
    {
        node n=new node(num);
        node p =head;
        if (head ==null)
        {
            n.next=head;
            head =n;

        }else
        {
            while(p.next!=null)
            {
                p=p.next;
            }
            p.next=n;
        }
        nYanyujun++;
    }

最后要求输出链表和链表个数

public String toString()
    {
        String result ="";
        node tem = head;
        while(tem!=null)
        {
            result+= tem.data +" ";
            tem =tem.next;
        }
        return  result;
    }

    public int size()
    {
        return  nYanyujun;
    }

图1结果

- 第二个提交点

过程： 该任务主要是编写三个方法（插入后输出、前插后输出、删除后输出）刚开始写插入方法的时候我看见要求的时候，以为只有两个目标，把头插和普通插入混为一谈了，导致后面用普通插入来实现头插时，插不进去。头插法：

public void addHeadNode(int data)
    {
        node x=new node(data);
        if(head==null){
            head =x;nYanyujun++;
            return;
        }
        x.next=head;
        head=x;
        nYanyujun++;

插入法：

public void insert(int index,int data)
    {
        node n=new node(data);
        node cur =head;
        node pre=head;

        int pos =0;
        while (pos!=index-1)
        {
            pre=cur;
            cur=cur.next;
            pos++;
        }
        n.next=cur;
        pre.next=n;
        nYanyujun++;
    }

删除法：

public Boolean deleteNode(int index)
    {
        if(index<1||index>nYanyujun)
            return false;
        int i=1;
        node p=head;
        while(i!=(index-1))
        {
            p=p.next;
            i++;
        }

        (p.next)=(p.next.next);
        nYanyujun--;
        return true;
    }

当然 还有从文件中读取数据的过程，这个代码说实话我没搞懂，直接在上个学期的代码中拿修改些许后，并测试了一下就拿来用了。
读取数据

try {
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (IOException Exception) {
            System.out.println("错误，指定路径不存在");
        }
        InputStream inputStream1 = new FileInputStream(file);
        while (inputStream1.available() > 0) {
            System.out.println((char) inputStream1.read() + "  ");
        }
        inputStream1.close();
        byte[] buffer = new byte[1024];
        String content = "";
        int flag = 0;
        InputStream inputStream2 = new FileInputStream(file);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream2);
        while ((flag = bufferedInputStream.read(buffer)) != -1) {
            content += new String(buffer, 0, flag);
        }
        bufferedInputStream.close();
        String[] a = new String[10];
        a = content.split(" ");
        String B = a[0];
        String C = a[1];
//        int i = Integer.valueOf(B).intValue();
//        int ii = Integer.valueOf(C).intValue();

结果图2

- 第三个提交点

过程 第三个任务需要使用冒泡或者选择排序，冒泡排序貌似没学过，但是由于要求学号是单数的要用冒泡，就只能在网上借鉴学习自己编写了一个功能貌似一样的冒泡排序，然后就出问题了，题目要求要将每一次的结果输出，我编写的冒泡排序是排序是没问题，但是在输出元素个数的时候永远是0，后来在国庆第一天我改了两个小时候无果，心态又爆炸了，然后想了想反正从头到尾个数都没变化就直接在元素个数手动写好了。冒泡排序

public static node bubbleSort(node head){
        shiyan shiiyan =new shiyan();
        if(head == null || head.next == null)
            return head;

        node cur = null, tail = null;

        cur = head;

        while(cur.next != tail){
            while(cur.next != tail){
                if(cur.data > cur.next.data){
                    int tmp = cur.data;
                    cur.data = cur.next.data;
                    cur.next.data = tmp;

                }
                cur = cur.next;
            }
            System.out.println("排序后结果："+shiiyan.toString());
            System.out.println("元素数量：12" );
            tail = cur;
            cur = head;
        }

        return head;


    }

结果图3

前三个实验提交图

- 第四个提交点

过程 该任务和前三个任务需要在另外一个java程序中进行，其实大致内容差不多，大致就是用数组来完成之前的任务（建立数组、表示数组的内容、数组的元素个数、插入、删除）

显示内容方法

public void tostring(String[]a)
    {
        System.out.print("整个数组是：");
        for (int k = 0; k<=a.length-1; k++)
        {
            System.out.printf(a[k] +" ");
            nYanYuJun =k+1;
        }
    }

数组元素个数

 public int size()
    {
        return nYanYuJun;
    }

数组插入方法

public void insert(int index, String num) {
        String[] result = new String[nYanYuJun + 1];

        if (index == 0) {
            result[0] = num;
            for (int a = 0; a < nYanYuJun; a++) {
                result[a + 1] = K[a];
            }
        } else {
            if (index == nYanYuJun) {
                for (int a = 0; a < nYanYuJun; a++) {
                    result[a] = K[a];
                }
                result[nYanYuJun + 1] = num;
            } else {
                result[index] = num;
                for (int a = 0; a < nYanYuJun; a++) {
                    if (a < index)
                        result[a] = K[a];
                    else
                        result[a + 1] = K[a];
                }
            }
        }
        K = result;

    }

数组删除方法

protected void Delete(int index) {
        String[] L = new String[nYanYuJun - 1];
        if (index == 0)
        {
            for (int a = 0; a < nYanYuJun - 1; a++) {
                L[a] = K[a + 1];
            }

        } else {
            if (index == nYanYuJun - 1) {
                for (int a = 0; a < nYanYuJun - 1; a++) {
                    L[a] = K[a];
                }
            } else {
                for (int a = 0; a < nYanYuJun - 1; a++) {
                    if (a < index)
                        L[a] = K[a];
                    else
                        L[a] = K[a + 1];
                }
            }
        }
        K = L;
        nYanYuJun--;
    }

实验结果4

- 第五个提交点

过程 该任务就是数组的排序方法的实现，由于之前我在排的时候，排序方法要用某个int型数组，最后我却只有个string数组，需要进行转化，后来我问同学，共同弄了个转换的方法所以我的排序方法会有两个。Sort的方法名才是最后要使用的那个。

public static void sort(int[] arr)
    {
        int index;
        for(int i=1;i<arr.length;i++){
            index=0;
            for(int j=1;j<=arr.length-i;j++){
                if(arr[j]>arr[index]){
                    //查找最大值
                    index=j;
                }
            }
            //交换在arr.length-i和index（最大值）位置的两个数
            int temp=arr[arr.length-i];
            arr[arr.length-i]=arr[index];
            arr[index]=temp;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }

    }
    public void Sort()
    {
        int[] A = new int[nYanYuJun];
        for (int i = 0; i < nYanYuJun; i++) {
            A[i] = Integer.valueOf(K[i]).intValue();
        }
        shiyan3_4.sort(A);

    }

实验结果图5

实验4—5的上传记录

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

问题1：在进行实验排序的时候，最后输出的排序结果是没有问题的，但是中间过程每一步输出简直爆炸，刚开始是前面所有的排序内容全为0，元素个数没有变化图。

解决：尝试在循环语句中进行修改，具体代码有参考网上别人的循环语句，改成了第二次的样子，然后排序内容每一次都可以进行了，但是它的展现过程有点奇怪，按道理应该是每一步过程换后之后的，但我改好之后展现出来的是每一步将那些元素要动的删掉，在下一步中又将上一步删除的排好放在后面，把下一步应该拿出比较的数字删除，导致每一步的个数不太一样。

问题2：依旧延续第一个问题，在解决了排序内容为0的问题又出现展现的过程不对的情况。

解决：由于对于冒泡排序极度不熟悉，一度删除了全部方法，后来看到网上一个冒泡排序的方法，感觉比其他的冒泡排序的要简单一些，就尝试用它改成每一步显示的那种方法，结果比较如愿，得到了我想要的效果，问题又出来了那就是每一次出来的元素个数永远是0个。

实验码云地址

其他（感悟、思考等）

这是我第一次在国庆第一天就开始做作业，感觉还行，从下午一点开始做，到晚上八点回去。对于链表的概念是清楚的多了，但是有时还是感觉反应有点慢，做方法不能得心应手。
还有最最最重要的事情就是码云用手动拖入上传文件是真真滴好用，垃圾git push / pull

参考资料

Java 密码学算法