双向链表的实现

最新推荐文章于 2024-04-14 23:29:03 发布
最新推荐文章于 2024-04-14 23:29:03 发布
阅读量501 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52463861/article/details/126308070
版权

前置知识：
为了解决单链表只能单方向进行，既要存储下一个节点地址，还要存储前一个节点地址。
在这里插入图片描述
1.头插
在这里插入图片描述

public void addFirst(int val){
        //引入一个局部变量，暂存头节点的地址
        DoubleNode f = first;
        DoubleNode node = new DoubleNode(val);
        //判断链表是否为空
        first = node;
        if (f == null){
            last = node;
        }else{
            node.next = f;
            f.prev = node;
        }
        size ++;
    }

2.尾插
在这里插入图片描述

public void addLast(int val){
        DoubleNode l = last;
        DoubleNode node = new DoubleNode(val);
        //判断链表是否为空
        last = node;
        if (l == null){
            first = node;
        }else{
            l.next = node;
            node.prev = l;
        }
    }

3.index位置插入
在这里插入图片描述

/**
     * 根据index与size的大小关系快定位指定index位置的节点(addIndex、get、set方法都需要用)
     * @param index
     * @return
     */
    private DoubleNode node(int index) {
        //根据index与size的大小关系来判断到底
        // 从头向后走还是从后向头走
        if (index < size / 2){
            //此时从头向后走
            DoubleNode node = first;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return node;
        }else{
            //此时index > size/2
            //此时从后向头走
            DoubleNode node = last;
            for (int i = size - 1 ; i > index; i--) {
                node = node.prev;
            }
            return node;
        }
    }

/**
     * 在index位置插入元素
     * @param index
     * @param val
     */
    public void addIndex(int index,int val){
        //判断index的合法性
        if(index < 0 || index > size){
            System.err.println("add index illegal!");
        }
        else if(index == 0){
            //头插
            addFirst(val);
        }
        else if(index == size){
            //尾插
            addLast(val);
        }else{
            //此时 0<index<size
            DoubleNode node = node(index);
           //指向当前位置的前驱节点
           DoubleNode prev = node.prev;
           DoubleNode newNode = new DoubleNode(val);
           //先处理后半部分
            newNode.next = node;
            node.prev = newNode;
            //在处理前半部分
            prev.next = newNode;
            newNode.prev = prev;
            size ++;
        }
    }

4.get与set方法

//判断Index是否合法
private boolean rangeCheck(int index){
        if (index < 0 || index >= size){
            return false;
        }
        return true;
    }

 /**
     * 根据index索引取得节点值
     * @param index
     * @return
     */
    public int get(int index){
        if (rangeCheck(index)){
            DoubleNode node = node(index);
            return node.val;
        }else{
            System.err.println("get index illegal!");
            return -1;
        }
    }


/**
     * 修改index位置的值
     * @param index
     * @param newVal
     */
    public void set(int index,int newVal){
        if (rangeCheck(index)){
            DoubleNode node = node(index);
            node.val = newVal;
        }else{
            System.err.println("set index illegal!");
        }
    }

5.传入一个双向链表节点，将该结点从双向链表中删除
（1）删除前半部分
在这里插入图片描述
（2）删除后半部分
在这里插入图片描述

/**
     * 传入一个双向链表节点，将该结点从双向链表中删除
     * （分治思想，先处理前驱或后继，再处理另一半的情况）
     * @param node
     */
    private void UnlinkedNode(DoubleNode node){
        //待删除结点前驱
        DoubleNode prev = node.prev;
        //待删除结点后继
        DoubleNode next = node.next;
        //判断边界
        if (prev == null){
            first = next;
        }else{
            //此时前驱节点不为空
            prev.next = next;
            node.prev = null;
        }
        if (next == null){
            last = prev;
        }else{
            //此时后继节点不为空
            next.prev = prev;
            node.next = null;
        }
        size --;
    }

6.删除第一次出现的节点值

public void removeValueOnce(int val){
        for (DoubleNode x = first;x != null;x = x.next) {
            if(x.val == val){
                UnlinkedNode(x);
                return;
            }
        }
    }

7.删除所有的节点值

public void removeAllValue(int val){
        for(DoubleNode x = first;x != null;){
            if(x.val == val){
                DoubleNode next = x.next;
                UnlinkedNode(x);
                x = next;
            }else{
                x = x.next;
            }
        }
    }

最终代码实现如下：

package seqlist;

class DoubleNode{
    //指向前驱节点
    DoubleNode prev;
    //存储具体元素
    int val;
    //指向后继节点
    static DoubleNode next;

    public DoubleNode(int val) {
        this.val = val;
    }
}

/**
 * 基于int的双向链表
 */
public class DoubleLinkedList {
    //具体车厢的个数
    private int size;
    //头节点
    private DoubleNode first;
    //尾节点
    private DoubleNode last;

    /**
     * 头插
     * @param val
     */
    public void addFirst(int val){
        //引入一个局部变量，暂存头节点的地址
        DoubleNode f = first;
        DoubleNode node = new DoubleNode(val);
        //判断链表是否为空
        first = node;
        if (f == null){
            last = node;
        }else{
            node.next = f;
            f.prev = node;
        }
        size ++;
    }

    /**
     * 尾节点插入
     * @param val
     */
    public void addLast(int val){
        DoubleNode l = last;
        DoubleNode node = new DoubleNode(val);
        //判断链表是否为空
        last = node;
        if (l == null){
            first = node;
        }else{
            l.next = node;
            node.prev = l;
        }
    }

    /**
     * 在index位置插入元素
     * @param index
     * @param val
     */
    public void addIndex(int index,int val){
        //判断index的合法性
        if(index < 0 || index > size){
            System.err.println("add index illegal!");
        }
        else if(index == 0){
            //头插
            addFirst(val);
        }
        else if(index == size){
            //尾插
            addLast(val);
        }else{
            //此时 0<index<size
            DoubleNode node = node(index);
           //指向当前位置的前驱节点
           DoubleNode prev = node.prev;
           DoubleNode newNode = new DoubleNode(val);
           //先处理后半部分
            newNode.next = node;
            node.prev = newNode;
            //在处理前半部分
            prev.next = newNode;
            newNode.prev = prev;
            size ++;
        }
    }

    /**
     * 根据index索引取得节点值
     * @param index
     * @return
     */
    public int get(int index){
        if (rangeCheck(index)){
            DoubleNode node = node(index);
            return node.val;
        }else{
            System.err.println("get index illegal!");
            return -1;
        }
    }

    /**
     * 修改index位置的值
     * @param index
     * @param newVal
     */
    public void set(int index,int newVal){
        if (rangeCheck(index)){
            DoubleNode node = node(index);
            node.val = newVal;
        }else{
            System.err.println("set index illegal!");
        }
    }

    public void removeValueOnce(int val){
        for (DoubleNode x = first;x != null;x = x.next) {
            if(x.val == val){
                UnlinkedNode(x);
                return;
            }
        }
    }

    public void removeAllValue(int val){
        for(DoubleNode x = first;x != null;){
            if(x.val == val){
                DoubleNode next = x.next;
                UnlinkedNode(x);
                x = next;
            }else{
                x = x.next;
            }
        }
    }

    /**
     * 传入一个双向链表节点，将该结点从双向链表中删除
     * （分治思想，先处理前驱或后继，再处理另一半的情况）
     * @param node
     */
    private void UnlinkedNode(DoubleNode node){
        //待删除结点前驱
        DoubleNode prev = node.prev;
        //待删除结点后继
        DoubleNode next = node.next;
        //判断边界
        if (prev == null){
            first = next;
        }else{
            //此时前驱节点不为空
            prev.next = next;
            node.prev = null;
        }
        if (next == null){
            last = prev;
        }else{
            //此时后继节点不为空
            next.prev = prev;
            node.next = null;
        }
        size --;
    }

    private boolean rangeCheck(int index){
        if (index < 0 || index >= size){
            return false;
        }
        return true;
    }

    /**
     * 根据index与size的大小关系快定位指定index位置的节点(addIndex、get、set方法都需要用)
     * @param index
     * @return
     */
    private DoubleNode node(int index) {
        //根据index与size的大小关系来判断到底
        // 从头向后走还是从后向头走
        if (index < size / 2){
            //此时从头向后走
            DoubleNode node = first;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return node;
        }else{
            //此时index > size/2
            //此时从后向头走
            DoubleNode node = last;
            for (int i = size - 1 ; i > index; i--) {
                node = node.prev;
            }
            return node;
        }
    }

    @Override
    public String toString() {
        String ret = "";
        DoubleNode node = first;
        while (node != null){
            ret += node.val + "->";
            node = node.next;
        }
        ret += "NULL";
        return ret;
    }

    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addLast(1);
        doubleLinkedList.addLast(2);
        doubleLinkedList.addLast(3);
        System.out.println(doubleLinkedList);
        //System.out.println(doubleLinkedList.get(1));
        doubleLinkedList.set(1,22);
        System.out.println(doubleLinkedList);
    }

}
努力加油鸭！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3146
简述双向链表概念、C语言实现双向链表
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
【数据结构】双向链表实现
m0_73367097的博客
03-26 1652
双向链表的定义与实现
数据结构之双向链表的实现
qq_62905847的博客
10-02 617
java自主实现双向链表
【数据结构】双链表实现
qq_55829345的博客
01-23 1772
实现双链表以及双链表的应用，单链表和双链表的对比。
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
双向链表实现
05-12
双向链表实现C源码
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
【数据结构】双向链表的实现
adcxhw的博客
04-07 1248
又是一篇万字文章，建议收藏。
【数据结构与算法】 - 双向链表 - 详细实现思路及代码
wkd_007的博客
04-12 6490
介绍双向链表，以及双向链表的详细实现步骤，最后提供了C语言实现双向链表的代码
【数据结构初阶】第四篇——双链表（实现+图解）
weixin_58450087的博客
10-29 1897
这篇博客，我要给大家分享双链表的知识，上一篇博客，我给大家分享了有关单链表的知识，单链表相比双链表而言结构比较简单，但事实上，双链表的实现比单链表要方便很多，下面我就来给大家聊一聊双链表的那些事儿~ 博客代码已上传至gitee：https://gitee.com/byte-binxin/data-structure/tree/master/List_2.0 目录带头双向链表的结构带头双向链表的接口实现初始化双链表打印双链表双链表的销毁双链表的尾插双链表的尾删双链表的头插双链表的头删双链表任意位置查找双链.
双向链表的实现（详解）
最新发布
的博客
04-14 522
链表的分类： 带头 不带头 单向 双向 循环 不循环一共有 (2 * 2 * 2) 种链表带头指的是：带有哨兵位节点哨兵位（头结点）：可以放随机数据，哨兵位指向的下一个节点就是我们的第一个有效节点，我们指的头节点是哨兵位单向：指针只能从前向后遍历双向：指针既可以从前向后遍历又可以从后向前遍历循环：可以通过尾节点找到头节点，从而达到循环主要使用的链表是单链表和双向链表单链表:不带头单向不循环双向链表：带头双向循环。
双向链表原来是这样实现的！
2203_75397752的博客
12-18 1416
我会定期分享我的学习经验，也欢迎大家留言和交流，让我们共同学习和进步！双链表是一种由节点组成的数据结构，每个节点都包含一个数据域和两个指针域，分别指向前一个节点和后一个节点。这种结构为双链表带来了高度的灵活性，使其适用于各种复杂的编程场景。(ListNode)注意下述代码皆是：在SList.h头文件中定义函数在SList.c文件中实现函数在Test.c文件中函数测试}ListNode;SList.c文件中// 双向链表尾插// 将新节点插入到尾节点之后。
双向链表的功能实现
Lee贤的博客
05-12 745
本文主要介绍了双向链表的原理及功能的实现
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 7759
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
双链表的实现
m0_71403998的博客
10-20 79
哈喽大家好呀！下面是我对双链表的实现笔记~和我一起来看一下吧！要想这类链表更好的实现还需要使用画图功能，才不会乱套。
数据结构—双向链表（详解）
梅山
03-20 6148
双向链表 在之前一篇文章中介绍了单向链表的实现，可以看出单向链表实现过程中，只能够逐次向下继续查找，指针一直指向下一个节点，而本文中的双向链表，在结构体定义的时候多了一个指向上一节点的指针，因此，无论是在插入还是删除来说，从后往前和从前往后遍历都极大的提高了便利性。下面来介绍双向链表的具体实现。 双向非循环链表的实现 1、链表结构体封装 /* 双向链表的结构 */ typedef struct llist_st { int data; struct llist_st * prev;
双向链表实现多级菜单
09-22
以下是一个使用双向链表实现多级菜单的示例代码： ```python class MenuItem: def __init__(self, label): self.label = label self.child = None self.parent = None self.next_sibling = None def create_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值