[双向链表]实现一个双向链表

已于 2022-05-10 19:54:58 修改
阅读量146 收藏
点赞数
分类专栏： java数据结构 文章标签： 链表 数据结构 java
于 2022-05-10 19:30:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54426859/article/details/124693366
版权

文章目录

学习内容

使用java实现一个双向链表的增删改查

完整代码：

//双向链表的节点，需要记录next和prev
class Node{
    int val;
    Node next;
    Node prev;

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

}
//实现一个双向链表
public class MyLinkedList {
    //记录头节点的位置
    private Node head;
    //记录尾节点的位置
    private Node tail;
    //链表的元素个数
    private int length;

    public MyLinkedList(){
        //此处没有使用傀儡节点
        head = null;
        tail = null;
    }

    public int length(){
        return this.length;
    }

//插入节点
    //头插
    public void addFirst(int val){
        Node newNode = new Node(val);
        if(head == null) {
            head = newNode;
            tail = newNode;
            length++;
            return;
        }
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
            length++;
            return;
    }
    //尾插
    public void addTail(int  val){
        Node newNode = new Node(val);
        tail = head;
        if(head == null){
            head = newNode;
            tail = newNode;
            length++;
            return;
        }
        while (tail.next != null){
            tail = tail.next;
        }
        tail.next = newNode;
        newNode.prev = tail;
        tail =  newNode;
        length++;

    }
    //指定位置插入
    public void add(int index,int val){
        if(index < 0 || index > length){//如果index = length，就相当于尾插
            return;
        }
        if(index ==  0 ){//头插
            addFirst(val);
            return;
        }
        if(index == length){//尾插
            addTail(val);
            return;
        }
        Node newNode = new Node(val);
        Node nextNode = getNode(index);
        Node prevNode = newNode.prev;
        /**
         * 接下来要往cur之前插入newNode，因为要让newNode的下标变为val;
         * 如果是cur之后，那就变成了val＋1
         */
        prevNode.next = newNode;
        newNode.prev = prevNode;

        newNode.next = nextNode;
        nextNode.prev = newNode;
        length++;
    }


//删除
    public void removeByIndex(int index) {
        if(index < 0 || index >= length || head == null){
            return;
        }
        //头删
        if(head.next == null){
            head = null;
            tail = null;
            length = 0;
            return;
        }
        if(index == 0){
            Node newNode = head;
            newNode = newNode.next;
            newNode.prev = null;
            head = newNode;
            return;
        }
        //尾删
        if(index == length - 1){
            Node newNode = head;
            while (newNode.next != null){
                newNode = newNode.next;
            }
            newNode.prev.next = null;
            tail = newNode.prev;
            length--;
            return;
        }
        Node newNode = getNode(index);

        newNode.prev.next = newNode.next;
        newNode.next.prev = newNode.prev;
        length--;
    }
    public void removeByValue(int val){

        int index = indexof(val);
        if(index == -1){
            return;
        }
        removeByIndex(index);
    }

//查找
    public int get(int index){
        return getNode(index).val;
    }

    public int indexof(int val){
        if(head == null){
            return -1;
        }
        Node cur = head;
        for(int i = 0;i < length;i++){
            if(cur.val == val){
                return i;
            }
            cur = cur.next;
        }
        return -1;
    }

//根据取下标得到节点
    public Node getNode(int index){
        if(index < 0 || index >= length || head == null){
            return null;
        }
        Node cur = head;
        for(int i = 0;i < index;i++){
            cur = cur.next;
        }
        return cur;
    }

//修改
    public void set(int index,int val){
        Node cur = getNode(index);
        cur.val = val;

    }
    //给定值查找下标
    public int getIndex(int val){
        if(head == null){
            return -1;
        }
        for(int i = 0; i < length;i++){
            if(head.val == val){
                return i;
            }
            head = head.next;
        }
        return -1;
    }
}

代码分解：

  • 建立一个Node类,因为是双向链表，所以需要一个next，一个prev
//双向链表的节点，需要记录next和prev
class Node{
    int val;
    Node next;
    Node prev;

    public Node(int val){
        this.val = val;
    }
}
  • 设置参数
    //记录头节点的位置
   private Node head;
   //记录尾节点的位置
   private Node tail;
   //链表的元素个数
   private int length;

   public MyLinkedList(){
       //此处没有使用傀儡节点
       head = null;
       tail = null;
   }

   public int length(){
       return this.length;
   }
  • 增 —— 头插插入节点在这里插入图片描述
    原理如上图，其他插入也是同理，因为是双向链表，所以next和prev指向什么都要写清楚，最后对相应的变量进行更新。
public void addFirst(int val){
       Node newNode = new Node(val);chu
       if(head == null) {
           head = newNode;
           tail = newNode;
           length++;
           return;
       }
       //双向链表
           newNode.next = head;
           head.prev = newNode;
           head = newNode;
           length++;
           return;
   }
  • 尾插
    在这里插入图片描述
 public void addTail(int  val){
       Node newNode = new Node(val);
       tail = head;
       if(head == null){
           head = newNode;
           tail = newNode;
           length++;
           return;
       }
       while (tail.next != null){
           tail = tail.next;
       }
       tail.next = newNode;
       newNode.prev = tail;
       tail =  newNode;
       length++;

   }
  • 指定位置插入：
//根据取下标得到节点,这步后面会多次用到，为了方便，所以单独写成一个方法。
   public Node getNode(int index){
       if(index < 0 || index >= length || head == null){
           return null;
       }
       Node cur = head;
       for(int i = 0;i < index;i++){
           cur = cur.next;
       }
       return cur;
   }

public void add(int index,int val){
       if(index < 0 || index > length){//如果index = length，就相当于尾插
           return;
       }
       if(index ==  0 ){//头插
           addFirst(val);
           return;
       }
       if(index == length){//尾插
           addTail(val);
           return;
       }
       Node newNode = new Node(val);
       Node nextNode = getNode(index);//调用上面的方法
       Node prevNode = newNode.prev;
       /**
        * 接下来要往cur之前插入newNode，因为要让newNode的下标变为val;
        * 如果是cur之后，那就变成了val＋1
        */
       prevNode.next = newNode;
       newNode.prev = prevNode;

       newNode.next = nextNode;
       nextNode.prev = newNode;
       length++;
   }

在这里插入图片描述

指定位置插入考虑的较多，如果指定的 位置为0，即为头插，则调用尾插的方法，如果指定的 位置和 他的长度一样，即为尾插，则调用尾插的方法。

  • 删除和查找
    在这里插入图片描述
//根据给定的下标得到节点
   public Node getNode(int index){
       if(index < 0 || index >= length || head == null){
           return null;
       }
       Node cur = head;
       for(int i = 0;i < index;i++){
           cur = cur.next;
       }
       return cur;
   }

//根据给定的值查找下标
 public int indexof(int val){
       if(head == null){
           return -1;
       }
       Node cur = head;
       for(int i = 0;i < length;i++){
           if(cur.val == val){
               return i;
           }
           cur = cur.next;
       }
       return -1;
   }


//根据下标删除
 public void removeByIndex(int index) {
       if(index < 0 || index >= length || head == null){
           return;
       }
       //头删
       if(head.next == null){
           head = null;
           tail = null;
           length = 0;
           return;
       }
       if(index == 0){
           Node newNode = head;
           newNode = newNode.next;
           newNode.prev = null;
           head = newNode;
           return;
       }
       //尾删
       if(index == length - 1){
           Node newNode = head;
           while (newNode.next != null){
               newNode = newNode.next;
           }
           newNode.prev.next = null;
           tail = newNode.prev;
           length--;
           return;
       }
//非头删和尾删
       Node newNode = getNode(index);//通过getNode方法，找到下标为index的节点，进行删除
       newNode.prev.next = newNode.next;
       newNode.next.prev = newNode.prev;
       length--;
   }
   
   //根据值删除
   public void removeByValue(int val){
       int index = indexof(val);//通过indxof方法找到值为val所对应的下标，此时根据值删除就转化为了根据下标删除
       if(index == -1){
           return;
       }
       removeByIndex(index);//此时就可以调用上面的根据下标删除方法 
   }
  • 修改
//根据取下标得到节点
  public Node getNode(int index){
      if(index < 0 || index >= length || head == null){
          return null;
      }
      Node cur = head;
      for(int i = 0;i < index;i++){
          cur = cur.next;
      }
      return cur;
  }

//修改，根据给定的下标找到对应的 节点，然后修改该节点存储的值
  public void set(int index,int val){
      Node cur = getNode(index);
      cur.val = val;

  }
  • 查找
//根据取下标得到节点
   public Node getNode(int index){
       if(index < 0 || index >= length || head == null){
           return null;
       }
       Node cur = head;
       for(int i = 0;i < index;i++){
           cur = cur.next;
       }
       return cur;
   }

//给定下标进行查找，此时可以调用上面的方法，找到下标对应的节点，然后将该节点的值返回
   public int get(int index){
       return getNode(index).val;
   }

//给定值查找下标
public int getIndex(int val){
       if(head == null){
           return -1;
       }
       for(int i = 0; i < length;i++){
           if(head.val == val){
               return i;
           }
           head = head.next;
       }
       return -1;
   }
春风又。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3145
简述双向链表概念、C语言实现双向链表
【链表 反转链表】 双指针
weixin_44669411的博客
01-19 234
反转链表 leetcode(206) 双指针 /** 时间O(n) 空间O(1) * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode reverseList(ListNode head) {
数据结构之双向链表的实现
qq_62905847的博客
10-02 614
java自主实现双向链表
双向链表的实现
Yntic的博客
11-21 781
数据结构——带头双向循环链表的实现
【数据结构】双向链表实现
m0_73367097的博客
03-26 1641
双向链表的定义与实现
双向链表的实现（详解）
的博客
04-14 521
链表的分类： 带头 不带头 单向 双向 循环 不循环一共有 (2 * 2 * 2) 种链表带头指的是：带有哨兵位节点哨兵位（头结点）：可以放随机数据，哨兵位指向的下一个节点就是我们的第一个有效节点，我们指的头节点是哨兵位单向：指针只能从前向后遍历双向：指针既可以从前向后遍历又可以从后向前遍历循环：可以通过尾节点找到头节点，从而达到循环主要使用的链表是单链表和双向链表单链表:不带头单向不循环双向链表：带头双向循环。
双向链表的访问，双向链表的排序
honeylife的博客
08-12 1436
双向链表的访问，双向链表的排序 题目 已知不带头结点的双向链表第一个节点的指针为list，链节点除了数据域和分别指向该结点的前驱结点和后继结点的指针域外，还设置记录该节点访问次数频度域freq(初始值为0)，请设计一算法LOCATE(list,x),该算法的功能是每当访问LOCATE（list,x）操作，数据域信息为X的结点freq域的值增加1，并且保持链表中结点的freq值得递减链接，使得频繁访...
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
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...
C++的双向链表实现
04-15
下面是一个简化的双向链表类实现，包含上述基本操作： ```cpp class DoublyLinkedList { private: Node* head; Node* tail; public: DoublyLinkedList() : head(nullptr), tail(nullptr) {} void ...
C++双向链表实现简单通讯录
08-19
我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表的基本概念。链表是一种数据结构，它由多个节点组成，每个节点包含一些数据和指向下一个节点的...
基础知识一、Python实现双向链表
12-20
在Python中，我们可以通过定义一个`Node`类来表示链表中的节点，以及一个`DoubleLinkedList`类来实现链表的整体结构。以下是关键点： 1. **Node类**： - `__init__`方法：初始化节点，包括键（key）、值（value）...
双向链表的功能实现
Lee贤的博客
05-12 744
本文主要介绍了双向链表的原理及功能的实现
一步步带你用Java实现双向链表（超详细）
热门推荐
you do ,you win
04-21 1万+
文章目录什么是双向链表属性及方法节点Nodesize数据插入头插法 addFirst(T value)尾插法 addLast(T value)插入到指定下标位置add(int index)数据删除(返回被删除节点存储的值)删除头结点 removeFirst删除尾结点 removeLast删除指定下标节点remove（int index）获取指定下标位置节点的数据 getData（int index）获取链表长度遍历输出print()详细遍历输出清空链表实现细节 上一节说到了单链表,这一节我们来手写一个双向链
数据结构——动手实战双向链表
TechFlow的博客
03-05 260
本文始发于个人公众号：TechFlow，原创不易，求个关注 在之前介绍SkipList的文章当中，有一些同学反馈说由于对链表缺少认知以及了解，所以直接啃算法有些过于困难。加上之前的文章当中介绍过了栈，所以这次继续线性表这个话题，我们来一起讨论一下链表。 链表是很多数据结构的基础，它的最大特点是支持快速的删除和插入，因此在很多数据频繁变动的场景下使用广泛。而且链表的可拓展性较强，所以它的应用非常广...
自己实现一个双向链表
weixin_46117546的博客
03-09 162
自己实现一个双向链表 双向链表和单向链表不同的是双向链表中不仅有next指向, 还有pre这个指向, 分别指向了该节点的前一个节点和后一个节点, 这样比单向链表操作起来更方便. class TwoNode{ int val; TwoNode pre; TwoNode next; public TwoNode(int val){ this.val = val; } } public class MyLinkedList { //双向链表需要
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 389
【代码】c语言（7.23）
C++编程：双向链表与集合操作实现
在C++中，双向链表是一种数据结构，它允许在列表中的每个元素（节点）都有一个指向前一个元素和后一个元素的指针。这个实验主要涉及以下几个知识点： 1. **双向链表的构建**：双向链表由Node类和List类组成。Node类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值