20202324 实验五和六 《数据结构与面向对象程序设计》实验报告

# 20202324 2021-2022-1 《数据结构与面向对象程序设计》实验四报告

课程：《程序设计与数据结构》
班级： 2023
姓名： 肖郅宇
学号：20202324
实验教师：王志强
实验日期：2021年10月28日
必修/选修： 必修

一、实验内容

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. 并打印所有数字和元素的总数。

3.链表练习，要求实现下列功能：

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

4.在android上实现实验（1）和（2）

5.在android平台上实现实验（3)

二、实验过程及其结果

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. 并打印所有数字和元素的总数。

3.链表练习，要求实现下列功能：

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

   

   

  
  

   

实验截图

public class Chain {
    protected int element;
    protected Chain next = null;

    public Chain(int element) {
        this.element = element;
        this.next = next;
    }

    public int getElement() {
        return element;
    }

    public void setElement(int element) {
        this.element = element;
    }

    public Chain getNext() {
        return next;
    }

    public void setNext(Chain next) {
        this.next = next;
    }
}

import java.io.*;
import java.util.Scanner;

public class Chain_2 {
    public static Chain head;
    public static int nXiaoZhiYv = 0;

    public static void main(String[] args) throws IOException {
        Scanner scan=new Scanner(System.in);

        //先输入并创建表头
        System.out.println("Enter numbers("+(nXiaoZhiYv + 1)+").Type stop if you want to stop.");
        String str = scan.nextLine();
        Chain chain0 = new Chain(Integer.parseInt(str));
        head = chain0;

        //一直输入并连接，直到输入“stop”
        do{
            nXiaoZhiYv++;
            System.out.println("Enter numbers("+(nXiaoZhiYv + 1)+").Type stop if you want to stop.");
            str = scan.nextLine();
            if(str.equals("stop")){     //防止整数型链表输入字符串导致错误
                break;
            }
            Chain chain = new Chain(Integer.parseInt(str));
            connect(head, chain);
        }while (!str.equals("stop"));

        //删除
        System.out.println("Delete?(y/n)");
        if (scan.nextLine().equals("y")){
            System.out.println("Please enter the node you want to delete:");
            int node = scan.nextInt();
            delete(head, node);
        }

        //插入
        System.out.println("Insert?(y/n)");
        if(scan.next().equals("y")){                      //此处不可next.Line,否则会读走剩下的链表
            System.out.println("Please enter the location where you want to insert the node:");
            int node = scan.nextInt();
            System.out.println("Please enter an element for this node:");
            int element = scan.nextInt();
            insert(head, element, node);
        }


        //输出
        PrintLinkedList(head);

        //1.文件创建（文件类实例化）
        File file = new File("D:\\test6","Chain.txt");
        //2.文件的读写，字节流读写，先写后读
        OutputStream outputStream = new FileOutputStream(file);
        byte[] insert2 = { 11 , 13 };                //定义字节流数组
        outputStream.write(insert2);

        InputStream inputStream = new FileInputStream(file);
        int[] num = new int[2];
        int by = 0;
        while (inputStream.available() > 0){                 //读取，用数组存储字节流
            num[by] = inputStream.read();
            by++;
        }
        outputStream.close();
        inputStream.close();                     //结束

        //输出文件内容
        System.out.print("File content is: ");
        for(int i = 0; i < 2; i++) {
            System.out.print(num[i] + " ");
        }
        System.out.print("\n");

        //将文件的第一个数字插入到链表第5位,并输出
        insert(head, num[0], 5);
        PrintLinkedList(head);
        //将文件的第二个数字插入到链表第0位,并输出
        insert(head, num[1], 1);
        PrintLinkedList(head);
        //将文件的第一个数字从链表中删除,并输出
        delete(head, 6);
        PrintLinkedList(head);

        rank();
        PrintLinkedList(head);
    }

    //链表之间的连接，尾插法，遍历
    public static void connect(Chain head, Chain chain2){
        Chain head2 = head;
        while (head2.getNext() != null){
            head2 = head2.getNext();
        }
        head2.setNext(chain2);
    }

    //用来输出的静态方法
    public static void PrintLinkedList(Chain head){
        Chain temp = head;
        String list = "";
        while (temp != null){
            list = list + " " + temp.getElement();
            temp = temp.getNext();
        }
        System.out.println(list);
        System.out.println("Total number of elements:" + nXiaoZhiYv);
    }

    public static void delete(Chain head, int node){
        Chain temp = head;

        if(node == 1) {                //删除头节点
            Chain_2.head = head.getNext();
        }
        else {                          //遍历至要删除的节点
            for(int i = 1; i < node - 1; i++){
                temp = temp.getNext();
            }
        }

        temp.setNext(temp.getNext().getNext());    //跳过该节点，达到删除的目的
        nXiaoZhiYv--;                              //总数减1
    }

    public static void insert(Chain head, int element, int node){
        Chain insert = new Chain(element);
        Chain temp = head;

        if(node == 1){
            insert.setNext(head);
            Chain_2.head = insert;
        }
        else {
            for(int i = 0; i < node - 2; i++){
                temp = temp.getNext();
            }
            insert.setNext(temp.getNext());
            temp.setNext(insert);
        }
        nXiaoZhiYv++;
    }

    public static void rank(){
        Chain temp = Chain_2.head;
        Chain temp1 = Chain_2.head;              //双指针用于排序
        int t , w = 1, e = 1;            //t储存链表当前位置后的最大值，w记录指针位置，e记录排序后重复的数的位置

        for(int i = 1; i < nXiaoZhiYv; i++){
            t = temp.getElement();
            while (temp1.getNext() != null){
                temp1 = temp1.getNext();
                w++;
                if(temp1.getElement() > t){
                    t = temp1.getElement();
                    e = w + 1;
                }
            }
            insert(head, t, i);        //将最大值放在表头
            delete(head, e);           //删除移动后残留的数
            PrintLinkedList(head);
            w = i + 1;
            if(e <= w) temp = temp.getNext();          //此处遇到困难，问题出在后面的数插到当前位置后，temp已经后移一位,所以要加if
            temp1 = temp;
            if(temp1.getNext() == null) break;         //防止越界
        }
    }
}

↑是实验六前几步的全部代码，

所幸的是所有的实验结果都能跟预期对的上

可喜可贺可喜可贺

 

 

 

4.在android上实现实验（1）和（2）

5.在android平台上实现实验（3)

正在弄，马上搞出来。。。

 

三. 实验过程中遇到的问题和解决过程
- 问题1：安卓编程平台疯狂报错，一步一错甚至一步两三错，折磨惨了
- 问题解决方案： 百度，百度，还是**的百度，csdn承包了我每一步报错的解决方法

- 问题2：链表中的
- 问题解决方案： 通过在方法内部使用String a = “”+t（自定义变量）来实现将自定义的变量转换为String类型，

 

四.实验感想

还是好难啊，安卓平台比上一个服务器还搞心态，网上的教程也不完全都是对的，就硬着头皮一点一点的搞，本来以为学到现在应该不会出现编个程序啥都不会的情况，结果还是对着实验题目想很久，才慢慢悠悠编出来，这个实验都还没搞完下个实验又发布了，累了，毁灭吧，看着下个实验应该比这个简单点，但为什么还有安卓平台啊，累了，就这样吧