第二章-数据结构之链表

最新推荐文章于 2023-02-26 16:05:40 发布
最新推荐文章于 2023-02-26 16:05:40 发布
阅读量410 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/109274318
版权

文章目录

第二章-链表

1.链表(Linked List)介绍

1.1 内存结构

image-20201019203816653

  • 链表是以节点的方式来存储的,是链式存储
  • 每个节点包含 data 域：存放数据， next 域：指向下一个节点
  • 链表的各个节点不一定是连续存储，比如a1的地址是150，而next指向的a2地址是110
  • 链表分带头节点的链表和没有头节点的链表

1.2 逻辑结构

image-20201019204743453

链表的逻辑结构虽然看起来像是连续的，但实际上的结构如1.1的内存结构所示，链表的存储空间是不连续的

2.链表的应用场景

使用带head头的单向链表实现 –水浒英雄排行榜管理
完成对英雄人物的增删改查操作
第一种方法在添加英雄时，直接添加到链表的尾部
第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

image-20201019213209740

2.1 直接插入链表

image-20200725211512478

//第一种方法在添加英雄时，直接添加到链表的尾部
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();

        // 将Hero对象加入链表
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);

        //遍历链表并显示
        singleLinkedList.list();
    }
}

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    /**
     * 思路，当不考虑编号顺序时
     *  1.找到当前链表的最后节点
     *  2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 显示链表[遍历链表]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {

    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;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
    }

}

程序运行结果

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]

2.2 按顺序插入链表

image-20200726111924129

第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)
 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.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        //遍历链表并显示
        singleLinkedList.list();
    }
}

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    // 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // (如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        // 因为是单链表，因此我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; // flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {// 说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) { // 位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已然存在

                flag = true; // 说明编号存在
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断flag 的值
        if (flag) { // 如果flag为true，不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            // 插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 显示链表[遍历链表]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {

    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;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
    }

}

程序运行结果

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]

2.3 修改单链表的节点信息

思路
(1) 先找到该节点，通过遍历
(2) temp.name = newHeroNode.name ; 
		temp.nickname= newHeroNode.nickname

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();

        // 将Hero对象加入链表
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);

        //加入按照编号的顺序
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        System.out.println("修改前的链表情况:");
        singleLinkedList.list();

        // 测试修改节点的代码
        HeroNode newHeroNode = new HeroNode(2, "小卢", "小玉");
        singleLinkedList.update(newHeroNode);

        System.out.println("修改后的链表情况:");
        singleLinkedList.list();
    }
}

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    /**
     * 思路，当不考虑编号顺序时
     *  1.找到当前链表的最后节点
     *  2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // (如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        // 因为是单链表，因此我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; // flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {// 说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) { // 位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已然存在

                flag = true; // 说明编号存在
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断flag 的值
        if (flag) { // 如果flag为true，不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            // 插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 修改节点的信息, 根据no编号来修改，即no编号不能改.
    // 说明
    // 1. 根据 newHeroNode 的 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; //temp后移
        }
        // 根据flag 判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else { // 没有找到
            System.out.printf("没有找到 编号为 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

    // 显示链表[遍历链表]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {

    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;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + 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=豹子头]

2.4 删除单链表的节点

image-20200726111912029

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();

        // 将Hero对象加入链表
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);

        //加入按照编号的顺序
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        System.out.println("修改前的链表情况:");
        singleLinkedList.list();

        // 测试修改节点的代码
        HeroNode newHeroNode = new HeroNode(2, "小卢", "小玉");
        singleLinkedList.update(newHeroNode);

        System.out.println("修改后的链表情况:");
        singleLinkedList.list();

        //删除节点
        singleLinkedList.del(1);
        singleLinkedList.del(4);

        System.out.println("删除后的链表情况:");
        singleLinkedList.list();

    }
}

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    /**
     * 思路，当不考虑编号顺序时
     *  1.找到当前链表的最后节点
     *  2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // (如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        // 因为是单链表，因此我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; // flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {// 说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) { // 位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已然存在

                flag = true; // 说明编号存在
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断flag 的值
        if (flag) { // 如果flag为true，不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            // 插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 修改节点的信息, 根据no编号来修改，即no编号不能改.
    // 说明
    // 1. 根据 newHeroNode 的 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; //temp后移
        }
        // 根据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) {
                // 找到 待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }
        // 判断flag
        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;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {

    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;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + 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=智多星]

3.单链表的常见面试题

3.1 求单链表中的有效节点个数

//方法：获取单链表有效节点的个数(如果是带头结点的链表，需求不统计头节点)
    /**
     * @param head 链表的头节点
     * @return 返回的就是有效节点的个数
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) { // 空链表
            return 0;
        }
        int length = 0;
        // 定义一个辅助的变量(指针), 这里我们没有统计头节点
        HeroNode cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next; // 遍历
        }
        return length;
    }

测试代码

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.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        //删除节点
        singleLinkedList.del(1);
        singleLinkedList.del(4);

        // 测试一下 求单链表中有效节点的个数
        System.out.println("有效的节点个数=" + getLength(singleLinkedList.getHead()));// 2
    }

程序运行结果

有效的节点个数=2

3.2 查找单链表中的倒数第k个节点[新浪面试题]

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();

        // 将Hero对象加入链表
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);

        //加入按照编号的顺序
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        System.out.println("修改前的链表情况:");
        singleLinkedList.list();

        // 测试修改节点的代码
        HeroNode newHeroNode = new HeroNode(2, "小卢", "小玉");
        singleLinkedList.update(newHeroNode);

        System.out.println("修改后的链表情况:");
        singleLinkedList.list();

        //删除节点
        singleLinkedList.del(1);
        singleLinkedList.del(4);

        System.out.println("删除后的链表情况:");
        singleLinkedList.list();

        // 测试一下 求单链表中有效节点的个数
        System.out.println("有效的节点个数=" + getLength(singleLinkedList.getHead()));// 2

        // 测试一下看看是否得到了倒数第K个节点
        HeroNode res = findLastIndexNode(singleLinkedList.getHead(), 2);
        System.out.println("res=" + res);
    }

    //方法：获取单链表有效节点的个数(如果是带头结点的链表，需求不统计头节点)
    /**
     * @param head 链表的头节点
     * @return 返回的就是有效节点的个数
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) { // 空链表
            return 0;
        }
        int length = 0;
        // 定义一个辅助的变量(指针), 这里我们没有统计头节点
        HeroNode cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next; // 遍历
        }
        return length;
    }

    // 查找单链表中的倒数第k个结点
    // 思路
    // 1. 编写一个方法，接收head节点，同时接收一个index
    // 2. index 表示 倒数第index个节点
    // 3. 先把链表从头到尾遍历，得到链表的总长度 getLength
    // 4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
    // 5. 如果找到了，则返回该节点，否则返回nulll
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        // 判断如果链表为空，返回null
        if (head.next == null) { //链表为空
            return null;// 没有找到
        }
        // 第一次遍历得到链表的长度(节点个数)
        int size = getLength(head);
        // 第二次遍历到 (size-index) 的位置，就是我们倒数的第K个节点
        // 先做一个index的校验
        if (index <= 0 || index > size) {
            return null;
        }
        // 定义辅助变量 cur， for循环定位到倒数的index
        HeroNode cur = head.next;
        for (int i = 0; i < size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

}

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

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

    //添加节点到单向链表
    /**
     * 思路，当不考虑编号顺序时
     *  1.找到当前链表的最后节点
     *  2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // (如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        // 因为是单链表，因此我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; // flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {// 说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) { // 位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已然存在

                flag = true; // 说明编号存在
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断flag 的值
        if (flag) { // 如果flag为true，不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            // 插入到链表中, temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 修改节点的信息, 根据no编号来修改，即no编号不能改.
    // 说明
    // 1. 根据 newHeroNode 的 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; //temp后移
        }
        // 根据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) {
                // 找到 待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }
        // 判断flag
        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;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {

    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;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + 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=智多星]
有效的节点个数=2
res=HeroNode [no=2, name=小卢, nickName=小玉]

3.3 单链表的反转[腾讯面试题,有点难度]

image-20200725212137897

image-20200726111854627

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();

        // 将Hero对象加入链表
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);

        // 测试一下单链表的反转功能
        System.out.println("原来链表的情况:");
        singleLinkedList.list();

        System.out.println("反转单链表:");
        reversetList(singleLinkedList.getHead());
        singleLinkedList.list();
    }

    //将单链表进行反转
    public static void reversetList(HeroNode head) { //给定要反转链表的头结点
        //如果当前链表为空，或者只有一个节点，无需反转，直接返回
        if(head.next == null || head.next.next == null) {
            return;
        }
        //定义一个辅助变量(指针),帮助我们遍历原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;// 指向当前节点[cur]的下一个节点
        //新建一个链表
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
        while (cur != null) {
            next = cur.next; //先暂时保存当前节点的下一个节点，因为后面需要使用
            cur.next = reverseHead.next;// 将cur的下一个节点指向新的链表的最前端
            reverseHead.next = cur; // 将cur 连接到新的链表上
            cur = next;// 让cur后移
        }
        // 将head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;
    }

}

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

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

    //添加节点到单向链表
    /**
     * 思路，当不考虑编号顺序时
     *  1.找到当前链表的最后节点
     *  2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 显示链表[遍历链表]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {

    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;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
    }

}

程序运行结果

原来链表的情况:
HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=4, name=林冲, nickName=豹子头]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
反转单链表:
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=4, name=林冲, nickName=豹子头]
HeroNode [no=1, name=宋江, nickName=及时雨]

3.4 从尾到头打印单链表[百度面试题]

image-20200726111808563

//演示栈Stack的基本使用
public class TestStack {

    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        //入栈操作
        stack.add("jack");
        stack.add("tom");
        stack.add("smith");

        //出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop());//pop就是将栈顶的数据取出
        }
    }
}

程序运行结果

smith
tom
jack

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();

        // 将Hero对象加入链表
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero4);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);

        System.out.println("原来链表的情况:");
        singleLinkedList.list();

      	System.out.println("测试逆序打印单链表, 没有改变链表的结构");
        reversePrint(singleLinkedList.getHead());
    }
  
  	// 使用方式2：
    // 可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
    public static void reversePrint(HeroNode head) { //给定链表的头结点
        if (head.next == null) {
            return;// 空链表，不能打印
        }
        // 创建一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        //定义一个辅助变量(指针)，遍历链表
        HeroNode cur = head.next;
        // 将链表的所有节点压入栈
        while (cur != null) {
            stack.push(cur); //将cur节点压入栈中
            cur = cur.next; // cur后移，这样就可以压入下一个节点
        }
        // 将栈中的节点进行打印,pop 出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop()); // stack的特点是先进后出
        }
    }

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

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

    //添加节点到单向链表
    /**
     * 思路，当不考虑编号顺序时
     *  1.找到当前链表的最后节点
     *  2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 显示链表[遍历链表]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {

    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;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
    }

}

程序运行结果

原来链表的情况:
HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=4, name=林冲, nickName=豹子头]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
测试逆序打印单链表, 没有改变链表的结构
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=4, name=林冲, nickName=豹子头]
HeroNode [no=1, name=宋江, nickName=及时雨]

3.5 合并两个有序的单链表，合并之后的链表仍然有序

public class MergeList {

    public static void main(String[] args) {

        SingleLinkedList list1 = new SingleLinkedList();
        list1.add(new Node(1));
        list1.add(new Node(3));
        list1.add(new Node(5));
        list1.add(new Node(7));
        list1.add(new Node(9));

        SingleLinkedList list2 = new SingleLinkedList();
        list2.add(new Node(2));
        list2.add(new Node(4));
        list2.add(new Node(6));
        list2.add(new Node(6));
        list2.add(new Node(8));
        list2.add(new Node(10));
        list2.add(new Node(11));
        list2.add(new Node(12));

        // 合并链表
        SingleLinkedList mergeList = merge(list1.head, list2.head);
        System.out.println("合并后的链表如下:");
        mergeList.show();
    }

    public static SingleLinkedList merge(Node head1,Node head2) {
        //创建新链表的头结点
        Node head = new Node(0);

        SingleLinkedList mergeList = new SingleLinkedList();
        mergeList.head = head;

        Node temp = head;
        Node temp1 = head1.next;
        Node temp2 = head2.next;

        while (temp1 != null && temp2 != null) {
            if(temp1.data <= temp2.data) {
                temp.next = temp1;
                temp1 = temp1.next;
            }else {
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }

        while (temp1 != null) {
            temp.next = temp1;
            temp1 = temp1.next;
        }
        while (temp2 != null) {
            temp.next = temp2;
            temp2 = temp2.next;
        }

        return mergeList;
    }

}

//定义链表管理节点
class SingleLinkedList {

    //首先定义一个头结点，头节点不要动, 不存放具体的数据
    Node head = new Node(0);

    //添加节点到单链表，要求排好序，如果数据相等，则直接插入
    public void add(Node node) {
        //定义一个指针
        Node temp = head;

        while (true) {
            if(temp.next == null) { //说明temp已经在链表的最后
                //直接在temp的后面插入节点
                temp.next = node;
                break;
            }
            if (temp.next.data > node.data) {
                // 插入到链表中, temp的后面
                node.next = temp.next;
                temp.next = node;
                break;
            }else if (temp.next.data == node.data) {
                //如果要添加的数据与temp的下一个节点的数据相等
                //就直接在temp的下一个节点的后面插入即可
                temp.next.next = node;
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
    }

    //遍历链表
    public void show() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助变量来遍历
        Node temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//创建节点类
class Node {
    public Integer data; //数据
    public Node next; //指向下一个节点

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

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                '}';
    }
}

程序运行结果

合并后的链表如下:
Node{data=1}
Node{data=2}
Node{data=3}
Node{data=4}
Node{data=5}
Node{data=6}
Node{data=6}
Node{data=7}
Node{data=8}
Node{data=9}
Node{data=12}

4.双向链表

单向链表和双向链表的区别

1.单向链表， 查找的方向只能是一个方向， 而双向链表可以向前或者向后查找
2.单向链表不能自我删除， 需要靠辅助节点 ， 而双向链表， 则可以自我删除， 所以前面我们单链表删除时节点， 总是找到 temp ，temp 是待删除节点的前一个节点(认真体会)

image-20200726111748987

4.1 链表节点的定义

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode2 {

    public int no; //编号
    public String name; //名字
    public String nickName; //昵称
    public HeroNode2 next; // 指向下一个节点，默认为null
    public HeroNode2 pre; // 指向前一个节点，默认为null

    //构造器
    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickName = nickname;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode2 [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
    }

}

4.2 双向链表遍历

//遍历双向链表的方法
    // 显示链表[遍历链表]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode2 temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

4.3 尾部插入节点

//添加一个节点到双向链表的最后
    public void add(HeroNode2 heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode2 temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //形成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

4.4 按顺序插入节点

// 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // (如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode2 heroNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        HeroNode2 temp = head;
        boolean flag = false; // flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {// 说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) { // 位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已然存在
                flag = true; // 说明编号存在
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断flag 的值
        if (flag) { // 如果flag为true，不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            // 插入到链表中, temp的后面

            // heroNode 指向 temp 节点的下一个节点
          	heroNode.next = temp.next;
            if(temp.next != null) {
                temp.next.pre = heroNode;
            }

            // temp 节点指向 heroNode 节点
            temp.next = heroNode;
            heroNode.pre = temp;
        }
    }

4.5 修改节点信息

// 修改一个节点的内容, 可以看到双向链表的节点内容修改和单向链表一样
    // 只是 节点类型改成 HeroNode2
    public void update(HeroNode2 newHeroNode) {
        // 判断是否空
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        // 找到需要修改的节点, 根据no编号查找
        // 定义一个辅助变量
        HeroNode2 temp = head.next;
        boolean flag = false; // 表示是否找到该节点
        //遍历当前链表
        while (true) {
            if (temp == null) {
                break; // 已经遍历完链表
            }
            if (temp.no == newHeroNode.no) {
                // 找到
                flag = true;
                break;
            }
            temp = temp.next; //temp后移
        }
        // 根据flag 判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else { // 没有找到
            System.out.printf("没有找到 编号为 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

4.6 删除节点

// 从双向链表中删除一个节点,
    // 说明
    // 1 对于双向链表，我们可以直接找到要删除的这个节点
    // 2 找到后，自我删除即可
    public void del(int no) {

        // 判断当前链表是否为空
        if (head.next == null) {// 空链表
            System.out.println("链表为空，无法删除");
            return;
        }

        HeroNode2 temp = head.next; // 辅助变量(指针)
        boolean flag = false; // 标识是否找到待删除节点的
        while (true) {
            if (temp == null) { // 已经到链表的最后
                break;
            }
            if (temp.no == no) {
                // 找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }
        // 判断flag
        if (flag) { // 找到
            // 可以删除
            // temp.next = temp.next.next;[单向链表]
            temp.pre.next = temp.next;
            // 这里我们的代码有问题?
            // 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针异常
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

4.7 双向链表测试结果

双向链表的测试:
HeroNode2 [no=1, name=宋江, nickName=及时雨]
HeroNode2 [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode2 [no=3, name=吴用, nickName=智多星]
HeroNode2 [no=5, name=林冲, nickName=豹子头]
按顺序插入后的情况
HeroNode2 [no=1, name=宋江, nickName=及时雨]
HeroNode2 [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode2 [no=3, name=吴用, nickName=智多星]
HeroNode2 [no=4, name=Heygo, nickName=Heygogo]
HeroNode2 [no=5, name=林冲, nickName=豹子头]
HeroNode2 [no=6, name=Oneby, nickName=Onebyone]
修改后的链表情况:
HeroNode2 [no=1, name=宋江, nickName=及时雨]
HeroNode2 [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode2 [no=3, name=吴用, nickName=智多星]
HeroNode2 [no=4, name=Heygo, nickName=Heygogo]
HeroNode2 [no=5, name=公孙胜, nickName=入云龙]
HeroNode2 [no=6, name=Oneby, nickName=Onebyone]
删除后的链表情况:
HeroNode2 [no=1, name=宋江, nickName=及时雨]
HeroNode2 [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode2 [no=4, name=Heygo, nickName=Heygogo]
HeroNode2 [no=5, name=公孙胜, nickName=入云龙]
HeroNode2 [no=6, name=Oneby, nickName=Onebyone]

4.8 双向链表所有代码

public class DoubleLinkedListDemo {

    public static void main(String[] args) {
        // 测试
        System.out.println("双向链表的测试:");

        // 先创建节点
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 hero4 = new HeroNode2(5, "林冲", "豹子头");

        // 创建一个双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();

        // 测试按需插入
        doubleLinkedList.addByOrder(new HeroNode2(4, "Heygo", "Heygogo"));
        doubleLinkedList.addByOrder(new HeroNode2(6, "Oneby", "Onebyone"));
        System.out.println("按顺序插入后的情况");
        doubleLinkedList.list();

        // 修改
        HeroNode2 newHeroNode = new HeroNode2(5, "公孙胜", "入云龙");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表情况:");
        doubleLinkedList.list();

        // 删除
        doubleLinkedList.del(3);
        System.out.println("删除后的链表情况:");
        doubleLinkedList.list();
    }

}

//创建一个双向链表的类
class DoubleLinkedList {

    //先初始化一个头节点, 头节点不要动, 不存放具体的数据
    private HeroNode2 head = new HeroNode2(0,"","");

    //返回头结点head
    public HeroNode2 getHead() {
        return head;
    }

    //添加一个节点到双向链表的最后
    public void add(HeroNode2 heroNode){
        //因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode2 temp = head; //相当于此时的指针指向head节点
        //遍历链表，找到最后的节点
        while (true) {
            //找到链表的最后一个节点
            if(temp.next == null) {
                break;
            }
            //如果没有找到最后的节点，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //形成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    // 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // (如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode2 heroNode) {
        // 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        HeroNode2 temp = head;
        boolean flag = false; // flag标识添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {// 说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) { // 位置找到，就在temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已然存在
                flag = true; // 说明编号存在
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断flag 的值
        if (flag) { // 如果flag为true，不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
        } else {
            // 插入到链表中, temp的后面

            // heroNode 指向 temp 节点的下一个节点
          	heroNode.next = temp.next;
            if(temp.next != null) {
                temp.next.pre = heroNode;
            }

            // temp 节点指向 heroNode 节点
            temp.next = heroNode;
            heroNode.pre = temp;
        }
    }

    // 修改一个节点的内容, 可以看到双向链表的节点内容修改和单向链表一样
    // 只是 节点类型改成 HeroNode2
    public void update(HeroNode2 newHeroNode) {
        // 判断是否空
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        // 找到需要修改的节点, 根据no编号查找
        // 定义一个辅助变量
        HeroNode2 temp = head.next;
        boolean flag = false; // 表示是否找到该节点
        //遍历当前链表
        while (true) {
            if (temp == null) {
                break; // 已经遍历完链表
            }
            if (temp.no == newHeroNode.no) {
                // 找到
                flag = true;
                break;
            }
            temp = temp.next; //temp后移
        }
        // 根据flag 判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else { // 没有找到
            System.out.printf("没有找到 编号为 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

    // 从双向链表中删除一个节点,
    // 说明
    // 1 对于双向链表，我们可以直接找到要删除的这个节点
    // 2 找到后，自我删除即可
    public void del(int no) {

        // 判断当前链表是否为空
        if (head.next == null) {// 空链表
            System.out.println("链表为空，无法删除");
            return;
        }

        HeroNode2 temp = head.next; // 辅助变量(指针)
        boolean flag = false; // 标识是否找到待删除节点的
        while (true) {
            if (temp == null) { // 已经到链表的最后
                break;
            }
            if (temp.no == no) {
                // 找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }
        // 判断flag
        if (flag) { // 找到
            // 可以删除
            // temp.next = temp.next.next;[单向链表]
            temp.pre.next = temp.next;
            // 这里我们的代码有问题?
            // 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针异常
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

    //遍历双向链表的方法
    // 显示链表[遍历链表]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode2 temp = head.next; //辅助变量指向第一个节点
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移，一定要记得后移
            temp = temp.next;
        }
    }

}

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode2 {

    public int no; //编号
    public String name; //名字
    public String nickName; //昵称
    public HeroNode2 next; // 指向下一个节点，默认为null
    public HeroNode2 pre; // 指向前一个节点，默认为null

    //构造器
    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickName = nickname;
    }

    // 为了显示方便，重写toString方法，注意不要打印next，能够清晰一点
    @Override
    public String toString() {
        return "HeroNode2 [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
    }

}

5.单向环形链表

5.1 单向环形链表图解

image-20200714115444129

5.2 约瑟夫问题

Josephu 问题为： 设编号为 1， 2， … n 的 n 个人围坐一圈， 约定编号为 k（1<=k<=n） 的人从 1 开始报数， 数到 m 的那个人出列， 它的下一位又从 1 开始报数， 数到 m 的那个人又出列， 依次类推， 直到所有人出列为止， 由此产生一个出队编号的序列。

思路

用一个不带头结点的循环链表来处理 Josephu 问题： 先构成一个有 n 个结点的单循环链表， 然后由 k 结点起从 1 开始计数， 计到 m 时， 对应结点从链表中删除， 然后再从被删除结点的下一个结点又从 1 开始计数， 直到最后一个结点从链表中删除算法结束。

image-20200726113254075

5.3 环形链表的构建与遍历

image-20200726113301153

5.3.1 Boy 节点的定义
//创建一个Boy类，表示一个节点
class Boy {
    private int no; //编号
    private Boy next; //指向下一个节点，默认为null

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}
5.3.2 单向循环链表的定义
//创建一个环形的单向链表
class CircleSingleLinkedList {

    // 创建一个first节点,当前没有编号
    private Boy first = null;

    //添加小孩节点，构建成一个环形的链表
    public void addBoy(int nums) { //添加的节点个数
        //nums 做一个数据的校验
        if(nums < 1) {
            System.out.println("nums的值不正确!");
            return;
        }
        Boy curBoy = null; // 辅助变量(指针)，帮助构建环形链表
        //使用for循环来创建环形链表
        for (int i = 1; i <= nums; i++) {
            //根据编号，创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first); //构成环状
                curBoy = first; // 让curBoy指向第一个小孩
            }else {
                curBoy.setNext(boy); // 将 boy 节点加到链表尾部
                boy.setNext(first); // 构成环状
                curBoy = boy; // curBoy 指针后移
            }
        }
    }

    // 遍历当前的环形链表
    public void showBoy() {
        //先判断链表是否为空
        if(first == null) {
            System.out.println("没有任何小孩");
            return;
        }
        // 因为first不能动，因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("小孩的编号 %d \n", curBoy.getNo());
            if (curBoy.getNext() == first) { // 说明已经遍历完毕
                break;
            }
            curBoy = curBoy.getNext(); // curBoy指针后移
        }
    }

}

public static void main(String[] args) {
        // 测试一把看看构建环形链表，和遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);// 加入5个小孩节点
        circleSingleLinkedList.showBoy();
    }

程序运行结果

小孩的编号 1 
小孩的编号 2 
小孩的编号 3 
小孩的编号 4 
小孩的编号 5

5.4 约瑟夫问题代码实现

image-20200726113448880

//根据用户的输入，计算出小孩出圈的顺序
    /**
     * @param startNo 表示从第几个小孩开始数数
     * @param countnum 表示数几下
     * @param nums 表示最初有多少小孩在圈中
     */
    public void countBoy(int startNo,int countnum,int nums) {
        //先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误，请重新输入!");
            return;
        }
        //创建一个辅助指针，帮助小孩出圈
        Boy helper = first;
        // 需求创建一个辅助指针(变量) helper , 事先应该指向环形链表的最后这个节点
        while (true) {
            if (helper.getNext() == first) { // 说明helper指向最后小孩节点
                break;
            }
            helper = helper.getNext();
        }
        //小孩报数前，先让first 和 helper 移动 k-1次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 让 first 和 helper 指针同时 移动 countNum - 1, 然后出圈
        //这里是一个循环操作，直到圈中只有一个节点
        while (true) {
            if (helper == first) { //说明圈中只有一个节点
                break;
            }
            //让 first 和 helper 指针同时 的移动 countNum - 1
            for (int j = 0; j < countnum - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时first指向的节点，就是要出圈的小孩节点
            System.out.printf("小孩%d出圈\n", first.getNo());
            // 这时将first指向的小孩节点出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());
    }

public static void main(String[] args) {
        // 测试一把看看构建环形链表，和遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);// 加入5个小孩节点
        circleSingleLinkedList.showBoy();

        // 测试一把小孩出圈是否正确
        circleSingleLinkedList.countBoy(1, 2, 5); // 2->4->1->5->3
    }

程序运行结果

小孩的编号 1 
小孩的编号 2 
小孩的编号 3 
小孩的编号 4 
小孩的编号 5 
小孩2出圈
小孩4出圈
小孩1出圈
小孩5出圈
最后留在圈中的小孩编号3

5.5 约瑟夫问题所有代码

public class Josephu {

    public static void main(String[] args) {
        // 测试一把看看构建环形链表，和遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);// 加入5个小孩节点
        circleSingleLinkedList.showBoy();

        // 测试一把小孩出圈是否正确
        circleSingleLinkedList.countBoy(1, 2, 5); // 2->4->1->5->3
    }
}

//创建一个环形的单向链表
class CircleSingleLinkedList {

    // 创建一个first节点,当前没有编号
    private Boy first = null;

    //添加小孩节点，构建成一个环形的链表
    public void addBoy(int nums) { //添加的节点个数
        //nums 做一个数据的校验
        if(nums < 1) {
            System.out.println("nums的值不正确!");
            return;
        }
        Boy curBoy = null; // 辅助变量(指针)，帮助构建环形链表
        //使用for循环来创建环形链表
        for (int i = 1; i <= nums; i++) {
            //根据编号，创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first); //构成环状
                curBoy = first; // 让curBoy指向第一个小孩
            }else {
                curBoy.setNext(boy); // 将 boy 节点加到链表尾部
                boy.setNext(first); // 构成环状
                curBoy = boy; // curBoy 指针后移
            }
        }
    }

    // 遍历当前的环形链表
    public void showBoy() {
        //先判断链表是否为空
        if(first == null) {
            System.out.println("没有任何小孩");
            return;
        }
        // 因为first不能动，因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("小孩的编号 %d \n", curBoy.getNo());
            if (curBoy.getNext() == first) { // 说明已经遍历完毕
                break;
            }
            curBoy = curBoy.getNext(); // curBoy指针后移
        }
    }

    //根据用户的输入，计算出小孩出圈的顺序
    /**
     * @param startNo 表示从第几个小孩开始数数
     * @param countnum 表示数几下
     * @param nums 表示最初有多少小孩在圈中
     */
    public void countBoy(int startNo,int countnum,int nums) {
        //先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误，请重新输入!");
            return;
        }
        //创建一个辅助指针，帮助小孩出圈
        Boy helper = first;
        // 需求创建一个辅助指针(变量) helper , 事先应该指向环形链表的最后这个节点
        while (true) {
            if (helper.getNext() == first) { // 说明helper指向最后小孩节点
                break;
            }
            helper = helper.getNext();
        }
        //小孩报数前，先让first 和 helper 移动 k-1次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 让 first 和 helper 指针同时 移动 countNum - 1, 然后出圈
        //这里是一个循环操作，直到圈中只有一个节点
        while (true) {
            if (helper == first) { //说明圈中只有一个节点
                break;
            }
            //让 first 和 helper 指针同时 的移动 countNum - 1
            for (int j = 0; j < countnum - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时first指向的节点，就是要出圈的小孩节点
            System.out.printf("小孩%d出圈\n", first.getNo());
            // 这时将first指向的小孩节点出圈
            first = first.getNext();
            helper.setNext(first);
        }

        System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());

    }

}

//创建一个Boy类，表示一个节点
class Boy {
    private int no; //编号
    private Boy next; //指向下一个节点，默认为null

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}
猿小羽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Acwing-基础算法-第二章-数据结构
03-24
以下是对标题“Acwing-基础算法-第二章-数据结构”和描述中涉及的知识点的详细说明： 1. **链表**： - 单链表：由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在单链表中，插入和删除操作相对简单，...
第 4 章 链表
Oneby的博客
07-26 4443
第 4 章 链表 1、链表(Linked List)介绍 1.1、内存结构 内存上来看：链表存储空间不连续（不像数组） 1.2、逻辑结构 逻辑上来看：链表属于线性结构 1.3、链表特点 链表是以节点的方式来存储，是链式存储 data 域存放数据，next 域指向下一个节点 链表分带头节点的链表和没有头节点的链表， 根据实际的需求来确定 2、链表应用场景 2.1、水浒英雄榜 使用带 head 头的单向链表实现【水浒英雄排行榜管理】 2.2、链表节点定义 no ：英雄编号 name ：英
单项链表和双向链表-实现英雄节点的增删改操作
Passer-Go
05-27 149
一、单项链表 单向链表逻辑结构意图 1.定义一个英雄节点类 //定义一个HeroNode，每个HeroNode对象就是一个节点 class HeroNode{ public int no;//编号 public String name ;//姓名 public String nickName ;//昵称 public HeroNode next;//next指向下一个节点 //构造器 public HeroNode(int no, String nam
【数据结构】数组 VS 链表
weixin_72504310的博客
09-07 1014
数组 VS 链表
C语言数据结构篇——循环链表的创建，插入，节点删除，打印等操作
m0_68382289的博客
02-26 2476
C语言数据结构篇——循环链表的创建，插入，节点删除，打印等操作
链表（线性表的一种存储结构）
Mafia的博客
03-08 3907
链表一、单链表1.代码定义单链表2.两种实现带头结点不带头结点3.单链表的操作插入按位序插入指定结点的后插操作指定结点的前插操作删除按位序删除指定结点的删除查找 链表分为 单链表 双链表 循环链表 静态链表 一、单链表 顺序表（顺序存储）： 每个节点中只存放数据元素。优点：可随机存取，存储密度高；缺点：要求大片连续空间，改变容量较为麻烦。 单链表（链式存储）： 每个结点除了存放数据元素外，还要存储指向下一个节点的指针。优点：不要求大量连续空间，可以很方便地拓展容量；缺点：不可随机存取，要耗费一定空间存放
数据结构第二章-2.3
11-23
本章节“数据结构第二章-2.3”主要聚焦于链式数据结构，包括静态链表、顺序表与链表的比较、单链表的建立、循环链表以及双链表。 首先，我们来看静态链表。静态链表是一种在内存中预先分配好连续空间的数据结构，与...
数据结构第二章参考答案.doc
12-17
数据结构是计算机科学中最重要的基础知识之一，本章参考答案涵盖了数据结构第二章的主要知识点，包括单链表、顺序表、链表、静态链表、双链表、循环链表、顺序存储结构、链式存储结构、动态内存管理、STL 中的容器等...
数据结构第二章2.1-2.2
最新发布
11-23
在第二章中，我们主要关注两种基础且重要的数据结构：线性表和链表，具体包括它们的定义、基本操作以及查找和插入删除的算法。 2.1 线性表的定义和基本操作 线性表是一种最基本的数据结构，由n（n≥0）个相同类型...
算法与数据结构课件PPT第二章
07-16
在本章中，我们主要探讨了线性表这一基本数据结构。线性表是由n（n ≥ 0）个相同性质的元素组成的一个有序序列。它具有起点和终点，起点没有前驱，终点没有后继，其他元素都有一个直接前驱和一个直接后继。例如，...
链表（篇1）循环有序链表中插入节点
有图有真相
03-16 2704
在循环有序链表中插入一个新值。例如：插入7之后算法： 为新插入的节点分配内存，并将数据放在新分配的节点中。让指向新节点的指针是new_node。在内存分配之后，以下是需要处理的三种情况。1）链接为空： a）因为new_node是循环链表中的唯一节点，所以进行自循环。 new_node-> next = new_node; b）更改头指针以指向
循环链表的创建及按需插入节点
qq_43792862的博客
05-04 898
环境：C++ VS2013 目的：先创建一个框架，输入一个字符串数据就是一个节点，节点信息还包括字符串长度，当输入的字符串数目大于100条时进行循环，即第101条字符串覆盖在第1条字符串的节点上。 注：在练习时发现， ...
创建并操作循环链表
weixin_56273009的博客
04-07 1478
【问题描述】 输入n个整数，创建一个双向循环链表进行存储。这些整数从第二个开始，递增有序（设a2<a3<...<an） (ai为第i个整数)。 试编写程序，创建双向循环链表，依次将输入的整数存储在该链表的各节点中。然后，将第一个结点删除并插入链表中的适当位置，使整个链表递增有序。 【输入形式】 先输入整数的个数，再输入整数列。 【输出形式】 以整数递增的顺序，依次输出双向循环链表各个节点存储的整数。 【样例输入】 5 3 1 2 4 5 【样例输出】 1 2 3 4 5
计算机操作系统实验-进程调度算法（自己学习使用）
Fengshiyiaaaa的博客
05-08 1871
操作系统实验
数据结构之链表操作（单链表，单向循环链表，双向循环链表）查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等操作
qq_45698138的博客
05-16 2077
一、线性表 线性表结构的数据是依次排列（一对一） （1）顺序结构：数组，顺序栈，顺序队列（顺序表） （2）链式存储：链表，链式栈，链式队列（线性表） 二、链表 2.1、链表 ​ 链表是一种具体的数据结构 ​ 1、逻辑上：一对一的排列 ​ 2、存储上：非连续的 ​ 3、算法：查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等等 ​ 4、链表分类 ​ 单向链表，双向链表，单向循环链表，双向循环链表 ​ 5、链式存储特点 ​ 不需要一块连续
（二）单链表
Apikaqiu的博客
05-15 767
线性表的顺序存储的特点是逻辑上相邻的两个元素在物理位置上也相邻。因此可以随机存取表中的任一一个元素。但是这种存储方式存在的缺点是插入或者删除的时候，需要大量移动元素。 链式存储可以避免顺序存储的弱点，但同时也失去了顺序表课随机存取的优点。 线性链表：链式存储结构–用一组任意的存储单元存储线性表的数据元素（这组讯处单元可以是连续的也可以是不连续的）。链表的基本单元称为节点（node）。节点包括两个域：其中，存储数据元素信息的域称作数据域；存储直接后继存储位置的域称作指针域。 用线性链表表示线性表的时候，数据元
内存与链表
张昆
11-22 1061
内存分配与释放
基于连续存储空间的链表实现
小猪爱拱地
08-23 1303
根据算法导论　“10.3 Implementing pointers and objects”　这一章节实现。 list.h: #ifndef _LINK_LIST_HEADER_ void init_list(); int push_back(int key); int push_front(int key); void erase(int key); void print_list(v
每日一道小算法[十三] [链表] 单链表中的倒数第k个节点
qq_39397165的博客
02-07 158
前言： 还是没坚持住每天更新一道算法题，自己不会的东西太多，每天都要看很多的东西来充实自己，所以也没有每天都刷算法题，今天正好看到了一道算法题，赶紧来实现一下。 题目描述 一个单链表，求出单链表中倒数第K个节点。 题目解析 这一道题其实挺简单的，首先能想到的一个办法就是使用遍历一遍链表长度，然后链表长度减去K加1就是倒数第K个节点。这种方法实现简单，但是时间复杂度会很高，因为第一次就遍了链表。所...
数据结构第二章-线性表详解
"本章小结-数据结构第二章，主要涵盖了线性表的基本概念、顺序存储和链式存储的特点，以及单链表、双向链表和循环链表的介绍。" 在数据结构中，线性表是一个重要的基础概念，它是由n个数据元素构成的有限序列，每个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿小羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值