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 + "
"+ "链表元素为：" + all + "
";
        }
        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 + "
"+ "元素的总数为:" + array.length + "
" ;
        }
        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得到的字符串没有“ ”，在选择排序法中需要的形式有格式限制的。

其他

这次实验我做了好多次，第一次使用了队列的方法，后来得知不可以使用这种方法，第二次使用了一个结点类，但在头插法中发现元素并不能真正插进链表，修改了很久之后放弃该方法，第三次使用了LinearNode类才算顺利。过程坎坷，但也掌握了更多的方法。

参考

• java.lang.NumberFormatException:for input string是什么意思