数据结构和算法——基于Java——3.3 双向链表

理论补充

代码实现

以下代码实现功能

函数名	作用
add(HeroNode2 node)	添加
addByOrder(HeroNode2 heroNode)	按照编号顺序添加
list()	遍历输出节点
update(HeroNode2 newHeroNode)	更新节点元素
delete(int no)	根据编号删除节点

package com.b0.a1_3linkedList;

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(4, "林冲", "豹子头");
        //创建一个双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero3);
//        doubleLinkedList.add(hero4);
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.list();
        //修改测试
        HeroNode2 newHeroNode = new HeroNode2(4, "公孙胜", "入云龙");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表");
        doubleLinkedList.list();
        //删除
        System.out.println("删除后的结果");
        doubleLinkedList.delete(4);
        doubleLinkedList.list();
    }
}
class DoubleLinkedList{
    //初始化头节点，头节点不存放任何数据，不能动
    HeroNode2 head = new HeroNode2(0,"","");
    //返回头节点
    public HeroNode2 getHead() {
        return head;
    }
    //思路1.head不能变动，找到我们要删除的节点，自我删除就行
    public void delete(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){//找到待删除节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next;//后移，加上循环实现遍历
        }
        //判断flag
        if (flag){
            temp.pre.next = temp.next;
            //处理删除最后一个元素时情形
            if (temp.next == null){
                temp.pre = null;
            }else {
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.println("要删除的节点："+no+"不存在") ;
        }
    }
    //修改一个节点的内容
    //修改节点信息，根据no编号修改，no编号不能修改。
    //1.根据newHeroNode的no来修改
    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;
        }
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else {//没有找到
            System.out.println("没有找到编号："+newHeroNode.no+"的节点，不能修改！");
        }
    }
    //第二种方式再添加英雄时，根据排名将英雄插入到指定位置
    //如果有这个排名，添加失败，并给出提示
    public void addByOrder(HeroNode2 heroNode){
        //头节点不能动，因此需要使用一个辅助变量temp来找到添加位置
        //单链表，需要找到的temp是位于添加位置的前一个节点，否则插入不了
        HeroNode2  temp = head;
        boolean flag = false;//标识插入的编号是否存在，默认false
        while (true){
            if (temp.next == null){
                break;
            } else if (temp.next.no >heroNode.no) {//找到位置
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            } else {
                temp = temp.next;//后移，遍历当前链表
            }
        }
        //判断flag的值
        if (flag){
            System.out.println("准备插入的数据，编号:"+heroNode.no+"已经存在不能添加!");
        }else {
            //插入到链表中，temp的后面
            if (temp.next == null){
                heroNode.next = temp.next;
                temp.next = heroNode;
                heroNode.pre = temp;
            }else {
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
                temp.next = heroNode;
                heroNode.pre = temp;
            }
        }
    }
    //添加节点
    public void add(HeroNode2 node){
        //因为头节点不能移动，所以需要一个辅助变量temp
        HeroNode2 temp = head;
        while (true){
            //找到链表最后
            if (temp.next == null){
                break;
            }
            temp = temp.next;
        }
        //最后一个节点指向node,node的pre指向最后一个节点
        temp.next = node;
        node.pre = temp;
    }
    //遍历【双向链表】
    public void list(){
        if (head.next == null){
            System.out.println("链表为空！");
            return;
        }
        //因为头节点不能移动，所以需要一个辅助变量temp
        HeroNode2 temp = head.next;
        while (true){
            //判断链表是否到最后
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //输出结束必须要节点后移，不然会死循环
            temp = temp.next;
        }
    }
}
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;//指向下一个节点
    public HeroNode2 pre;//指向上一个节点
    //构造器
    public HeroNode2(int no,String name,String nickname){
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

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