• 数据结构 3：链表

    目录

    1. 链表介绍

    • 链表是有序的列表，但是它在内存中是存储如下

    在这里插入图片描述

    1. 链表是以节点的方式来存储，是链式存储
    2. 每个节点包含 data 域，next 域：指向下一个节点
    3. 链表的各个节点的内存地址不一定是连续存储
    4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
    • 单链表(带头结点) 逻辑结构示意图如下

    在这里插入图片描述

    2. 应用实例

    • 使用带head头的单向链表实现 –水浒英雄排行榜管理；完成对英雄人物的增删改查操作
    • 代码实现
    package com.datastructure.列表;

public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        // 随机插入
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero2);
        System.out.println("随机插入");
        // 显示
        singleLinkedList.list();

        // 按顺序插入
        SingleLinkedList singleLinkedList2 = new SingleLinkedList();
        singleLinkedList2.addByOrder(hero1);
        singleLinkedList2.addByOrder(hero4);
        singleLinkedList2.addByOrder(hero3);
        singleLinkedList2.addByOrder(hero2);
        System.out.println("顺序插入");
        // 显示
        singleLinkedList2.list();
        // 修改节点
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟");
        singleLinkedList2.update(newHeroNode);
        System.out.println("修改后的链表");
        singleLinkedList2.list();
        // 删除节点
        singleLinkedList2.del(1);
        singleLinkedList2.del(4);
        System.out.println("删除后的链表");
        singleLinkedList2.list();

    }
}

// 定义HeroNode，每个node对象就是一个节点
class HeroNode {
    // node是带序号的
    public int no;
    public String name;
    public String nickName;
    // 指向下一个节点
    public 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，管理node节点
class SingleLinkedList {
    // 初始化一个头节点，头节点不能栋，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

    // 添加节点到单向链表尾部
    // 1. 找到链表最后一个节点
    // 2. 将最后节点的next变量指向新的节点
    public void add(HeroNode heroNode) {
        // 头节点不能动，所以定义临时变量用于遍历链表
        HeroNode temp = head;
        while (true) {
            // next是null，说明temp是最后一个节点
            if (temp.next == null) {
                break;
            }
            // 如果temp不是最后一个节点，就向后移
            temp = temp.next;
        }
        // 当退出while时，就说明temp是链表的最后一个节点
        // 此时将temp节点的下一个节点指向新加入的节点
        temp.next = heroNode;
    }

    // 按序号顺序添加节点（从小到大），如果序号存在，则提示添加失败
    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        // 标记添加的序号是否存在，默认false
        boolean flag = false;
        while (true) {
            // next等于null，说明是最后一个节点
            if (temp.next == null) {
                break;
            }
            // 新节点的序号小于后面节点，则位置找到
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                // 序号存在
                flag = true;
                break;
            }
            // 没找到位置，需要继续后移
            temp = temp.next;
        }
        // 序号存在不能添加
        if (flag) {
            System.out.printf("序号%d已存在，不能添加\n", heroNode.no);
        } else {
            // 插入数据
            // 1. 先将temp的next和temp断开，赋给新节点的next
            heroNode.next = temp.next;
            // 2. 再将新节点赋给temp的后一位
            temp.next = heroNode;
        }
    }

    // 根据no序号修改节点信息
    public void update(HeroNode newHeroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 根据no找到要修改的节点
        // 定义一个辅助变量
        HeroNode temp = head.next;
        // 标记是否找到该节点
        boolean flag = false;
        while (true) {
            // 说明已经遍历完链表，没有找到
            if (temp == null) {
                break;
            }
            // 找到了
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            // 没找到节点，后移
            temp = temp.next;
        }
        // 根据flag判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {
            System.out.printf("%d号节点不存在，修改失败\n", newHeroNode.no);
        }
    }

    // 删除节点
    // 1. head不能栋，需要一个temp辅助变量找到待删除节点的前一个结点
    // 2. 使用temp.next.no 和待删除节点的no比较
    public void del(int no) {
        HeroNode 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) {
            // 将待删除节点的后一个节点赋给待删除节点的前一个节点
            temp.next = temp.next.next;
        } else {
            System.out.printf("待删除的%d号节点不存在\n", no);
        }
    }

    // 显示链表
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 遍历
        HeroNode temp = head.next;
        while (true) {
            // 判断当前节点是否空
            if (temp == null) {
                break;
            } else {
                // 不为空则输出
                System.out.println(temp);
                // 后移一位
                temp = temp.next;
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 打印结果
    随机插入
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
顺序插入
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
修改后的链表
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='小卢', nickName='玉麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
删除后的链表
HeroNode{no=2, name='小卢', nickName='玉麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    3. 单链表面试题

    3.1 有效节点的个数

        /**
     * 获取单链表有效节点个数
     *
     * @param head 链表的头节点
     * @return 有效节点数量
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        // 定义辅助变量，不统计头节点
        HeroNode temp = head.next;
        while (temp != null) {
            length++;
            // 后移一位，继续遍历
            temp = temp.next;
        }
        return length;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    3.2 查找单链表中的倒数第k个结点

        // 查找单链表中的倒数第K个节点
    // 1. 接收head节点和倒数第index个节点数字
    // 2. 遍历链表，得到链表有效节点的个数
    // 3. 得到length后，遍历链表，得到（length-index）位置的节点
    // 4. 如果找到，返回该节点，否则返回null
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        if (head == null) {
            return null;
        }
        // 获取有效节点个数
        int length = getLength(head);
        if (length <= 0 || index > length) {
            return null;
        }
        // 定义临时变量，遍历到length-index位置
        HeroNode temp = head.next;
        for (int i = 0; i < length - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    3.3 单链表的反转

    • 效果如下

    在这里插入图片描述

    • 思路:
    1. 先定义一个临时节点 reverseHead = new HeroNode();
2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表头节点 reverseHead 的next
3. 原来的链表的head.next = reverseHead.next

    • 1
    • 2
    • 3
        // 单链表的反转
    public static void reverseList(HeroNode head) {
        // 如果当前链表为空，或者只有一个节点，则无需反转，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
        // 定义一个临时变量，帮助遍历原来的链表
        HeroNode cur = head.next;
        // 定义next变量，指向cur节点的下一个节点
        HeroNode next = null;
        // 定义临时存放反转过来节点的链表的头节点
        HeroNode reverseHead = new HeroNode(0, "", "");
        // 遍历原来的链表，每遍历一个节点，就将其取出，并放在新链表reverseHead的next位置
        while (cur != null) {
            // 将cur节点的下一个节点，暂时保存在next变量，用于循环最后一步节点后移操作
            next = cur.next;
            // 将reverseHead的下一个节点赋给cur的下一个节点
            cur.next = reverseHead.next;
            // 将cur节点赋给reverseHead下一个节点
            reverseHead.next = cur;
            // 为cur重新赋值，使用前面保存的next数据，相当于把原来的链表节点后移，实现遍历
            cur = next;
        }
        // 将反转后的结果赋给原来链表头节点的下一个节点，实现原来链表的反转
        head.next = reverseHead.next;
    }
    

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    3.4 从尾到头打印单链表

    • 思路
    1. 逆序打印单链表.
2. 方式1： 先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
3. 方式2：可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果.

    • 1
    • 2
    • 3
    • 这里使用方式2
        // 逆序打印
    // 将节点压入到栈中，利用栈的先进后出特点
    public static void reversePrint(HeroNode head) {
        if (head.next == null) {
            return;
        }
        // 创建一个栈，将各节点压入栈
        Stack<HeroNode> stack = new Stack<>();
        HeroNode temp = head.next;
        while (temp != null) {
            stack.push(temp);
            // 节点后移
            temp = temp.next;
        }
        // pop后打印
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    3.5 完整代码

    import java.util.Stack;

public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        // 随机插入
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero2);
        System.out.println("随机插入");
        // 显示
        singleLinkedList.list();
        // 按顺序插入
        SingleLinkedList singleLinkedList2 = new SingleLinkedList();
        singleLinkedList2.addByOrder(hero1);
        singleLinkedList2.addByOrder(hero4);
        singleLinkedList2.addByOrder(hero3);
        singleLinkedList2.addByOrder(hero2);
        System.out.println("顺序插入");
        // 显示
        singleLinkedList2.list();
        System.out.println("list2的倒数第3个节点是：" + findLastIndexNode(singleLinkedList2.getHead(), 3));
        // 反转链表
        reverseList(singleLinkedList2.getHead());
        // 显示反转结果
        System.out.println("显示反转后的结果");
        singleLinkedList2.list();
        // 逆序打印
        System.out.println("逆序打印");
        reversePrint(singleLinkedList2.getHead());
        // 修改节点
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟");
        singleLinkedList2.update(newHeroNode);
        System.out.println("修改后的链表");
        singleLinkedList2.list();
        // 删除节点
        singleLinkedList2.del(1);
        singleLinkedList2.del(4);
        System.out.println("删除后的链表");
        singleLinkedList2.list();
        // 获取有效节点数量
        System.out.println("singleLinkedList2有效节点数=" + getLength(singleLinkedList2.getHead()));
    }

    /**
     * 获取单链表有效节点个数
     *
     * @param head 链表的头节点
     * @return 有效节点数量
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        // 定义辅助变量，不统计头节点
        HeroNode temp = head.next;
        while (temp != null) {
            length++;
            // 后移一位，继续遍历
            temp = temp.next;
        }
        return length;
    }

    // 查找单链表中的倒数第K个节点
    // 1. 接收head节点和倒数第index个节点数字
    // 2. 遍历链表，得到链表有效节点的个数
    // 3. 得到length后，遍历链表，得到（length-index）位置的节点
    // 4. 如果找到，返回该节点，否则返回null
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        if (head == null) {
            return null;
        }
        // 获取有效节点个数
        int length = getLength(head);
        if (length <= 0 || index > length) {
            return null;
        }
        // 定义临时变量，遍历到length-index位置
        HeroNode temp = head.next;
        for (int i = 0; i < length - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    // 单链表的反转
    public static void reverseList(HeroNode head) {
        // 如果当前链表为空，或者只有一个节点，则无需反转，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
        // 定义一个临时变量，帮助遍历原来的链表
        HeroNode cur = head.next;
        // 定义next变量，指向cur节点的下一个节点
        HeroNode next = null;
        // 定义临时存放反转过来节点的链表的头节点
        HeroNode reverseHead = new HeroNode(0, "", "");
        // 遍历原来的链表，每遍历一个节点，就将其取出，并放在新链表reverseHead的next位置
        while (cur != null) {
            // 将cur节点的下一个节点，暂时保存在next变量，用于循环最后一步节点后移操作
            next = cur.next;
            // 将reverseHead的下一个节点赋给cur的下一个节点
            cur.next = reverseHead.next;
            // 将cur节点赋给reverseHead下一个节点
            reverseHead.next = cur;
            // 为cur重新赋值，使用前面保存的next数据，相当于把原来的链表节点后移，实现遍历
            cur = next;
        }
        // 将反转后的结果赋给原来链表头节点的下一个节点，实现原来链表的反转
        head.next = reverseHead.next;
    }

    // 逆序打印
    // 将节点压入到栈中，利用栈的先进后出特点
    public static void reversePrint(HeroNode head) {
        if (head.next == null) {
            return;
        }
        // 创建一个栈，将各节点压入栈
        Stack<HeroNode> stack = new Stack<>();
        HeroNode temp = head.next;
        while (temp != null) {
            stack.push(temp);
            // 节点后移
            temp = temp.next;
        }
        // pop后打印
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

}

// 定义HeroNode，每个node对象就是一个节点
class HeroNode {
    // node是带序号的
    public int no;
    public String name;
    public String nickName;
    // 指向下一个节点
    public 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，管理node节点
class SingleLinkedList {
    // 初始化一个头节点，头节点不能栋，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

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

    // 添加节点到单向链表尾部
    // 1. 找到链表最后一个节点
    // 2. 将最后节点的next变量指向新的节点
    public void add(HeroNode heroNode) {
        // 头节点不能动，所以定义临时变量用于遍历链表
        HeroNode temp = head;
        while (true) {
            // next是null，说明temp是最后一个节点
            if (temp.next == null) {
                break;
            }
            // 如果temp不是最后一个节点，就向后移
            temp = temp.next;
        }
        // 当退出while时，就说明temp是链表的最后一个节点
        // 此时将temp节点的下一个节点指向新加入的节点
        temp.next = heroNode;
    }

    // 按序号顺序添加节点（从小到大），如果序号存在，则提示添加失败
    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        // 标记添加的序号是否存在，默认false
        boolean flag = false;
        while (true) {
            // next等于null，说明是最后一个节点
            if (temp.next == null) {
                break;
            }
            // 新节点的序号小于后面节点，则位置找到
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                // 序号存在
                flag = true;
                break;
            }
            // 没找到位置，需要继续后移
            temp = temp.next;
        }
        // 序号存在不能添加
        if (flag) {
            System.out.printf("序号%d已存在，不能添加\n", heroNode.no);
        } else {
            // 插入数据
            // 1. 先将temp的next和temp断开，赋给新节点的next
            heroNode.next = temp.next;
            // 2. 再将新节点赋给temp的后一位
            temp.next = heroNode;
        }
    }

    // 根据no序号修改节点信息
    public void update(HeroNode newHeroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 根据no找到要修改的节点
        // 定义一个辅助变量
        HeroNode temp = head.next;
        // 标记是否找到该节点
        boolean flag = false;
        while (true) {
            // 说明已经遍历完链表，没有找到
            if (temp == null) {
                break;
            }
            // 找到了
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            // 没找到节点，后移
            temp = temp.next;
        }
        // 根据flag判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {
            System.out.printf("%d号节点不存在，修改失败\n", newHeroNode.no);
        }
    }

    // 删除节点
    // 1. head不能栋，需要一个temp辅助变量找到待删除节点的前一个结点
    // 2. 使用temp.next.no 和待删除节点的no比较
    public void del(int no) {
        HeroNode 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) {
            // 将待删除节点的后一个节点赋给待删除节点的前一个节点
            temp.next = temp.next.next;
        } else {
            System.out.printf("待删除的%d号节点不存在\n", no);
        }
    }

    // 显示链表
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 遍历
        HeroNode temp = head.next;
        while (true) {
            // 判断当前节点是否空
            if (temp == null) {
                break;
            } else {
                // 不为空则输出
                System.out.println(temp);
                // 后移一位
                temp = temp.next;
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 打印结果
    随机插入
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
顺序插入
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
list2的倒数第3个节点是：HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
显示反转后的结果
HeroNode{no=4, name='林冲', nickName='豹子头'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
HeroNode{no=1, name='宋江', nickName='及时雨'}
逆序打印
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
修改后的链表
HeroNode{no=4, name='林冲', nickName='豹子头'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=2, name='小卢', nickName='玉麒麟'}
HeroNode{no=1, name='宋江', nickName='及时雨'}
删除后的链表
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=2, name='小卢', nickName='玉麒麟'}
singleLinkedList2有效节点数=2

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
  • 相关阅读:
    利用Msray-plus采集软件，营销人员的工作效率得到极大提升！
    SVG鼠标漫游
    吴恩达机器学习-可选实验室：逻辑回归（Logistic Regression））
    Day_43插入排序
    免费的云产品
    windows10关闭自动更新
    FileZilla的安装流程
    云服务器配置Code-Server环境并运行Python和C++
    使用密集预测变压器的图像语义分割--附源码下载
    ElasticSearch安装 &es基本操作& 安装es中文分词& ========= springboot 整合ElasticSearch
  • 原文地址：https://blog.csdn.net/qq_40977118/article/details/125416790