20172314 2018-2019-1 实验一《线性结构》实验报告

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

班级： 1723

姓名：方艺雯

学号：20172314

实验教师：王志强

实验日期：2018年9月27日

必修/选修：必修

1、实验内容及要求

实验一-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）实现节点插入、删除、输出操作（2分，3个知识点根据实际情况酌情扣分）；

继续你上一个程序，扩展它的功能，每做完一个新功能，或者写了超过10行新代码，就签入代码，提交到源代码服务器；

从磁盘读取一个文件，这个文件有两个数字。
从文件中读入数字1，插入到链表第 5 位，并打印所有数字，和元素的总数。保留这个链表，继续下面的操作。
从文件中读入数字2，插入到链表第 0 位，并打印所有数字，和元素的总数。保留这个链表，并继续下面的操作。
从链表中删除刚才的数字1. 并打印所有数字和元素的总数。

签入所有代码。
实验一-3

（3）使用冒泡排序法或者选择排序法根据数值大小对链表进行排序（2分）；
如果你学号是单数，选择冒泡排序，否则选择选择排序。
在排序的每一个轮次中，打印元素的总数，和目前链表的所有元素。

在（2）得到的程序中继续扩展，用同一个程序文件，写不同的函数来实现这个功能。仍然用 nZhangSan （你的名字）来表示元素的总数。
实验一-4

（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分，3个知识点根据实际情况酌情扣分）；

继续你上一个程序，扩展它的功能，每做完一个新功能，或者写了超过10行新代码，就签入代码，提交到源代码服务器；

从磁盘读取一个文件，这个文件有两个数字。
从文件中读入数字1，插入到数组第 5 位，并打印所有数字，和元素的总数。保留这个数组，继续下面的操作。
从文件中读入数字2，插入到数组第 0 位，并打印所有数字，和元素的总数。保留这个数组，并继续下面的操作。
从数组中删除刚才的数字1. 并打印所有数字和元素的总数。

签入所有代码。
实验一-5

（3）使用冒泡排序法或者选择排序法根据数值大小对数组进行排序（2分）；
如果你学号是单数，选择选择排序，否则选择冒泡排序。
在排序的每一个轮次中，打印元素的总数，和目前数组的所有元素。

在（2）得到的程序中继续扩展，用同一个程序文件，写不同的函数来实现这个功能。仍然用 nZhangSan （你的名字）来表示元素的总数。

实验过程及结果

实验1-1

主要代码：

@Override
    //打印链表
    public String Print() {

        String result = "";
        LinearNode <T>temp = head;
        while(temp != null){
            result += temp.getElement()+ " ";
            temp = temp.next;
        }
        return result;

    }

    @Override
    //链表长度
    public int size() {
        return nFangYiWen;
    }
    @Override
    //尾插法
    public void add(T t){
        LinearNode<T> node = new LinearNode(t);
        LinearNode<T> temp;

        if (head == null) {
            head = node;
        }
        else {
            temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = node;
        }
        nFangYiWen++;
    }

实验1-2

主要代码：

@Override
    //删除指定位置元素
    public void Delete(int where, T num) {
        LinearNode node = new LinearNode(num);
        LinearNode temp1, temp2;
        //头删除
        if ((where == 1) && (head.element.equals(num))) {
            head = head.next;
        } else {
            if (where <= nFangYiWen + 1) {
                temp1 = head;
                temp2 = head.next;
                for (int a = 1; a < where - 1; a++) {
                    temp1 = temp1.next;
                    temp2 = temp2.next;
                }
                //中间删
                if (temp2.element.equals(node.element)) {
                    if (temp2.next != null) {
                        temp1.next = temp2.next;
                    }
                    //尾删
                    else {
                        temp1.next = null;
                    }
                } else {
                    System.out.println("删除错误");
                }
            } else {
                System.out.println("删除错误");
            }
        }
        nFangYiWen--;
    }

实验1-3

主要代码：

 public String SelectSort() {
        String result = "";
        String[] strings = this.Print().split(" ");
        int[] a = new int[nFangYiWen];

        for (int i = 0; i < a.length - 1; i++) {
            int y = Integer.parseInt(strings[i]);
            a[i] = y;
        }

        for (int i = 0; i < a.length - 1; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] < a[j]) {
                    int min = a[i];
                    a[i] = a[j];
                    a[j] = min;
                }
            }
            String all = "";
            for (int s = 0; s < a.length; s++) {
                all += a[s] + " ";
            }
            result += "元素总数为：" + a.length + "\n"+ "链表元素为：" + all + "\n";
        }
        return result;
    }

实验1-4

主要代码：

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

    public int size(){
        return nFangYiWen;
    }

    public void Insert(int n,String num){
        int y =Array.length+1;
        String []result = new String[y];

        if (n==0){
            result[0]=num;
            for (int a=0;a<Array.length;a++)
            {
                result[a+1]=Array[a];
            }
        }
        else
        {
            if (n==Array.length){
                for (int a=0;a<Array.length;a++){
                    result[a]=Array[a];
                }
                result[Array.length+1]=num;
            }

            else {
                result[n]=num;
                for (int a=0;a<Array.length;a++){
                    if (a<n)
                        result[a]=Array[a];
                    else
                        result[a+1]=Array[a];
                }
            }
        }
        Array=result;
        nFangYiWen=Array.length;
    }

    public void  Delete(int n){
        String []result=new String[Array.length-1];

        if (n==0){
            for (int a=0;a<Array.length-1;a++)
            {
                result[a]=Array[a+1];
            }
        }
        else
        {
            if (n==Array.length-1){
                for (int a=0;a<Array.length-1;a++){
                    result[a]=Array[a];
                }
            }

            else {
                for (int a=0;a<Array.length-1;a++){
                    if (a<n)
                        result[a]=Array[a];
                    else
                        result[a]=Array[a+1];
                }
            }
        }
        Array=result;
        nFangYiWen=Array.length;
    }

实验1-5

主要代码：

//冒泡排序
    public String Sort(){
        String result2="";
        int[]array=new int[nFangYiWen];

        for (int a=0;a<nFangYiWen;a++ ){
            array[a]=Integer.parseInt(Array[a]);
        }

        for (int i = 0; i < array.length - 1; i++) {
            //遍历次数
            for (int j = 0; j < array.length - 1 - i; j++) {
                //每次遍历的排序
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
                }
            String every = "";
            for (int a = 0; a < array.length; a++) {
                every += array[a] + " ";
            }
            result2 += "链表元素为：" + every + "\n"+ "元素的总数为:" + array.length + "\n" ;
        }
        return result2;
    }

遇到的问题及解决

问题一：在排序时，要求每轮排序输出元素总数，而我显示的元素总数一直是1

问题一解决：我之前的排序代码为：

public Number selectionSort(Number Head) {
    //选择排序法,大的在左
    int temp;
    Number xxx = Head;
    //while (xxx != null) {
        Number s = xxx.next;
        while (s != null) {
            if (s.number > xxx.number) {
                temp = s.number;
                s.number = xxx.number;
                xxx.number = temp;
            }
            s = s.next;
            LinkedList3 linkedlist3 = new LinkedList3();
            System.out.println("链表元素是：");
            linkedlist3.Print(Head); ;
            System.out.println();
            System.out.println("元素总数为："+ linkedlist3.size());
        }
   //     xxx = xxx.next;
 //   }
    return Head;
}

其中的linkedlist3新声明的，并不是指正在排序的那条链表，linkedlist3.size()执行如下操作

public int size() {
    return nFangYiWen+1;
}

相当于0+1，所以元素总数一直是1.正确的应该是

public  Number selectionSort(Number Head) {
    //选择排序法,大的在左
    int temp;
    Number xxx = Head;
    while (xxx != null) {
        Number s = xxx.next;
        while (s != null) {
            while (s.number > xxx.number) {
                temp = s.number;
                s.number = xxx.number;
                xxx.number = temp;
            }
            s = s.next;
        }
        xxx=xxx.next;
        System.out.println();
        System.out.print("链表元素是：");
        Print(Head);
        System.out.println();
        System.out.println("元素总数为：" + size());
    }
        return Head;
}

问题二：元素重复出现问题
问题二解决：之前的错误代码为
```
while(num.hasMoreTokens()) {
        int i = Integer.parseInt(num.nextToken());
        Number number = new Number(i);
        Number Head = new Number(i);
        xxx.add(Head,number);
        xxx.Print(Head);
    }
```
这样的话每次while循环中，i有一个新的值，Head也为新的值，完整的链表还未形成，所以每次打印出一个Head,一个number，将xxx.Print(Head)移到while循环外即可。
问题三：运行程序抛出错误java.lang.NumberFormatException:For input String
问题三解决：在网上查找解决办法得知是因为

当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常
也就是说你的字符串有问题

仔细检查代码后发现

应为

因为.toString得到的字符串没有“ ”，在选择排序法中需要的形式有格式限制的。