数据结构 - 链表

关注 “弋凡”（YiFan）微信公众号吧 记录简单笔记 做你的最爱

链表的特点

1.是以节点方式来存储的，

2.每个节点包含data域，next域：指向下一个节点

3.链表的各个节点不一定是连续存放

4.链表分带头结点的链表和不带头结点的链表

单链表

特点

一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据

代码

package com.yifan.linear.Linkedlist;

/**
 * @Author YIFan
 * @Date 2020/6/7 15:49
 * @Version 1.0
 */
// 单向链表
public class Node {

    // 节点内容
    private int data;
    // 下一个节点
    private Node next;

    public Node(int data) {
        this.data = data;
    }

    // 追加节点
    public Node apped(Node node){
        // 获取当前节点
        Node currentNode = this ;
        // 循环向后找
        while (true){
            // 取出下一个节点
            Node nextNode = currentNode.next;
            // 下一个节点为 null 当前节点是最后一个节点了
            if(nextNode == null){
                break;
            }
            // 下一个节点赋值给当前节点
            currentNode = nextNode;
        }
        // 把需要追加的节点 追加为 找到当前节点的下一个节点
        currentNode.next = node ;

        return this;
    }

    // 获取下一个节点
    public Node next(){
        return this.next;
    }

    // 获取节点中的数据
    public int getData() {
       return this.data;
    }

    // 判断节点是否为最后一个节点
    public boolean isLast(){
        return next == null;
    }

    // 显示节点
    public void show(){
        Node currentNode = this;
        while (true){
            System.err.print(currentNode.getData()+" -> ");
            currentNode = currentNode.next;
            if(currentNode == null ){
                System.err.print("null ");
                break;
            }
        }
        System.err.println();
    }

    // 删除当前节点的下一个节点
    public void removeNext(){
        // 只能删除当前节点的下一个节点 获取到删除的下一个节点
        Node node = next.next ;
        // 把下下一个节点设置为当前节点的下一个节点
        this.next = node;
    }

    // 插入一个节点
    public void afterNode(Node node){
        // 取出当前节点的下一个节点 作为  下下一个节点
        Node nextNext = this.next;
        // 把插入的节点 赋值给当前节点的下一个节点
        this.next = node;
        //把下下个节点设置为新节点的下一个节点
        node.next = nextNext;
    }
}

public class TestNode {

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        // 追加节点
        node1.apped(node2).apped(node3);

        node1.show();
        node1.afterNode(node4);
        node1.show();
    }
}

循环链表

特点

循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环

当循环链表只有一个节点时,它的下一个节点直接指向自己

代码

package com.yifan.linear.Linkedlist;

/**
 * @Author YIFan
 * @Date 2020/6/7 15:49
 * @Version 1.0
 */
// 环形链表
public class CircleNode {

    // 节点内容
    private int data;
    // 下一个节点
    private CircleNode next = this;

    public CircleNode(int data) {
        this.data = data;
    }

    // 获取下一个节点
    public CircleNode next(){
        return this.next;
    }

    // 获取节点中的数据
    public int getData() {
       return this.data;
    }

    // 判断节点是否为最后一个节点
    public boolean isLast(){
        return next == null;
    }


    // 删除当前节点的下一个节点
    public void removeNext(){
        // 只能删除当前节点的下一个节点 获取到删除的下一个节点
        CircleNode node = next.next ;
        // 把下下一个节点设置为当前节点的下一个节点
        this.next = node;
    }

    // 插入一个节点
    public void afterNode(CircleNode node){
        // 取出当前节点的下一个节点 作为  下下一个节点
        CircleNode nextNext = this.next;
        // 把插入的节点 赋值给当前节点的下一个节点
        this.next = node;
        //把下下个节点设置为新节点的下一个节点
        node.next = nextNext;
    }
}

public class TestNode {

    public static void main(String[] args) {

        CircleNode node1 = new CircleNode(1);
        CircleNode node2 = new CircleNode(2);
        node1.afterNode(node2);
        System.out.println(node1.next().getData()); --> 1 -> 2
        System.out.println(node2.next().getData()); --> 2 -> 1

    }
}

双向循环链表

介绍

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向 循环链表

示意图

代码实现

package com.yifan.linear.Linkedlist;

/**
 * @Author YIFan
 * @Date 2020/6/12 11:21
 * @Version 1.0
 */
// 环形双向链表
public class CircleDoubleNode {
    // 只创建一个节点的话 上一个 ,下一个节点都是他自己
    // 上一个节点
    private CircleDoubleNode per = this;
    // 下一个节点
    private CircleDoubleNode next = this;
    // 节点的数据
    private int data ;

    public CircleDoubleNode(int data){
        this.data = data;
    }

    //增加节点
    public void after(CircleDoubleNode node){
        // 原来的下一个节点
        CircleDoubleNode nextNext = this.next;
        // 把新节点当作当前节点的下一个节点
        this.next = node;
        // 把当前节点当作新节点的前一个节点
        node.per = this;
        // 让原来的下一个节点当作新节点的下一个节点
        node.next = nextNext;
        // 让原来的下一个节点的上一个节点为新节点
        nextNext.per = node;
    }

    //下一个节点
    public CircleDoubleNode next(){
        return this.next;
    }

    //上一个节点
    public CircleDoubleNode previous(){
        return this.per;
    }

    //获取数据
    public int getData(){
        return this.data;
    }

}

public class TestNode {

    public static void main(String[] args) {


       CircleDoubleNode node1 = new CircleDoubleNode(1);
       CircleDoubleNode node2 = new CircleDoubleNode(2);
       CircleDoubleNode node3 = new CircleDoubleNode(3);

       node1.after(node2);
       node2.after(node3);

       System.out.println(node2.previous().getData());  1
       System.out.println(node2.getData());  2
       System.out.println(node2.next().getData());  3

    }
}

快来关注“弋凡”微信公众号吧