数据结构和算法（四）链表--单链表

1、链表（Linked List）介绍

• 链表是种常见数据结构，可以动态进行存储分配，是个功能强大的数组，可以在节点中定义多种数据类型
• 链表以节点的方式存储数据，链式存储
• 链表中每个节点包含 data 域，next 域：指向下一个节点
• 链表一般都有个头指针，用 head 来表示，存放一个指向第一个节点的地址
• 最后一个节点元素不指向其它元素，地址部分存储一个 null
• 链表的各个节点不一定是连续存储
• 链表分为带头节点的链表和没有头结点的链表，head 节点不存放具体数据，表示单链表头 next

在下面的代码中定义 Node 作为链表内每个节点元素

// 定义 Node，每个 Node 对象是一个节点
class Node{
    public int no; // 每个 Node 的编号
    public String name; // 名字
    public String nickName; // 绰号
    public Node next; // 指向下一个节点
	
    // 构造方法
    public Node(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }
    
    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

2、单链表创建和遍历

2.1 单链表创建思路

创建一个 head 头节点，用来表示单链表的头

后面添加每个节点，加入到链表的最后

遍历

2.2 单链表创建和遍历代码实现

public class SingleLinkedListDemo {
    // 主方法
    public static void main(String[] args) {
        // 创建单链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        // 向链表中加入节点
        singleLinkedList.add(new Node(1, "a", "a"));
        singleLinkedList.add(new Node(2, "b", "b"));
        singleLinkedList.add(new Node(3, "v", "c"));
        singleLinkedList.add(new Node(4, "d", "d"));
        singleLinkedList.add(new Node(5, "e", "e"));
        // 展示链表内所有节点元素
        singleLinkedList.list();
    }
}

// 定义单链表 SingleLinkedList 管理 Node
class SingleLinkedList{
    // 初始化头结点头结点不存放数据
    private Node head = new Node(0, "0", "0");

    // 添加节点到单链表，不考虑编号顺序，找到当前链表的最后节点，将最后节点的 next 指向新的节点
    public void add(Node node) {
        Node tempNode = head;
        // 循环遍历
        while (true) {
            if (tempNode.next == null) { // 找到最后一个元素
                break;
            }
            tempNode = tempNode.next;
        }
        // 最后节点的 next 指向 新的节点
        tempNode.next = node;
    }

    // 遍历链表，输出链表内所有 Node 节点信息
    public void list(){
        if (head.next == null) { // 头结点 next 为空
            System.out.println("链表为空");
            return;
        }
        Node tempNode = head.next;
        while (true) {
            if (tempNode == null) {
                break;
            }
            System.out.println("节点信息：" + tempNode);
            // 将 temp 后移
            tempNode = tempNode.next;
        }
    }
}

3、 单链表按顺序插入节点

3.1 单链表按顺序插入思路

首先找到要添加节点的位置，通过一个变量，遍历找到适合插入数据的位置
新的节点为 next = temp.next

将 temp.next = 要插入的节点

3.2 单链表按顺序插入代码实现

package com.sqdkk.linkedList;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        // 创建单链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        // 按编号顺序插入链表
        singleLinkedList.addByOrder(new Node(1, "a", "a"));
        singleLinkedList.addByOrder(new Node(4, "d", "d"));
        singleLinkedList.addByOrder(new Node(2, "b", "b"));
        singleLinkedList.addByOrder(new Node(5, "e", "e"));
        singleLinkedList.addByOrder(new Node(5, "e", "e"));
        singleLinkedList.addByOrder(new Node(3, "v", "c"));
        // 展示链表数据
        singleLinkedList.list();
    }
}

// 定义单链表 SingleLinkedList 管理 Node 节点
class SingleLinkedList{
    // 初始化头结点
    private Node head = new Node(0, "", "");
    
    // 添加节点到单链表，不考虑编号顺序，找到当前链表的最后节点，将最后节点的 next 指向新的节点
    public void add(Node node) {
        Node tempNode = head;
        // 循环遍历
        while (true) {
            if (tempNode.next == null) {
                break;
            }
            tempNode = tempNode.next;
        }
        // 最后节点的 next 指向 新的节点
        tempNode.next = node;
    }

    // 遍历链表
    public void list(){
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        Node tempNode = head.next;
        while (true) {
            if (tempNode == null) {
                break;
            }
            System.out.println("节点信息：" + tempNode);
            // 将 temp 后移
            tempNode = tempNode.next;
        }
    }

    // 添加节点时按照序号插入到指定位置，已有排名则添加失败，抛出异常
    public void addByOrder(Node node) {
        Node temp = head;
        // 标识编号是否存在
        boolean flag = false;
        // 循环链表对每个节点编号判断
        while (true) {
            if (temp.next == null) { // temp 在链表最后，后面没有数据了
                break;
            }
            if (temp.next.no > node.no) { // temp 下一个节点的编号大于要插入节点的编号，插入数据到 temp 下一个节点
                break;
            } else if (temp.next.no == node.no) { // temp 下个节点编号与要插入数据编号一致，编号已存在无法插入
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) { // 已存在相同编号数据
            System.out.printf("编号%d已存在，无法加入\n", node.no);
        } else {
            node.next = temp.next; // temp 后一个节点赋值给 node 下一个节点
            temp.next = node; // node 节点赋值给 temp 下一个节点完成插入
        }
    }

}

4、单链表节点的修改

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        // 创建单链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        // 按编号顺序插入链表
        singleLinkedList.addByOrder(new Node(1, "a", "a"));
        singleLinkedList.addByOrder(new Node(4, "d", "d"));
        singleLinkedList.addByOrder(new Node(2, "b", "b"));
        singleLinkedList.addByOrder(new Node(5, "e", "e"));
        singleLinkedList.addByOrder(new Node(3, "v", "c"));
        // 展示链表数据
        singleLinkedList.list();
        System.out.println("-------------修改后链表为------------");
        singleLinkedList.update(new Node(1, "aaa", "aaa"));
        singleLinkedList.list();
    }
}

// 定义单链表 SingleLinkedList 管理 Node 节点
class SingleLinkedList{
    // 初始化头结点
    private Node head = new Node(0, "0", "0");

    // 添加节点到单链表，不考虑编号顺序，找到当前链表的最后节点，将最后节点的 next 指向新的节点
    public void add(Node node) {
        Node tempNode = head;
        // 循环遍历
        while (true) {
            if (tempNode.next == null) {
                break;
            }
            tempNode = tempNode.next;
        }
        // 最后节点的 next 指向 新的节点
        tempNode.next = node;
    }

    // 遍历链表
    public void list(){
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        Node tempNode = head.next;
        while (true) {
            if (tempNode == null) {
                break;
            }
            System.out.println("节点信息：" + tempNode);
            // 将 temp 后移
            tempNode = tempNode.next;
        }
    }

    // 添加节点时按照序号插入到指定位置，已有排名则添加失败，抛出异常
    public void addByOrder(Node node) {
        Node temp = head;
        // 标识编号是否存在
        boolean flag = false;
        // 循环链表对每个节点编号判断
        while (true) {
            if (temp.next == null) { // temp 在链表最后，后面没有数据了
                break;
            }
            if (temp.next.no > node.no) { // temp 下一个节点的编号大于要插入节点的编号，插入数据到 temp 下一个节点
                break;
            } else if (temp.next.no == node.no) { // temp 下个节点编号与要插入数据编号一致，编号已存在无法插入
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) { // 已存在相同编号数据
            System.out.printf("编号%d已存在，无法加入\n", node.no);
        } else {
            node.next = temp.next; // temp 后一个节点赋值给 node 下一个节点
            temp.next = node; // node 节点赋值给 temp 下一个节点完成插入
        }
    }

    // 修改节点信息，根据编号修改
    public void update(Node newNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 找到要修改编号节点
        Node temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) { // 链表遍历结束
                break;
            }
            if (temp.no == newNode.no) { // 找到要修改的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) { // flag 为 true，进行数据修改
            temp.name = newNode.name;
            temp.nickName = newNode.nickName;
        } else { // 遍历完成后仍然为 false，未找到该节点
            System.out.printf("未找到编号为%d的节点\n", newNode.no);
        }
    }


}

5、单链表中删除指定节点

5.1 单链表删除指定节点思路

先找到要删除节点的前一个节点

将前一个节点的下一个节点指向删除节点的下一个节点 temp.next = temp.next.next;

被删除的节点，将不会有其它引用指向，会被 GC 垃圾回收

5.2 单链表删除指定节点代码实现

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        // 创建单链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        // 按编号顺序插入链表
        singleLinkedList.addByOrder(new Node(1, "a", "a"));
        singleLinkedList.addByOrder(new Node(4, "d", "d"));
        singleLinkedList.addByOrder(new Node(2, "b", "b"));
        singleLinkedList.addByOrder(new Node(5, "e", "e"));
        singleLinkedList.addByOrder(new Node(3, "v", "c"));
        // 展示链表数据
        singleLinkedList.list();
        System.out.println("-------------修改后链表为------------");
        singleLinkedList.delete(1);
        singleLinkedList.list();
    }
}

// 定义单链表 SingleLinkedList 管理 Node 节点
class SingleLinkedList{
    // 初始化头结点
    private Node head = new Node(0, "0", "0");

    // 添加节点到单链表，不考虑编号顺序，找到当前链表的最后节点，将最后节点的 next 指向新的节点
    public void add(Node node) {
        Node tempNode = head;
        // 循环遍历
        while (true) {
            if (tempNode.next == null) {
                break;
            }
            tempNode = tempNode.next;
        }
        // 最后节点的 next 指向 新的节点
        tempNode.next = node;
    }

    // 遍历链表
    public void list(){
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        Node tempNode = head.next;
        while (true) {
            if (tempNode == null) {
                break;
            }
            System.out.println("节点信息：" + tempNode);
            // 将 temp 后移
            tempNode = tempNode.next;
        }
    }

    // 添加节点时按照序号插入到指定位置，已有排名则添加失败，抛出异常
    public void addByOrder(Node node) {
        Node temp = head;
        // 标识编号是否存在
        boolean flag = false;
        // 循环链表对每个节点编号判断
        while (true) {
            if (temp.next == null) { // temp 在链表最后，后面没有数据了
                break;
            }
            if (temp.next.no > node.no) { // temp 下一个节点的编号大于要插入节点的编号，插入数据到 temp 下一个节点
                break;
            } else if (temp.next.no == node.no) { // temp 下个节点编号与要插入数据编号一致，编号已存在无法插入
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) { // 已存在相同编号数据
            System.out.printf("编号%d已存在，无法加入\n", node.no);
        } else {
            node.next = temp.next; // temp 后一个节点赋值给 node 下一个节点
            temp.next = node; // node 节点赋值给 temp 下一个节点完成插入
        }
    }

    // 修改节点信息，根据编号修改
    public void update(Node newNode) {
        if (head.next == null) {
            System.out.println("链表为空，没有数据可以进行修改");
            return;
        }
        // 找到要修改编号节点
        Node temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) { // 链表遍历结束
                break;
            }
            if (temp.no == newNode.no) { // 找到要修改的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) { // flag 为 true，进行数据修改
            temp.name = newNode.name;
            temp.nickName = newNode.nickName;
        } else { // 遍历完成后仍然为 false，未找到该节点
            System.out.printf("未找到编号为%d的节点\n", newNode.no);
        }
    }

    // 删除单链表中指定节点
    public void delete(int no){
        if (head.next == null) {
            System.out.println("链表为空，无法删除数据");
            return;
        }
        Node temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) { // 找到要删除的节点，删除节点下一个节点指向删除节点前一个节点的 next
            temp.next = temp.next.next;

        } else {
            System.out.printf("未找到编号为%d的节点\n", no);
        }
    }

}