数据结构与算法_1.稀疏数组和队列_2

1.2 队列

---

• 单链表
  • 链表为有序列表，在内存中的存储如下：
    
    1. 链表是以节点的方式来存储，是链式存储。
    2. 每个节点包含：data 域和 next 域（指向下一个节点）。
    3. 链表的各个节点不一定是连续存储的。
    4. 链表分有头节点的链表和没有头节点的链表，根据实际的需求来确定。
  • 代码实现：

/*
	1. 第一种方法：添加节点时，直接添加到链表尾部
*/
public class Demo01SingleLinkedList {
    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(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) {
        // 需要一个辅助变量temp，因为head节点不能动
        HeroNode temp = 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;
    }

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

/*
	2. 第二种方法：添加节点时，按照顺序添加到链表指定位置
*/
public class Demo01SingleLinkedList {
    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,"","");

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

    // 第二种方法添加节点，按照顺序将节点添加到指定位置
    public void addByOrder(HeroNode heroNode) {
        // 头节点不能动，需要一个辅助变量temp，帮助找到添加的位置
        // 因为是单链表，因为找的temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;   // flag标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {
                break;  // 已经在链表的最后
            }
            if (temp.next.no > heroNode.no) {
                // 位置找到，就在temp和temp.next之间插入
                break;
            } else if (temp.next.no == heroNode.no) {
                // 说明希望添加的heroNode的编号已经存在
                flag = true;
                break;
            }
            // temp后移
            temp = temp.next;
        }
        // 判断flag值
        if (flag) {
            // 说明编号存在，不能添加
            System.out.printf("准别插入的英雄编号 %d 已经存在，不能加入\n", heroNode.no);
        } else {
            // 插入到链表中
            heroNode.next = temp.next;  // 将原先temp.next的值赋值给heroNode.next
            temp.next = heroNode;       // 再将heroNode赋值给temp.next
        }
    }

    // 显示链表[遍历]
    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;
    }

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

来源：CSDN

作者：zhao Jack

链接：https://blog.csdn.net/zhao416129/article/details/104778717