20172302 《Java软件结构与数据结构》实验一：线性结构实验报告

课程：《Java软件结构与数据结构》

班级： 1723

姓名：侯泽洋

学号：20172302

实验教师：王志强老师

实验日期：2018年9月26日

必修/选修：必修

实验内容

（1）链表练习，要求实现下列功能：通过键盘输入一些整数，建立一个链表，这些数是你学号中依次取出的两位数，再加上今天的时间。打印所有链表元素，并输出元素的总数。
（2）链表练习，要求实现下列功能：实现节点插入、删除、输出操作，继续你上一个程序，扩展它的功能，每做完一个新功能，或者写了超过10行新代码，就签入代码，提交到源代码服务器。
（3）链表练习，要求实现下列功能：使用插入排序法或者选择排序法根据数值大小对链表进行排序。在排序的每一个轮次中，打印元素的总数，和目前链表的所有元素。
（4）数组练习，要求实现下列功能：（1）通过键盘输入一些整数，建立一个数组；（2）实现节点插入、删除、输出操作。签入所有代码。
（5）数组练习，要求实现下列功能：使用插入排序法或者选择排序法根据数值大小对数组进行排序，在排序的每一个轮次中，打印元素的总数，和目前数组的所有元素。

实验过程及结果

(1)实验一

这里是要求我们建立一个整数的链表，并将它们打印出来，同时要记录元素的总数。

我们首先建立一个节点类，这是建立链表的一个前提基础，在这个类里要设置好两个变量，一个是指向下一数字的节点next；另一个就是我们在链表存储的整数。采用方法重载给出两种构造函数。

public class LinearNode<T> {

    public int number;

    public LinearNode next;

    public LinearNode()

    {

        next = null;

    }

    public LinearNode(int number) {

        this.number = number;

        next = null;

    }

}

接下来便是开始建立链表。

实验结果截图：

(2)实验二

首先我们要进行从文件中读取数字这一操作，这里首先要创建File对象，采用输出流进行读取，这里是以字符为单位读取文件内容，一次读一个字节，然后将读取出的字符转换为对应数字，并将它们储存在一个int型数组中。

File file = new File("D:\\JAVA程序设计\\Java-pro\\text.txt");

        Reader reader = null;

        try {

            System.out.println("以字符为单位读取文件内容，一次读一个字节：");

            reader = new InputStreamReader(new FileInputStream(file));

            int tempchar;

            int[] array = new int[2];

            int x = 0;

            while ((tempchar = reader.read()) != -1)

            {

                if (((char) tempchar) != '\r'&&((char) tempchar) != '\n')

                {

                    {

                        array[x]=tempchar-(int)('0');

                        System.out.print((array[x])+" ");

                        x++;

                    }

                }

            }

            reader.close();

} catch (Exception e) {

            e.printStackTrace();

        }

然后我们进行以下操作：

1.从文件中读入数字1，插入到链表第 5 位，并打印所有数字，和元素的总数。保留这个链表，继续下面的操作。

//将数字1插入到链表第5位，并打印所有数字，和元素的总数

            int index = 4;

            System.out.println();

            LinearNode<Integer> current = linearNode;

            LinearNode linearNode1 = new LinearNode(array[0]);

            for (int y= 0;y<index-1;y++)

            {

                current = current.next;

            }

            linearNode1.next = current.next;

            current.next = linearNode1;

            nHouZeYang++;

            result = "";

            i = 0;

            integerLinearNode = linearNode;

            while (i<nHouZeYang)

            {

                result += integerLinearNode.number+" ";

                integerLinearNode = integerLinearNode.next;

                i++;

            }

            System.out.println("插入数字1后所有链表元素为："+result);

            System.out.println("插入数字1后元素个数为："+nHouZeYang);

2.从文件中读入数字2，插入到链表第 0 位，并打印所有数字，和元素的总数。保留这个链表，并继续下面的操作。

// 将将数字2插入到链表第0位，并打印所有数字，和元素的总数

            LinearNode linearNode2 = new LinearNode(array[1]);

            System.out.println(array[1]);

            current = linearNode;

            linearNode = linearNode2;

            linearNode.next = current;

            nHouZeYang++;

            result = "";

            i = 0;

            integerLinearNode = linearNode;

            while (i<nHouZeYang)

            {

                result += integerLinearNode.number+" ";

                integerLinearNode = integerLinearNode.next;

                i++;

            }

            System.out.println("插入数字2后所有链表元素为："+result);

            System.out.println("插入数字2后元素个数为："+nHouZeYang);

3.从链表中删除刚才的数字1. 并打印所有数字和元素的总数

//从链表中删除刚才的数字1.  并打印所有数字和元素的总数

            current = linearNode ;

            while (current.next!=linearNode1)

            {

                current = current.next;

            }

            current.next = current.next.next;

            nHouZeYang--;

            result = "";

            i = 0;

            integerLinearNode = linearNode;

            while (i<nHouZeYang)

            {

                result += integerLinearNode.number+" ";

                integerLinearNode = integerLinearNode.next;

                i++;

            }

            System.out.println("删除数字1后所有链表元素为："+result);

            System.out.println("删除数字1后元素个数为："+nHouZeYang);

实验结果截图：

(3)实验三

使用选择排序法对链表中元素进行排序，我们首先看以下选择排序法如何实现.

      int min;

      T temp;

      for (int index = 0; index < data.length-1; index++)

      {

         min = index;

         for (int scan = index+1; scan < data.length; scan++)

            if (data[scan].compareTo(data[min]) < 0)

               min = scan;

         // Swap the values

         temp = data[min];

         data[min] = data[index];

         data[index] = temp;

      }

接下来再来实现链表中元素排序：

LinearNode<Integer> current = linearNode;

       while (current.next!=null)

       {

           LinearNode temp = current.next;

           int minNumber = current.number;

           while (temp!=null)

           {

               if(minNumber>temp.number)

               {

                   minNumber = temp.number;

               }

               temp = temp.next;

           }

           LinearNode current0 = current;

           while (current0.number!=minNumber)

           {

               current0 = current0.next;

           }

           current0.number = current.number;

           current.number = minNumber;

           result = "";

           i = 0;

           integerLinearNode = linearNode;

           while (i<nHouZeYang)

           {

               result += integerLinearNode.number+" ";

               integerLinearNode = integerLinearNode.next;

               i++;

           }

           System.out.println("排序中所有链表元素为："+result+" 元素个数为："+nHouZeYang);

           System.out.println();

实验结果截图：

(4)实验四

上面进行的是链表练习，这里将进行一些数组的练习：

（1）通过键盘输入一些整数，建立一个数组；（2）实现节点插入、删除、输出操作；

实验结果截图：

(5)实验五

数组练习，要求实现下列功能：使用插入排序法对数组中元素进行排序，在排序的每一个轮次中，打印元素的总数，和目前数组的所有元素。

for (int index = 1; index <nHouZeYang; index++)

        {

            int key = array[index];

            int position = index;

            //  Shift larger values to the right

            while (position > 0 && key<array[position-1])

            {

                array[position] = array[position-1];

                position--;

            }

            array[position] = key;

            result = "";

            for (int i = 0; i < nHouZeYang; i++) {

                result += array[i] + " ";

            }

            System.out.println("排序中所有数组元素为：" + result);

            System.out.println("排序中元素个数为：" + nHouZeYang);

        }

实验结果截图：

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

问题1：首先是建立链表时，产生一些问题，遇到空指针错误。
问题1解决方案：这里主要是把问题太过简单化了，使用了之前jsjf包中的LinearNode类，想直接把所有的数字直接用setNext方法给处理了，实际则不然。于是重新建立了节点类，并修改其中代码

若链表为空，将链表赋值为要添加节点，若不为空，则循环找到链表中下一节点为空的节点，将其next赋为待添加节点，完成建立链表。

            if(linearNode==null)

                linearNode=tLinearNode;

            else

            {

                LinearNode<Integer> current = linearNode;

                while (current.next != null)

                    current = current.next;

                current.next = tLinearNode;

            }

问题2：从文件读取文本，并将其转化为数字类型，上学期学过，这里没有记住。
问题2解决方案：从网上找了一些资料，将这里重新复习了一下，最后采用单个读取字节的形式实现；

File file = new File(fileName);

        Reader reader = null;

        try {

            System.out.println("以字符为单位读取文件内容，一次读一个字节：");

            // 一次读一个字符           

            reader = new InputStreamReader(new FileInputStream(file));

            int tempchar;

            while ((tempchar = reader.read()) != -1) {

                // 对于windows下，\r\n这两个字符在一起时，表示一个换行。

                // 但如果这两个字符分开显示时，会换两次行。

                // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。                

                 if (((char) tempchar) != '\r')

                {

                    System.out.print((char) tempchar);

                }

            }

            reader.close();

        } catch (Exception e) {

            e.printStackTrace();

        }

但是按照这样代码仍然会出现错误，读取出来的有13这个数字，对照ASCII码表，发现这个数字是回车符的ASCII码值，于是尝试将if (((char) tempchar) != '\r'){}改为if (((char) tempchar) != '\r'&&((char) tempchar) != '\n)，修改之后读取内容是正确的。

- 关于char型转int型

char ch = '9';

int n = int(ch) - int('0');

此处ch也是‘0’至‘9’的数字字符

问题3：在数组练习中要在原数组中间插入一个数字，这里一开始以为很简单，可做的过程遇到了问题，见下图：
问题3解决方案：看了两遍代码之后，我知道问题出在了哪里，每次我都是存储了当前y值作为temp，又把数组中索引为(y+1)的元素赋为temp，进行下一次循环时，y=y+1，此时temp便成了之前数组中索引为(y+1)的元素，也就相当于temp前后没有变化，导致了插入后每个元素都变成了同一个。找到了问题，又去尝试了好些改代码的方式，仍然没有解决，大概卡了10多分钟之后，才有了另一种思路，我一开始的思路是一个个地从前往后将索引为4的元素空出来，可这样不会做了，那我是不是可以从后往前去挪元素，将最后一个元素挪至它的下一位置，依次类推，直至将索引为4元素移至索引为5处，最后将索引为4处元素赋为要插入元素，问题也就得以解决，最后修改后代码为

            int index = 4;

            for (int y = nHouZeYang;y>=4;y--)

            {

                array[y+1] = array[y];

            }

            array[index] = nums[0];

其他（感悟、思考等）

本次实验大部分是在复习上学期所学过的内容，包括链表的建立，插入，删除等操作，以及文件的读取。数组这里之前没有练习过，但难度不算大。关于链表的排序这里，上个学期也做过，但那时我是将链表元素逐个取出放入数组之中，再进行排序的，这次是直接用链表进行排序这一操作，直接对链表元素进行比较，完成排序，这里完成的要比之前好一些。

参考资料