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

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

课程：《程序设计与数据结构》
班级： 2023
姓名：贾奕琦
学号：20202301
实验教师：王志强
实验日期：2021年11月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.链表练习，要求实现下列功能：

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

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

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

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

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

## 2. 实验过程及结果

<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）。
代码：
主函数：

System.out.println("————链表创建————");
LinkedList linkedList=new LinkedList();
Scanner scanner=new Scanner(System.in);
for(int i=1;i<=11;i++)
{
    int n;
    System.out.print("No."+i+":");
    n=scanner.nextInt();
    LinkedNode linkedNode =new LinkedNode(n);
    linkedList.add(linkedNode);
}
linkedList.list();
System.out.println();
int nJiaYiqi=0;
nJiaYiqi=linkedList.getlength(linkedList.getHead());
System.out.println("单链表的有效节点个数为：" + nJiaYiqi);
子函数：

class LinkedNode{
    public int i;
    public LinkedNode next;

    public LinkedNode(int i) {
        this.i=i;
    }

    @Override
    public String toString() {
        return ""+i;
    }
}

class LinkedList{
    private LinkedNode head = new LinkedNode(0);
    public LinkedNode getHead()
    {
        return head;
    }
    public void add(LinkedNode linkedNode1)
    {
        LinkedNode temp = head;
        while(true)
        {
            if(temp.next == null)
            {
                break;
            }
            temp = temp.next;
        }
        temp.next = linkedNode1;
    }

public void list() {
    if(head.next == null) {
        System.out.println("链表为空");
        return;
    }
    LinkedNode temp = head.next;
    while(true) {
        if(temp == null) {
            break;
        }
        System.out.print(" ");
        System.out.print(temp);
        temp = temp.next;
    }
}

public int getlength(LinkedNode head)
{
    if(head.next == null) {
        return 0;
    }
    int length = 0;
    LinkedNode cur = head.next;
    while(cur != null) {
        length++;
        cur = cur.next;
    }
    return length;
}


结果截图：

上传截图：

<2>.链表练习，要求实现下列功能：

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

代码：

<提取文件>

//第二部分（提取文件内容）
System.out.println("————文件操作————");
File file = new File("/Huawei Share/Screenshot/jia.txt");
if (file.createNewFile()) {
    System.out.println("File has been created.");
} else {
    System.out.println("File already exists.");
}
BufferedReader bw = new BufferedReader(new FileReader(file));
String line= bw.readLine();
System.out.println(line);
String[] temp=line.split(" ");
for(int i=0;i<temp.length;i++)
{
    System.out.println("temp"+(i+1)+"="+temp[i]);
}

<插入元素>

主函数：

//插入元素
System.out.println("————插入元素————");
System.out.println("添加节点之前的链表：");
linkedList.list();
System.out.println();
System.out.println("第一个插入元素的位置：");
int m=scanner.nextInt();
int n= Integer.parseInt(temp[0]);
LinkedNode element1=new LinkedNode(n);
linkedList.addin(m,element1, linkedList.getHead());
System.out.println("添加节点之后的链表：");
linkedList.list();
nJiaYiqi=linkedList.getlength(linkedList.getHead());
System.out.println();
System.out.println("添加节点后，单链表的有效节点个数为：" + nJiaYiqi);

System.out.println("添加节点之前的链表：");
linkedList.list();
System.out.println();
System.out.println("第二个插入元素的位置：");
int a=scanner.nextInt();
int b= Integer.parseInt(temp[1]);
LinkedNode element2=new LinkedNode(b);
linkedList.addin(a,element2, linkedList.getHead());
System.out.println("添加节点之后的链表：");
linkedList.list();
nJiaYiqi=linkedList.getlength(linkedList.getHead());
System.out.println();
System.out.println("添加节点后，单链表的有效节点个数为：" + nJiaYiqi);

子函数：

public void addin(int x, LinkedNode element,LinkedNode head) {
    LinkedNode temp = head;
    for (int y = 0; y < x ; y++) {
        temp = temp.next;
    }
    element.next = temp.next;
    temp.next = element;
}

<删除元素>
主函数：

//删除元素
System.out.println("————删除元素————");
int j;
System.out.println("删除节点之前的链表：");
linkedList.list();
System.out.println();
System.out.println("输入要删除的元素：");
j=scanner.nextInt();
linkedList.del(j);
System.out.println("删除节点之后的链表：");
linkedList.list();
nJiaYiqi=linkedList.getlength(linkedList.getHead());
System.out.println();
System.out.println("删除节点后，单链表的有效节点个数为：" + nJiaYiqi);

子函数：

public void del(int i) {
    int j = 0;
    Scanner scanner=new Scanner(System.in);
    System.out.println("输入要删除的是第几个"+i);
    j=scanner.nextInt();
    LinkedNode temp = head;
    boolean flag = false;
    int s=0;
    while(true) {
        if(temp.next == null) {
            break;
        }
        if(temp.next.i== i) {
            flag = true;
            s++;
            if(s==j)
            {
                break;
            }
        }
        temp = temp.next;
    }
    if(flag) {
        temp.next = temp.next.next;
    }else {
        System.out.printf("要删除的%d节点不存在！", i);
    }
}

运行截图：

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

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

代码：

主函数：

linkedList.select(linkedList.getHead(),linkedList,nJiaYiqi);
System.out.println("由小到大的链表为：");
linkedList.list();
nJiaYiqi=linkedList.getlength(linkedList.getHead());
System.out.println();
System.out.println("排序后，单链表的有效节点个数为：" + nJiaYiqi);

子函数：

public LinkedNode select(LinkedNode head,LinkedList linkedList,int nJiaYiqi)
{
    LinkedNode temp=head;
    LinkedNode tail=null;
    int in;
    if(head== null || head.next== null)
    {
        return null;
    }
    while(head.next != tail) {
        while (head.next != tail) {
            if (head.i > head.next.i) {
                in = head.i;
                head.i = head.next.i;
                head.next.i = in;
                System.out.println("排序中的链表为：");
                linkedList.list();
                nJiaYiqi=linkedList.getlength(linkedList.getHead());
                System.out.println();
                System.out.println("单链表的有效节点个数为：" + nJiaYiqi);
            }
            head = head.next;
        }
        tail = head;
        head = temp;
    }
    return head;
}