数据结构与算法——单链表（2）

数据结构与算法——单链表（2）

在数据结构与算法——单链表（1）的基础上对于添加节点的算法的优化，不是仅仅添加于链表末尾，而是按照编号顺序添加。同时，增加了删除，更新的算法功能。

思路分析

1.添加算法：根据编号顺序将节点插入到指定位置（如果已经存在，则添加失败）

1. 首先找到新添加的节点的位置, 是通过辅助变量(指针), 通过遍历来搞定
2. 新的节点.next = temp.next
3. 将temp.next = 新的节点

2.更新节点算法：

• 首先，通过遍历，找到该节点
• 找到后，令temp.name = newNode.name;temp.nickname = newNode.nickname等其他所需要更新的节点信息。

3.删除节点算法：

• 我们先找到需要删除的这个节点的前一个节点 temp
• temp.next = temp.next.next
• 被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收

代码展示

1.创建节点对象见数据结构与算法——单链表（1）
2.创建链表并更新增删改查算法

• 添加节点：addHero()\addByOrder()
• 更新节点：update()
• 删除节点：deleteNode()
• 节点信息输出：show()

class SingleLinkedList {
    HeroNode head = new HeroNode(0, " ", " ");// 创建头节点，不需要具体的信息

    // 头节点数据不可更改，创建临时指针变量充当头节点实现指针后移的操作
    HeroNode temp = head;

    // 1.找到当前链表的最后节点
    // 2.将最后这个节点的next指向新的节点
    public void addHero(HeroNode heroNode) {
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        // 当while循环终止的时候，此时temp已经找到链表的最后一个节点
        // 将新的节点赋给temp，即在链表末尾添加节点
        temp.next = heroNode;
    }

    // 按照no顺序插入节点
    public void addByOrder(HeroNode newHeroNode) {

        HeroNode temp = head;
        boolean isFlag = false;// 用于寻找比目标节点位置大的节点位置，方便插入
        while (true) {
            if (temp.next == null) {// 此时说明已经遍历完毕
                break;
            }
            if (temp.next.no > newHeroNode.no) {
                break;
            } else if (temp.next.no == newHeroNode.no) {// 说明已经存在该编号的节点
                isFlag = true;
                break;
            }
            temp = temp.next;

        }

        if (!isFlag) {
            newHeroNode.next = temp.next;
            temp.next = newHeroNode;
        } else {
            System.out.println("节点存在，无法插入~~");
        }
    }

    // 按照no来更新节点信息
    public void update(HeroNode newHeroNode) {

        // 判断列表是否为空
        if (head.next == null) {
            System.out.println("列表为空");
        }

        HeroNode temp = head;
        boolean isFlag = false;// 用来判断是否找到节点位置
        while (true) {
            if (temp.next == null) {// 此时说明遍历完成，temp为最后一个节点所在的位置
                break;
            } else if (temp.next.no == newHeroNode.no) {
                isFlag = true;// 找到了所需要更新节点的节点位置
                break;
            }

            temp = temp.next;
        }

        if (isFlag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.println("不存在该节点~~");
        }
    }

    public void deleteNode(int n) {
        // 判断当前链表是否为空
        if (head.next == null) {
            System.out.println("当前链表为空~~");
        }

        HeroNode temp = head;// 临时指针，用于遍历节点，定位要删除的节点位置
        boolean isFlag = false;// 用于判断是否找到节点位置

        while (true) {
            if (temp.next == null) {
                break;// 遍历完成，没有找到节点
            }

            if (temp.next.no == n) {
                isFlag = true;// 找到节点位置
                break;
            }

            temp = temp.next;
        }

        if (isFlag) {
            // 找到节点，需要把当前指针的next域指向下下一个节点位置
            // 因为while判断里指针的next域是需要删除的指针
            temp.next = temp.next.next;
        } else {
            System.out.println("不存在该节点信息~~");
        }
    }

    // 遍历链表
    public void show() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("当前链表为空~~");

        }
        HeroNode temp = head;
        temp = temp.next;// 如果不先将temp指针后移，输出节点信息时，头节点的信息也会输出
        while (true) {
            if (temp == null) {
                break;
            }
            // 输出当前temp指针所指向的节点信息
            System.out.println(temp);
            // 指针后移，输出下一个节点信息
            temp = temp.next;
        }
    }
}

3.主函数部分，调用测试写的方法

public class SingleLinkedListTest {
    public static void main(String[] args) {
        // 1.创建节点对象
        HeroNode hero1 = new HeroNode(1, "wjj", "jjw");
        HeroNode hero2 = new HeroNode(2, "wzt", "tzw");
        HeroNode hero3 = new HeroNode(3, "jjw", "wjj");
        HeroNode hero4 = new HeroNode(4, "jwj", "jwj");

        // 2.创建单链表对象，并将节点加入到链表中
        SingleLinkedList sll = new SingleLinkedList();
        // sll.addHero(hero1);
        // sll.addHero(hero2);
        // sll.addHero(hero3);
        // sll.addHero(hero4);

        // 添加节点

        sll.addByOrder(hero1);
        sll.addByOrder(hero3);
        sll.addByOrder(hero4);
        sll.addByOrder(hero2);

        System.out.println("更新节点前：");
        sll.show();
        // 更新节点
        sll.update(new HeroNode(3, "mjj", "jjm"));
        System.out.println("更新节点后：");
        sll.show();

        // 删除节点
        sll.deleteNode(2);
        // 删除节点后遍历显示
        System.out.println("删除某个节点后：");
        sll.show();

    }
}

运行结果

结尾

至此，单链表的增删改查功能基本完成，准备进入双向链表的内容的学习。