链表

链表（Linked List）的介绍

链表是有序的列表，它在内存中的存储方式如下图所示。

头指针为head，指向的地址是150，而150地址指向的节点data域是a1，next域是110；110指向的节点的data域是a2，next域是130；…；170指向的节点的data域是a5，next域为null。

	地址	data域	next域
	110	a2	130
头指针 150	120
	130	a3	180
	140
	150	a1	110
	160
	170	a5	null
	180	a4	170
	190

1、链表是以节点的方式进行存储的
2、每一个节点都包含data域：用来存放数据、next域：用来指向下一个节点
3、链表的各个节点之间不一定是连续存储的
4、链表分为带头结点的链表和不带头节点的链表，根据实际需求进行使用。

单链表（带头结点）的逻辑结构图

代码实现单链表的创建、添加数据（尾插）及遍历

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        // 测试
        // 创建链表
        SingleLinkedList linkedList = new SingleLinkedList() ;
        // 创建节点对象
        HeroNode node1 = new HeroNode(1,"宋江","及时雨");
        HeroNode node2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode node3 = new HeroNode(3,"吴用","智多星");
        HeroNode node4 = new HeroNode(4,"林冲","豹子头");
        // 向链表中添加节点
        linkedList.addNode(node1);
        linkedList.addNode(node2);
        linkedList.addNode(node3);
        linkedList.addNode(node4);
        // 遍历链表
        linkedList.showList();
    }
}

// 定义heroNode表示节点对象
class HeroNode {
    int no ;            // 编号
    String name ;       // 名字
    String nickName ;   // 昵称
    HeroNode next ;     // 指向下一个节点

    public HeroNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

// 定义SingleLinkedList 对英雄进行管理
class SingleLinkedList {
    // 初始化头节点,头节点不存放任何数据
    HeroNode head = new HeroNode(0,"","") ;

    // 添加节点到单向链表
    public void addNode(HeroNode heroNode) {
        // 创建一个辅助节点遍历链表
        HeroNode temp = head ;
        // 遍历单链表，找到单链表的最后一个节点
        while (temp.next != null) { // 当没找到最后一个节点时
            // 将temp指向下一个节点的next域
            temp = temp.next ;
        }
        // 将最后一个节点的next域改为传入的节点
        temp.next = heroNode ;
    }

    // 遍历并输出链表中的节点数据
    public void showList() {
        // 判断链表是否为空
        // 为空
        if(head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 不为空
        // 创建辅助节点
        HeroNode temp = head ;
        // 判断当前节点后是否存在其他节点
        // 存在
        while (temp.next != null) {
            // 指向下一个节点
            temp = temp.next ;
            // 输出该节点
            System.out.println(temp);
        }
    }
}

结果

头插法

代码

// 添加节点到单向链表(头插法)
public void addNode(HeroNode heroNode) {
    // 创建一个辅助节点遍历链表
    HeroNode temp = head ;
    /*
        要想将节点添加到头节点后，
        首先要将该节点的next域指向head的next域
        然后需要head节点的next域指向该节点
     */
    // 将插入的节点的next域指向head的next域
    heroNode.next = temp.next ;
    temp.next = heroNode ;
}

结果

排序添加

代码

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        // 测试
        // 创建链表
        SingleLinkedList linkedList = new SingleLinkedList() ;
        // 创建节点对象
        HeroNode node2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode node1 = new HeroNode(1,"宋江","及时雨");
        HeroNode node4 = new HeroNode(4,"林冲","豹子头");
        HeroNode node3 = new HeroNode(3,"吴用","智多星");
        // 向链表中添加节点
//        linkedList.addNode(node1);
//        linkedList.addNode(node2);
//        linkedList.addNode(node3);
//        linkedList.addNode(node4);

        linkedList.addByNo(node1);
        linkedList.addByNo(node2);
        linkedList.addByNo(node3);
        linkedList.addByNo(node4);
        // 遍历链表
        linkedList.showList();
    }
}

// 根据英雄的no大小进行排序添加
public void addByNo(HeroNode heroNode) {
    // 创建辅助节点
    HeroNode temp = head ;
    // 根据no进行插入节点时需要先找出其应该插入的位置，所以我们要先对链表进行遍历并比较no
    // 不为空
    while (temp.next != null) {
        if(temp.next.no > heroNode.no) {    // 当当前节点的no大于要插入节点的no时，直接在其后插入
            heroNode.next = temp.next ;
            temp.next = heroNode ;
        }else if(temp.next.no == heroNode.no) { // 当no相同时
            System.out.println("该英雄已存在");
            return;
        }
        // 节点后移
        temp = temp.next ;
    }
    // 为空直接插到head后
    temp.next = heroNode ;
}

结果

修改节点

/**
 * 传入一个节点，根据no找链表中是否存在该节点，如果存在就进行修改，不存在就提示用户不存在
 * @param heroNode  传入的节点对象
 */
public void updateNode(HeroNode heroNode) {
    // 创建辅助节点
    HeroNode temp = head ;
    // 判断链表是否为空或到达链表的尾部
    while (temp.next != null) {
        if(temp.next.no == heroNode.no) { // 当找到该节点时
            temp.next.name = heroNode.name ;
            temp.next.nickName = heroNode.nickName ;
            return;
        }
        // 节点后移
        temp = temp.next ;
    }
    System.out.println("该节点不存在");
}

删除节点

/**
 * 传入一个int类型的参数，到链表中进行查找，若该链表存在则将其删除
 * @param no    英雄编号
 */
public void deleteNode(int no) {
    // 创建辅助节点
    HeroNode temp = head ;
    // 判断链表是否为空或到达链表的尾部
    while (temp.next != null) {
        if(temp.next.no == no) {
            temp.next = temp.next.next ;
            return;
        }
        // 节点后移
        temp = temp.next ;
    }
    System.out.println("该节点不存在");
}

双线链表

单向链表和双向链表的对比：
1、查找的方向只能是一个方向，而双向链表可以向前或向后查找
2、单向链表不能自我删除，需要靠辅助结点，而双向链表可以实现自我删除

双向链表的遍历、添加、修改、删除的操作思路

1、遍历双向链表时，可以从前遍历，也可以从后遍历，其遍历方法和单向链表一样。
2、添加节点（尾插）
（1）先找到链表的最后一个节点temp
（2）temp.next = newNode，将最后一个节点的next指向要插入的节点newNode
（3）newNode.pre = temp，将新节点的pre指向temp
3、修改节点时，只需要查找到这个节点进行data的改变即可
4、删除节点
（1）在双向链表中，节点可以实现自我删除
（2）找到要删除的节点temp
（3）temp.pre.next = temp.next，将要删除的节点的前一个节点的next指向要删除节点的后一个节点
（4）temp.next.pre = temp.pre，将要删除的节点的后一个节点的pre指向要删除节点的前一个节点

双向链表删除截节点的示意图

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        // 创建一个双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList() ;
        // 创建节点
        LinkedNode node1 = new LinkedNode(1) ;
        LinkedNode node2 = new LinkedNode(2) ;
        LinkedNode node3 = new LinkedNode(3) ;
        LinkedNode node4 = new LinkedNode(4) ;
        // 将节点添加到双向链表
        doubleLinkedList.addNode(node1);
        doubleLinkedList.addNode(node2);
        doubleLinkedList.addNode(node3);
        doubleLinkedList.addNode(node4);
        // 遍历双向链表
        doubleLinkedList.listNode();
        System.out.println("----------------------");
        // 修改data=2的节点的data为5
        doubleLinkedList.updateNode(2 , 5);
        doubleLinkedList.listNode();
        System.out.println("----------------------");
        // 删除data=3的节点
        doubleLinkedList.deleteNode(3);
        doubleLinkedList.listNode();
    }
}

// 创建一个节点类
class LinkedNode {
    int no ;            // data属性
    LinkedNode pre ;    // 指向前一个节点
    LinkedNode next ;   // 指向后一个节点

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

    @Override
    public String toString() {
        return "LinkedNode{" +
                "no=" + no +
                '}';
    }
}

// 创建一个双向链表的类
class DoubleLinkedList {
    // 初始化一个头节点，data为-1
    LinkedNode head = new LinkedNode(-1) ;

    // 返回头节点
    public LinkedNode getHead() {
        return head ;
    }

    // 遍历双向链表
    public void listNode() {
        // 当链表为空时
        if(head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 链表不为空时
        // 创建辅助节点
        LinkedNode temp = head ;
        while (temp.next != null) {
            temp = temp.next ;  // 节点后移
            System.out.println(temp);   // 输出
        }
    }

    /**
     * 添加节点，尾插法
     * @param linkedNode    要添加的节点
     */
    public void addNode(LinkedNode linkedNode) {
        // 创建一个辅助节点
        LinkedNode temp = head ;
        // 判断链表是否到最后
        // 没有到最后一个节点时
        while (temp.next != null) {
            temp = temp.next ;  // 节点后移
        }
        // 到最后一个节点时
        temp.next = linkedNode ;
        linkedNode.pre = temp ;
    }

    // 修改节点
    public void updateNode(int no , int n) {
        // 当链表为空时
        if(head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 创建一个辅助节点
        LinkedNode temp = head ;
        // 遍历查找链表中是否存在no=n的节点
        while (temp.next != null) {
            temp = temp.next ;
            if(temp.no == no) {
                temp.no = n;
                return;
            }
        }
        System.out.println("该节点不存在");
    }

    // 删除节点
    public void deleteNode(int n) {
        // 当链表为空时
        if(head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 创建一个辅助节点
        LinkedNode temp = head ;
        // 遍历查找链表中是否存在no=n的节点
        while (temp.next != null) {
            temp = temp.next;
            if(temp.no == n) {
                temp.pre.next = temp.next ;
                temp.next.pre = temp.pre ;
                return;
            }
        }
        System.out.println("该节点不存在");
    }
}

结果