链表

1、问题描述：

　　创建一个Java链表

 

2、基本要求：

　（1）创建一条单向链表

    （2）合并两条有序链表

 

3、设计思路：

　　首先要创建结点类，一个结点由结点值（数据域）和下一个结点（指针域）组成，添加非头结点的构造方法、获取结点指针域和数据域的方法和设置当前结点指针域和数据域的方法。

　　然后创建链表类，定义链表的第一个指针和最后一个指针对象，判断链表是否为空，如果链表为空则直接添加结点，如果链表不为空则在尾部追加结点，期间需要采用整数创建结点，

　　所以上述过程应当分成两个方法，添加整数的方         法调用追加结点的方法（方便赋值，以整数创建），然后以各链表的数值（数据域）来输出链表即可。最后回归到测试类，向链

　　表中输入数值，然后追加链表值，最后输出链表。如果需要合并列表，需要判断         链表各个数值的大小并进行排序，最后才能输出链表。

 

4、源代码：

　　（1）Node类

package list;

public class Node {
    private int val;//数据域
    private Node next;//指针域
    //非头结点的构造方法
    public Node(int val) {
        this.val=val;
        this.next=null;
    }
    //获得当前结点的指针域
    public Node getNext() {
        return this.next;
    }
    //获得当前节点数据域的值
    public int getVal() {
        return this.val;
    }
    //设置当前结点的指针域
    public void setNext(Node nextval) {
        this.next=nextval;
    }
    //设置当前结点的数据域的值
    public void setVal(int val) {
        this.val=val;
    }
}

　　（2）List类　

package list;

public class List {
    private Node frist;// 链表的第一个指针
    private Node last;// 链表的最后一个结点对象

    public List() {
        frist = null;
        last = null;
    }

    public void append(Node node) {
        if (frist == null) {
            frist = node;
            last = node;
        } else {     //追加一个结点
            last.setNext(node);
            last = node;
        }
    }

    public void append(int val) {   //追加一个整数
        Node node = new Node(val);  //根据整数创建结点
        append(node);                //往尾部追加结点
    }

    // 输出链表的所有节点
    public void output() {
        Node current = frist;
        while (current != null) {
            System.out.print(current.getVal() + " ");
            current = current.getNext();
        }
        System.out.println();
    }

    public void setFrist(Node frist) {
        this.frist = frist;
    }

    public void setLast(Node last) {
        this.last = last;
    }

    public Node getFirst() {
        return frist;
    }

    public Node getLast() {
        return last;
    }
}

　　（3）Test类：不合并，单纯输出一个链表　

package list;
import java.util.Scanner;

public class Test {
    static Scanner sc=new Scanner(System.in);
    static void listinputOutput() {
        int value;
        List list=new List();
        System.out.println("===链表输入输出===");
        System.out.println("请输入链表的各个节点的值（以负数结束）:");
        while((value=sc.nextInt())>=0) {
            list.append(value);
        }
        System.out.println("输出链表");
        list.output();
    }
public static void main(String[] args) {
        // TODO 自动生成的方法存根
       // 链表输入输出
        listinputOutput();
        
    }
}

　　（4）Test类：合并输出链表　

package list;
import java.util.Scanner;

public class Test {
    

    static void listMerge() {
        int value;
        Node currentNodeOfList1, currentNodeOfList2;
        List list1 = new List();
        List list2 = new List();
        List list = new List();
        System.out.println("===链表合并===");
        System.out.println("请输入第一个链表的个节点的值（以负数结束）：");
        while ((value = sc.nextInt()) >= 0) {
            list1.append(value);
        }
        System.out.println("请输入第二个链表各个结点的值（以负数结束）：");
        while ((value = sc.nextInt()) >= 0) {
            list2.append(value);
        }
        currentNodeOfList1 = list1.getFirst();
        currentNodeOfList2 = list2.getFirst();
        while (currentNodeOfList1 != null && currentNodeOfList2 != null) {
            if (currentNodeOfList1.getVal() <= currentNodeOfList2.getVal()) {
                list.append(currentNodeOfList1);
                currentNodeOfList1 = currentNodeOfList1.getNext();
            } else {
                list.append(currentNodeOfList2);
                currentNodeOfList2 = currentNodeOfList2.getNext();
            }

        }
        while (currentNodeOfList2 != null) {
            list.append(currentNodeOfList1);
            currentNodeOfList1 = currentNodeOfList1.getNext();
        }
        while (currentNodeOfList2 != null) {
            list.append(currentNodeOfList2);
            currentNodeOfList2 = currentNodeOfList2.getNext();
        }
        System.out.println("输出合并后的链表：");
        list.output();
    }

    public static void main(String[] args) {
        //链表合并
        listMerge();
        sc.close();
    }
}

 

5、运行结果：

（1）创建一条单向链表

　　

（2）合并两条有序链表