【 双向链表】 实现一个双向链表，主要功能有头插，头删，尾插，尾删，按下标插入，按下标删除，按下标查找，按元素查找，按元素删除等等

最新推荐文章于 2023-12-20 13:35:53 发布
最新推荐文章于 2023-12-20 13:35:53 发布
阅读量174 收藏 1
点赞数 2
分类专栏： Java数据结构 Java题目练习 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangxxin/article/details/114606984
版权

学习目标：

目标：熟练运用Java所学知识

学习内容：

本文内容：使用Java实现：自己实现一个链表，主要功能有，头插，头删，尾插，尾删，按下标插入，按下标删除等等

文章目录

具体实现：

  • 首先创建一个节点
class ListNode {
    int val;
    ListNode next;//指向下一个节点
    ListNode prev;//指向前一个结点
    public ListNode(int val){
        this.val=val;
    }
}
  • 创建头尾结点和记录长度的变量
   public ListNode head=null;//头结点
   private ListNode tail=null;//尾节点
   private int length=0;//记录链表长度
  • 按位置获取结点
//按位置获取结点
public ListNode getNode(int index){
    ListNode cur=head;
    //当位置输入有误
    if(index<0||index>=length){
        return null;
    }
    //通过for循环遍历到当前结点
    for(int i=0;i<index;i++){
        cur=cur.next;
    }
    return cur;
}
  • 头插操作
public void addFirst(int val){
    ListNode newNode=new ListNode(val);//为val创建新节点
    //链表为空时，将新节点赋给头尾结点并返回
    if(head==null){
        head=newNode;
        tail=newNode;
        length++;
        return;
    }
    //链表不为空时。头插新节点
    newNode.next=head;
    head.prev=newNode;
    head=newNode;
    length++;
}
  • 尾插
//尾插
public void addLast(int val){
    ListNode newNode=new ListNode(val);//为val创建新节点
    //链表为空时，将新节点赋给头尾结点并返回
    if(tail==null){
        head=newNode;
        tail=newNode;
        length++;
        return;
    }
    //链表不为空时，尾插新节点
    tail.next=newNode;
    newNode.prev=tail;
    tail=newNode;//更新尾结点
}
  • 按指定位置插入
//指定位置插入
public void add(int index,int val){
    ListNode newNode=new ListNode(val);//为val创建新节点
    //当下标输入错误时
    if(index<0||index>length){
        System.out.print("位置输入错误");
        return;
    }
    //下标等于0，直接调用头插操作
    if(index==0){
        addFirst(val);
        return;
    }
    //下标等于长度，调用尾插操作
    if(index==length){
        addLast(val);
        return;
    }

    ListNode curNode=getNode(index);//调用按位置获取结点方法获取index下标位置的结点
    ListNode preNode=curNode.prev;//要插入位置的前一个结点
    //插入新节点
    preNode.next=newNode;
    newNode.prev=preNode;

    newNode.next=curNode;
    curNode.prev=newNode;

    length++;
}
  • 头删
//头删
public void removeFirst(){
    //链表为空
    if(head==null){
        return;
    }
    //链表只有一个节点
    if(head.next==null){
        head=null;
        tail=null;
        length=0;
        return;
    }
    head.next.prev=null;//删除头结点
    head=head.next;//更新头结点
    length--;
}
  • 尾删
//尾删
public void removeLast(){
    //链表为空
    if(head==null){
        return;
    }
    //链表只有一个节点
    if(head.next==null){
        head=null;
        tail=null;
        length=0;
        return;
    }
    tail.prev.next=null;//删除尾结点
    tail=tail.prev;//更新尾结点
    length--;
}
  • 按照下标删除
//按照下标删除
public void removeByIndex(int index){
    //输入的下标不合法时
    if(index<0||index>=length){
        return;
    }
    //下标为0，调用头删操作
    if(index==0){
        removeFirst();
        return;
    }
    //下标为尾结点，调用尾删操作
    if(index==length-1){
        removeLast();
        return;
    }
    
    ListNode cur=getNode(index);//调用按位置获取结点方法得到下标的结点
    //删除当前结点
    cur.prev.next=cur.next;
    cur.next.prev=cur.prev;
    length--;
}
  • 按给定值删除
//按给定值值删除
public void removeByVal(int value){
    int index=getIndex(value);//获取当前值对应的下标
    //下标不合法时
    if(index==-1){
        return;
    }
    removeByIndex(index);//调用按照位置删除的操作
}
  • 按给定值获取对应下标
//按值获取下标
public int getIndex(int value){
    ListNode cur=head;
    //循环遍历，找对应值
    for(int i=0;i<length;i++){
        //当找到对应值的，返回对应下标
        if(cur.val==value){
            return i;
        }
            cur=cur.next;
    }
    return -1;
}
  • get，set方法
public int get(int index){
    if(index<0||index>=length){
        return -1;
    }
    return getNode(index).val;
}
public void set(int index,int value){
    if(index<0||index>=length){
        return;
    }
    getNode(index).val=value;
}

代码汇总:

public class MyLinkedList
    {
        @Override
        public String toString() {
            return "MyLinkedList{" +
                    "head=" + head.val +
                    ", tail=" + tail.val +
                    '}';
        }
        public static void printList(ListNode head) {
            ListNode cur = head;
            while (cur != null) {
                System.out.println(cur.val);
                cur = cur.next;
            }
        }
        public ListNode head=null;//头结点
        private ListNode tail=null;//尾节点
        private int length=0;//记录链表长度
        //头插
        public void addFirst(int val){
            ListNode newNode=new ListNode(val);//为val创建新节点
            //链表为空时，将新节点赋给头尾结点并返回
            if(head==null){
                head=newNode;
                tail=newNode;
                length++;
                return;
            }
            //链表不为空时。头插新节点
            newNode.next=head;
            head.prev=newNode;
            head=newNode;
            length++;
        }
        //尾插
        public void addLast(int val){
            ListNode newNode=new ListNode(val);//为val创建新节点
            //链表为空时，将新节点赋给头尾结点并返回
            if(tail==null){
                head=newNode;
                tail=newNode;
                length++;
                return;
            }
            //链表不为空时，尾插新节点
            tail.next=newNode;
            newNode.prev=tail;
            tail=newNode;//更新尾结点
        }
        //指定位置插入
        public void add(int index,int val){
            ListNode newNode=new ListNode(val);//为val创建新节点
            //当下标输入错误时
            if(index<0||index>length){
                System.out.print("位置输入错误");
                return;
            }
            //下标等于0，直接调用头插操作
            if(index==0){
                addFirst(val);
                return;
            }
            //下标等于长度，调用尾插操作
            if(index==length){
                addLast(val);
                return;
            }

            ListNode curNode=getNode(index);//调用按位置获取结点方法获取index下标位置的结点
            ListNode preNode=curNode.prev;//要插入位置的前一个结点
            //插入新节点
            preNode.next=newNode;
            newNode.prev=preNode;

            newNode.next=curNode;
            curNode.prev=newNode;

            length++;
        }
        //头删
        public void removeFirst(){
            //链表为空
            if(head==null){
                return;
            }
            //链表只有一个节点
            if(head.next==null){
                head=null;
                tail=null;
                length=0;
                return;
            }
            head.next.prev=null;//删除头结点
            head=head.next;//更新头结点
            length--;
        }
        //尾删
        public void removeLast(){
            //链表为空
            if(head==null){
                return;
            }
            //链表只有一个节点
            if(head.next==null){
                head=null;
                tail=null;
                length=0;
                return;
            }
            tail.prev.next=null;//删除尾结点
            tail=tail.prev;//更新尾结点
            length--;
        }
        public int size(){
            return length;
        }
        //按照下标删除
        public void removeByIndex(int index){
            //输入的下标不合法时
            if(index<0||index>=length){
                return;
            }
            //下标为0，调用头删操作
            if(index==0){
                removeFirst();
                return;
            }
            //下标为尾结点，调用尾删操作
            if(index==length-1){
                removeLast();
                return;
            }

            ListNode cur=getNode(index);//调用按位置获取结点方法得到下标的结点
            //删除当前结点
            cur.prev.next=cur.next;
            cur.next.prev=cur.prev;
            length--;
        }
        //按给定值值删除
        public void removeByVal(int value){
            int index=getIndex(value);//获取当前值对应的下标
            //下标不合法时
            if(index==-1){
                return;
            }
            removeByIndex(index);//调用按照位置删除的操作
        }

        //按值获取下标
        public int getIndex(int value){
            ListNode cur=head;
            //循环遍历，找对应值
            for(int i=0;i<length;i++){
                //当找到对应值的，返回对应下标
                if(cur.val==value){
                    return i;
                }
                    cur=cur.next;
            }
            return -1;
        }
        //按位置获取结点
        public ListNode getNode(int index){
            ListNode cur=head;
            //当位置输入有误
            if(index<0||index>=length){
                return null;
            }
            //通过for循环遍历到当前结点
            for(int i=0;i<index;i++){
                cur=cur.next;
            }
            return cur;
        }
        public int get(int index){
            if(index<0||index>=length){
                return -1;
            }
            return getNode(index).val;
        }
        public void set(int index,int value){
            if(index<0||index>=length){
                return;
            }
            getNode(index).val=value;
        }

    }
printf("不要熬夜!")
关注
专栏目录
数据结构— 循环链表、双向链表【插入&删除】、双向循环链表
四季轮换叶，一路招摇胜
03-31 5742
循环链表也称为环形链表，其结构与单链表相似，只是将单链表的首尾相连。将最后一个结点的后继指针指向第一个结点。
双向链表的实现
zhao19971014的博客
05-13 408
//头文件 //List.h #pragma once #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<stdbool.h> typedef int LTDataType; typedef struct ListNode { struct ListNode* next; struct ListNode* prev; LTDataType data; }LTNode; .
双向链表的各种操作（包括建立，插入，删除，查找等）源代码
09-11
双向链表的各种操作（包括建立，插入，删除，查找等）源代码
实现双向链表的任意位置删除
zeoman的博客
11-01 109
【代码】实现双向链表的任意位置删除。
双链表的头插头删及尾插尾删操作
qq_45648990的博客
12-01 304
双链表的头插头删及尾插尾删操作： 定义链表: Node类： public class Node { int val; Node next; Node prev; Node(int val, Node next,Node prev){ this.val=val; this.next=next; this.prev=pr...
双向链表实现创建双向链表，判空，创建节点，头插，遍历，尾插，查找任意位置数据，任意位置插入，任意位置删除
m0_71934534的博客
11-01 195
双向链表实现创建双向链表，判空，创建节点，头插，遍历，尾插，查找任意位置数据，任意位置插入，任意位置删除
双向链表实现 插入删除
xiangqiao123的专栏
04-23 1104
#include "stdafx.h" #include "stdio.h" #include "stdlib.h" //双向链表 结点 typedef struct Node{ int data; Node * prior; Node * next; }Node; //链表管理 节点 typedef struct Link{ Node * front; Node * rear;
数据结构之双向链表详解
最新发布
小源_ 的博客
12-20 3638
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
数据结构《LinkeList 双向链表》
m0_66483195的博客
11-13 1179
LinkeList 的模拟和使用
链表-双向循环链表【C语言】
weixin_45423515的博客
05-15 2094
双向循环链表是最优链表，能补齐单链表的缺点，是个结构复杂，操作简单的链表。其插入和删除节点的时间复杂度是O(1)。 双向链表： 和单链表不同的是双向链表有两个指针，一个指向下一个节点，一个指向上一个节点 typedef int LTDataType; typedef struct ListNode { LTDataType _data; struct ListNode* _next; struct ListNode* _prev; }ListNode; ...
数据结构双链表之(二)头插&&尾删&&头删
YL950305的博客
05-15 167
文章目录1. 思路1.1 头插1.2 尾删1.3 头删2. 代码2.1 DList.h2.2 DList.cpp2.3 main.cpp3. 结果3.1 头插3.2 尾删3.3 头删 1. 思路 1.1 头插 1.2 尾删 1.3 头删 2. 代码 2.1 DList.h //头插 void push_front(List *list, ElemType x); //尾删 void pop_back(List *list); //头删 void pop_front(List *list)
双向链表实现
gradkid的专栏
10-26 606
1. 双向链表访问数据的方式不是数组的下标，而是他的节点的指针来访问。所以他可以更灵活的处理数据见得相关信息。不过他的速度肯定没有数组下标快的，空间也没有数组利用率高，可他的灵活性给了我们很大的方便。我们用链表的时候还是很多的。2. 链表是用指针的指向来访问管理数据的，一个我们把数据存在一个节点里，一个节点包括：nData，节点的数据域，nNext，他指向的下一个指针，nPre他的上一个指针。如果
手写双向链表add元素以及通过下标获取元素（LinkedList源码分析）
vtrbrtsghu的博客
05-28 307
public class MyLinkedList { class Node{ // 上一个节点地址 private Node pre; // 当前节点存储值 private E cur; // 下一个节点地址 private Node next; public Node getPre() { return pre; } public void setPre(Node pre) { this.pre =
js封装数据结构_05_双向链表
masierty的博客
03-19 416
一、双向链表的特点： 双向链表不同于单向链表，它既可以从头遍历到尾，又可以从尾遍历到头； 链表一般有head、tail、length等属性，head指向头节点，length表示链表节点的个数,tail指向尾部节点； 链表无法通过下标直接访问元素，需要从head指向的头节点或tail指向的尾节点开始一个一个的访问，直到找到对应的元素； 二、这里我实现了： 增： append，向链尾添加节点 insert,向特定位置插入新节点 删： removeAt，指定位置删除节点，成功返回删除节点.
双向链表及其用法
热门推荐
5431的专栏
04-17 1万+
一、双向链表的定义 二、双向链表的存储结构 三、双向链表的实现与操作
数据结构双向链表学习
fengjuju的博客
05-02 1332
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
2.12双向链表基本操作（C语言实现）
weixin_42437172的博客
12-29 1113
本节学习有关双向链表的一些基本操作，即如何在双向链表中添加、删除、查找或更改数据元素。 本节知识基于已熟练掌握双向链表创建过程的基础上，我们继续上节所创建的双向链表来学习本节内容，创建好的双向链表如图 1 所示： 图 1 双向链表示意图 双向链表添加节点 根据数据添加到双向链表中的位置不同，可细分为以下 3 种情况： 添加至表头 将新数据元素添加到表头，只需要将该元素与表头元素建立双层...
双向链表和数组的区别
iteye_71的博客
12-18 954
 //自定义一个链表 public class LinkList&lt;E&gt; { //初始状态时没有任何数据；头结点为null；尾结点为null；数据个数为0 public Node&lt;E&gt; head=null; public Node&lt;E&gt; last=null; private int num=0; //存放数据（添加结点）的...
面试官让我手写一个双向链表
Geek_ymv的专栏
11-10 702
笔者之前参加过一场视频面试，其中一个问题是说说ArrayList、LinkedList的区别，参加过面试的同学可能经常会被问到这个问题，当我说到ArrayList是基于数组实现的LinkedList是基于双向链表实现的时候，面试官说那你能写一个双向链表吗？ 因为面试邀请邮件中告知面试时需要写代码，笔者在面试之前虽然看了一些数据结构方面的知识点，但当真正手写的时候还是费了一番功夫。趁着这次周末有空，写一篇文章总结下双向链表。 在前面的文章单链表的CRUD中详细介绍过单链表的插入、查找、修改和删除操作。我们可以
实现线性表的链式存储定义，完成单链表的创建（头插法、尾插法）、插入、删除、查找等常用操作，将线性链表逆置，即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，以此类推。
05-18
头插法是指将新节点插入到链表的头部，即新节点成为链表的第一个节点。以下是头插法创建单链表的代码实现： ```c LinkedList createListByHeadInsert(int* arr, int n) { LinkedList head = (LinkedList)malloc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值