JAVA版本的链表

链表

链表的特点：

与普通的数组不同，它在内存上的分布并不是连续的，而是分散的，可以利用更多内存的零散空间
(1)链表是以节点来储存，也可以想象成一个节点对象
(2)每个节点有data域用于储存数据，next域用于指向下一个节点，若是双向链表，还会有head域，指向上一个节点

单向链表

首先设计一个节点
为了更好的服用，先设计一个节点父类

@Data
public class ListNode {
    ListNode next;

    public ListNode() {
        this.next = null;
    }
}

继承这个父类，设计出一个自己的节点

@Data
class StudentNode extends ListNode{
    private String name;
    private int num;

    public StudentNode(String name, int num) {
        super();
        this.name = name;
        this.num = num;
    }

    public StudentNode() {
        super();
    }
}

再设计一个可以服用的链表

@Data
class  LinkList {
    private ListNode headNode;

    public LinkList() {
        this.headNode = null;
    }

    public boolean isEmpty(){
        return headNode == null;
    }

    public void add(ListNode node){
        if(isEmpty()){
            this.headNode = node;
            return;
        }
        ListNode temp = this.headNode;

        while (true){
           if(temp.next == null){
               temp.next = node;
               break;
           }
           temp = temp.next;
        }
    }

    public void delete(ListNode node) {
        if(node.equals(headNode)){
            headNode = node.next;
        }
        ListNode temp = this.headNode;
        while(true){
            if (temp.next.equals(node)){
                temp.next = temp.next.next;
                break;
            }
            if(temp.next == null){
                throw new RuntimeException("没有该对象");
            }
            temp = temp.next;
        }

    }

    public void showList(){
        ListNode temp = headNode;
        while (true){
            if(temp == null){
                break;
            }
            System.out.println(temp + "\t====>\t");
            temp = temp.next;
        }
    }

    public ListNode getNodeByNum(int num){
        int count  = 0;
        ListNode temp = headNode;
        while (true){
            if(temp == null){
                throw new RuntimeException("超出范围");
            }
            if(count == num){
                return temp;
            }
            temp = temp.next;
            count++;
        }
    }

下面就是测试代码

public static void main(String[] args) {
        LinkList linkList = new LinkList();
        char key = ' '; // 接受用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop){
            System.out.println("s(show):显示链表");
            System.out.println("e(exit): 退出程序");
            System.out.println("a(add): 添加数据到链表");
            System.out.println("d(delete): 删除数据");
            key = scanner.next().charAt(0);
            switch (key){
                case 's':
                    try {
                        linkList.showList();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    loop = false;
                    break;
                case 'a':
                    System.out.println("请输入名字");
                    String name = scanner.next();
                    System.out.println("请输入学号");
                    int num = scanner.nextInt();
                    StudentNode stu = new StudentNode(name, num);
                    linkList.add(stu);
                    break;
                case 'd':
                    try {
                        System.out.println("请输入序号");
                        int count = scanner.nextInt();
                        StudentNode node = (StudentNode)linkList.getNodeByNum(count);
                        System.out.println(node.toString());
                        linkList.delete(node);
                        System.out.println("该节点已经删除");
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                default:
                    break;

            }
        }
    }
}

双向链表就是再加一个头指针，指向上一个节点，其他同理