好玩的数据结构与算法——双链表

最新推荐文章于 2024-11-01 10:00:37 发布

b u g

最新推荐文章于 2024-11-01 10:00:37 发布

阅读量161

点赞数

分类专栏：数据结构与算法文章标签：算法数据结构链表 java

本文链接：https://blog.csdn.net/qq_40705355/article/details/106609289

版权

数据结构与算法专栏收录该内容

18 篇文章 0 订阅

订阅专栏

双链表在单链表的基础上多了一个指向前一个节点的指针，通过next和pre可以双向遍历。
节点数据：

public class HeroNodeDouble {

    private int no;
    private String name;
    private String nckName;
    private HeroNodeDouble next;//下一个节点
    private HeroNodeDouble pre;//上一个节点
	// 省略了get和set  以及构造方法
}

双链表的添加

1.按照顺序直接添加到链表尾部
思路：

遍历链表找到最后一个节点
将最后一个节点的next指向添加的节点
将添加的节点的pre指向链表的最后一个节点

public void add(HeroNodeDouble  heroNodeDouble){
    // 辅助遍历变量
    HeroNodeDouble temp = head;
    // 遍历链表，找到最后
    while (true){
        //找到链表最后,并添加
        if (temp.getNext() == null){
            temp.setNext(heroNodeDouble);
            heroNodeDouble.setPre(temp);
            break;
        }
        // 如果没有找到最后，将temp后移
        temp = temp.getNext();
    }
}

2.添加到链表是按照顺序插入
思路：

遍历找到要插入链表的位置
如果要插入的位置是最后，这按照上面直接插入尾部的方式插入
如果要插入的位置是在两个节点之间，找到要插入的节点位置之后，按照如下方式插入

1.新节点指向要添加的位置的节点
2.要添加位置的上一个节点的next指向要添加的新节点
3.将要添加的节点的上一个pre设置为添加的位置节点的上一个位置
4.将要添加位置的节点的pre设置为新添加的节点

图解在两个节点直接插入新节点：
在这里插入图片描述

/**
  * @Description: addOrder  按照编号顺序添加
  */
 public void addOrder(HeroNodeDouble heroNodeDouble){
     HeroNodeDouble temp = head;
     // 标识英雄是否找到
     boolean flag = false;
     while (true){
         // 到了链表最后
         if (temp.getNext() == null){
             break;
         }
         //找到要插入位置的前一个位置
         if (temp.getNext().getNo() > heroNodeDouble.getNo()){
             break;
         }else if (temp.getNext().getNo() == heroNodeDouble.getNo()){
             // 说明需要添加的heroNode的标号已经存在
             flag = true;
             break;
         }
         // 如果没有找到最后，将temp后移
         temp = temp.getNext();
     }
     if (flag){// 不能添加，编号已存在
         System.out.printf("准备插入的英雄编号%d已经存在，不能加入",temp.getNext().getNo());
     }else {// 添加
         // 如果是插入到中间
         if (temp.getNext() != null){
             temp = temp.getNext();
             // 1.新节点指向要添加的位置的节点
             heroNodeDouble.setNext(temp);
             // 2.要添加位置的上一个节点的next指向要添加的新节点
             temp.getPre().setNext(heroNodeDouble);
             // 3.将要添加的节点的上一个pre设置为添加的位置节点的上一个位置
             heroNodeDouble.setPre(temp.getPre());
             // 4.将要添加位置的节点的pre设置为新添加的节点
             temp.setPre(heroNodeDouble);
         }else {// 插入到尾部
             // 1.将当前节点的next指向要添加的节点
             temp.setNext(heroNodeDouble);
             // 2.新节点的pre指向当前节点
             heroNodeDouble.setPre(temp);
         }
     }
 }

双链表的删除

思路：

遍历找到要删除的节点
将要删除的节点的上一个节点的next指向要和删除节点的下一个节点
将要删除节点的下一个节点的pre指向要删除节点的上一个节点

图解过程（删除节点2）：
在这里插入图片描述

如果要删除的节点是最后一个节点，那个最后一个节点的上一个节点next指向要删除节点的next

代码实现：

/**
 * @Description: deleteNode 删除节点
 */
public void deleteNode(HeroNodeDouble heroNodeDouble){
    HeroNodeDouble temp = head;
    // 表示是否找到节点信息
    boolean flag = false;
    while (true){
        if (temp.getNext() == null){
            break;
        }
        if (temp.getNo() == heroNodeDouble.getNo()){
            flag = true;
            break;
        }
        // 如果没有找到最后，将temp后移
        temp = temp.getNext();
    }
    if (flag){
        // 1. 将要删除节点的上一个节点的next指向要删除节点的下一个节点
        temp.getPre().setNext(temp.getNext());  
        // 2.将要删除的下一个节点的pre指向要删除的节点的上一个节点
        if (temp.getNext() != null){
            temp.getNext().setPre(temp.getPre());
        }
    }else {
        System.out.println("未找到该节点信息");
    }
}

双链表的更新与查询和单链表一致

附完整代码：
节点信息：

public class HeroNodeDouble {

    private int no;
    private String name;
    private String nckName;
    private HeroNodeDouble next;//下一个节点
    private HeroNodeDouble pre;//上一个节点

    public int getNo() {
        return no;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNckName() {
        return nckName;
    }

    public void setNckName(String nckName) {
        this.nckName = nckName;
    }

    public HeroNodeDouble getNext() {
        return next;
    }

    public void setNext(HeroNodeDouble next) {
        this.next = next;
    }

    public HeroNodeDouble getPre() {
        return pre;
    }

    public void setPre(HeroNodeDouble pre) {
        this.pre = pre;
    }

    public HeroNodeDouble(int no, String name, String nckName) {
        this.no = no;
        this.name = name;
        this.nckName = nckName;
    }

    public HeroNodeDouble() {
    }

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

操作单链表：

public class DoubleLinkList {

    private HeroNodeDouble head = new HeroNodeDouble(0,"","");


    public HeroNodeDouble getHead() {
        return head;
    }

    /**
     * @Description: 添加节点
     * 思路：
     * 1.先找到当前链表的最后节点
     * 2.将最后这个节点的next域指向新的节点
     */
    public void add(HeroNodeDouble  heroNodeDouble){
        // 辅助遍历变量
        HeroNodeDouble temp = head;
        // 遍历链表，找到最后
        while (true){
            //找到链表最后,并添加
            if (temp.getNext() == null){
                temp.setNext(heroNodeDouble);
                heroNodeDouble.setPre(temp);
                break;
            }
            // 如果没有找到最后，将temp后移
            temp = temp.getNext();
        }
    }

    /**
     * @Description: addOrder  按照编号顺序添加
     */
    public void addOrder(HeroNodeDouble heroNodeDouble){
        HeroNodeDouble temp = head;
        // 标识英雄是否找到
        boolean flag = false;
        while (true){
            // 到了链表最后
            if (temp.getNext() == null){
                break;
            }
            //找到要插入位置的前一个位置
            if (temp.getNext().getNo() > heroNodeDouble.getNo()){
                break;
            }else if (temp.getNext().getNo() == heroNodeDouble.getNo()){
                // 说明需要添加的heroNode的标号已经存在
                flag = true;
                break;
            }
            // 如果没有找到最后，将temp后移
            temp = temp.getNext();
        }
        if (flag){// 不能添加，编号已存在
            System.out.printf("准备插入的英雄编号%d已经存在，不能加入",temp.getNext().getNo());
        }else {// 添加
            // 如果是插入到中间
            if (temp.getNext() != null){
                temp = temp.getNext();
                // 1.新节点指向要添加的位置的节点
                heroNodeDouble.setNext(temp);
                // 2.要添加位置的上一个节点的next指向要添加的新节点
                temp.getPre().setNext(heroNodeDouble);
                // 3.将要添加的节点的上一个pre设置为添加的位置节点的上一个位置
                heroNodeDouble.setPre(temp.getPre());
                // 4.将要添加位置的节点的pre设置为新添加的节点
                temp.setPre(heroNodeDouble);
            }else {// 插入到尾部
                // 1.将当前节点的next指向要添加的节点
                temp.setNext(heroNodeDouble);
                // 2.新节点的pre指向当前节点
                heroNodeDouble.setPre(temp);
            }
        }
    }

    /**
     * @Description: update 根据no更新信息
     */
    public void update(HeroNodeDouble heroNodeDouble){
        HeroNodeDouble temp = head;
        if (temp.getNext() == null){
            System.out.println("链表为空~~~~~~~");
            return;
        }
        // 标识是否找到该节点
        boolean flag = false;
        while (true){
            if (temp.getNext() == null){
                break;
            }
            if (temp.getNext().getNo() == heroNodeDouble.getNo()){// 找到要修改的节点的前一个位置
                flag = true;
                break;
            }
            // 如果没有找到最后，将temp后移
            temp = temp.getNext();
        }
        if (flag){
            // 更新信息
            HeroNodeDouble next = temp.getNext();
            next.setName(heroNodeDouble.getName());
            next.setNckName(heroNodeDouble.getNckName());
        }else {
            System.out.printf("没有找到编号%d的节点，不能修改\n",heroNodeDouble.getNo());
        }
    }

    /**
     * @Description: deleteNode 删除节点
     */
    public void deleteNode(HeroNodeDouble heroNodeDouble){
        HeroNodeDouble temp = head;
        // 表示是否找到节点信息
        boolean flag = false;
        while (true){
            if (temp.getNext() == null){
                break;
            }
            if (temp.getNo() == heroNodeDouble.getNo()){
                flag = true;
                break;
            }
            // 如果没有找到最后，将temp后移
            temp = temp.getNext();
        }
        if (flag){
            // 1. 将要删除节点的上一个节点的next指向要删除节点的下一个节点
            temp.getPre().setNext(temp.getNext());
            // 2.将要删除的下一个节点的pre指向要删除的节点的上一个节点
            if (temp.getNext() != null){
                temp.getNext().setPre(temp.getPre());
            }
        }else {
            System.out.println("未找到该节点信息");
        }
    }


    /**
     * @Description: 显示链表
     */
    public void show(){
        if(head.getNext() == null){
            System.out.println("链表为空");
            return;
        }
        HeroNodeDouble temp = head.getNext();
        while (true){
            if (temp == null){
                break;
            }
            // 输出节点信息
            System.out.println(temp);
            // 将temp后后移
            temp = temp.getNext();
        }
    }

    /**
     * @Description: getLinkListLength 查询单链表的长度
     */
    public static int getLinkListLength(HeroNodeDouble heroNodeDouble){
        int length = 0;
        if (heroNodeDouble.getNext() == null){//单链表为空
            return length;
        }
        HeroNodeDouble cur = heroNodeDouble.getNext();
        while (cur != null){
            length ++;
            cur = cur.getNext();
        }
        return length;
    }


}

测试验证：

public class TestDoubleLinkList {

    public static void main(String[] args) {
        DoubleLinkList doubleLinkList = new DoubleLinkList();
        HeroNodeDouble heroNodeDouble1 = new HeroNodeDouble(1, "宋江", "及时雨");
        HeroNodeDouble heroNodeDouble2 = new HeroNodeDouble(4, "卢俊义", "玉麒麟");
        HeroNodeDouble heroNodeDouble3 = new HeroNodeDouble(3, "无用", "智多星");
        HeroNodeDouble heroNodeDouble4 = new HeroNodeDouble(6, "林冲", "豹子头");
//        doubleLinkList.add(heroNodeDouble1);
//        doubleLinkList.add(heroNodeDouble2);
//        doubleLinkList.add(heroNodeDouble3);
//        doubleLinkList.add(heroNodeDouble4);
//        System.out.println("按照顺序添加到尾部");
//        doubleLinkList.show();

        doubleLinkList.addOrder(heroNodeDouble1);
        doubleLinkList.addOrder(heroNodeDouble2);
        doubleLinkList.addOrder(heroNodeDouble3);
        doubleLinkList.addOrder(heroNodeDouble4);
        System.out.println("按照顺序添加，自动排序");
        doubleLinkList.show();

        System.out.println("更新节点");
        heroNodeDouble2.setName("没用");
        doubleLinkList.update(heroNodeDouble2);
        doubleLinkList.show();

        System.out.println("删除节点");
        doubleLinkList.deleteNode(heroNodeDouble2);
        doubleLinkList.show();


    }

}