数据结构系列5——链表（无头双向非循环链表）

已于 2023-03-15 13:50:40 修改
阅读量171 收藏
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 Powered by 金山文档
于 2023-03-15 11:53:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46114074/article/details/129545625
版权

一、定义

与单向无头非循环链表相比多了一个前驱

二、实现MyLinkedList

1.双向非循环链表的构建

public class MyLinkedList {
    static class listNode{
        public int val;
        // 前驱
        public listNode prev;
        // 后继
        public listNode next;

        public listNode(int val) {
            this.val = val;
        }
    }
    // 头节点
    public listNode head;
    // 尾节点
    public listNode last;
}

2.头插法

public void addFirst(int data){
    listNode node = new listNode(data);
    if(head  == null){
        head = node;
        last = node;
    }else{
        node.next = head;
        head.prev = node;
        head = node;
    }
 } 

2.尾插法

public void addLast(int data){
    listNode node = new listNode(data);
    if(head == null){
        head = node;
        last = node;
    }else{
        last.next = node;
        node.prev = last;
        last = node;
    }
}

3.打印链表

public void display(){
        listNode cur = head;
        while (cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

与单向无头非循环链表一样

4.链表长度

public int size(){
        listNode cur = head;
        int count = 0;
        while (cur != null){
            count++;
            cur = cur.next;
        }
        return count;
    }

与单向无头非循环链表一样

5.判断是否包含关键字key在双向链表中

public boolean contains(int key){
        listNode cur = head;
        while (cur != null){
            if (cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;

与单向无头非循环链表一样

6.任意位置插入一个数据节点

思路：1.检查index是否越界

2.检查index==0 >> 头插法

3.检查index==size() >> 尾插法

4.正常插入

public void addIndex(int index,int data) throws ListIndexOutOfException{
    if(index<0 || index > size()){
        throw new ListIndexOutOfException("越界");
    }
    if(index == 0){
        addFirst(data);
        return;
    }
    if(index == size()){
        addLast(data);
        return;
    }
    listNode cur = head;
    while (index != 0){
        cur = cur.next;
        index--;
    }
    listNode node = new listNode(data);
    node.next = cur;
    cur.prev.next = node;
    node.prev = cur.prev;
    cur.prev = node;
}

7.删除第一次出现关键字为key的节点

思路：分删除头节点，中间节点，尾节点

  1. 删除头结点，考虑链表只有头结点，要是有大于两个以上的节点，需要将head = head.next 然后head.prev = null;

  1. 删除中间节点 cur.prev.next = cur.next cur.next.prev = cur.prev

  1. 删除尾节点 cur.prev.next = cur.next 此时cur.next == null,需要将last = last.prev; 

 public void remove(int key){
    listNode cur = head;
    while(cur != null){
        if(cur.val == key){
            if(head == cur){
                //只有一个head节点
                head = head.next;
                if(head != null){
                    head.prev =null;
                }
            }else{
                cur.prev.next = cur.next;
                if(cur.next != null){
                    cur.next.pev = cur.prev;
                }else{
                    last = last.prev;
                }
            }
            return;
        }
        cur = cur.next;  
    }
}

8.删除所有key值节点

 public void remove(int key){
    listNode cur = head;
    while (cur != null){
        if(cur.val == key){
            if(cur == head){
                head = head.next;
                if(head != null){
                    head.prev = null;
                }
            }else {
                cur.prev.next = cur.next;
                if(cur.next!=null){
                    cur.next.prev = cur.prev;
                }else {
                    last = last.prev;
                }
            }
        }
        cur = cur.next;
    }
}

去掉return继续进行查找进行删除。

  1. 清空MyLnkedList

public void clear(){
    listNode cur = head;
    // 遍历链表，将节点的前驱和后继进行置为null
    while (cur != null){
        listNode curNext = cur.next;
        cur.prev = null;
        cur.next =null;
        cur = curNext;
    }
    // 将头结点和last节点引用进行置为null
    head = null;
    last = null;
}

三、什么是LinkedLIst

LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节

点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高

1. LinkedList实现了List接口

2. LinkedList的底层使用了双向链表

3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问

4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)

5. LinkedList比较适合任意位置插入的场景

四、LinkedList的使用

1. LinkedList的构造方法

方法

解释

LinkedList()

无参构造

public LinkedList(Collection<? extends E> c)

使用其他集合容器中元素构造List

public static void main(String[] args) {
    // 构造一个空的LinkedList
    List<Integer> list1 = new LinkedList<>();
    
    List<String> list2 = new ArrayList<>();
    list2.add("JavaSE");
    list2.add("JavaWeb");
    list2.add("JavaEE");
    // 使用ArrayList构造LinkedList
    List<String> list3 = new LinkedList<>(list2);
}

含参的构方法

2.LinkedList其他方法

1.尾插法

public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    list.add(1);  // add(elem): 表示尾插
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.add(7);
    System.out.println(list.size());
    System.out.println(list);
}

2.在指定位置插入

public static void main(String[] args) {
    // 在起始位置插入0
    list.add(1, 0);  // add(index, elem): 在index位置插入元素elem
}

3.删除元素

public static void main(String[] args) {   
    list.remove();     // remove(): 删除第一个元素，内部调用的是removeFirst()
    list.removeFirst();   // removeFirst(): 删除第一个元素
    list.removeLast();   // removeLast(): 删除最后元素
    list.remove(1);  // remove(index): 删除index位置的元素
    System.out.println(list);
    
    // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
    if(!list.contains(1)){
    list.add(0, 1);
    }
}

4.是否包含元素

public static void main(String[] args) {   
    // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
    boolean ret = list.contains(1);
}

5.查找元素以及设置指定位置的元素

public static void main(String[] args) {   
    System.out.println(list.indexOf(1));  // indexOf(elem): 从前往后找到第一个elem的位置
    System.out.println(list.lastIndexOf(1));  // lastIndexOf(elem): 从后往前找第一个1的位置
    int elem = list.get(0);   // get(index): 获取指定位置元素
    list.set(0, 100);      // set(index, elem): 将index位置的元素设置为elem
     System.out.println(list);
}

6.copyLinkedLIst(指定范围)——subList(from,to) [from,to)

public static void main(String[] args) {   
    List<Integer> copy = list.subList(0, 3); 
    System.out.println(list);
    System.out.println(copy);
}

3. LinkedList的遍历

  1. for循环

  1. for-each进行遍历

  1. 迭代器

public static void main(String[] args) {
    List<Integer> list = new LinkedList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    // 1.for循环
    for (int i = 0; i < list.size(); i++) {
        System.out.print(list.get(i)+" ");
    }
    System.out.println();
    // 2.for each
    for (Integer x :list) {
        System.out.print(x+" ");
    }
    System.out.println();
    // 3.迭代器
    ListIterator<Integer> it = list.listIterator();
    while (it.hasNext()){
        System.out.print(it.next()+" ");
    }
    // 4.迭代器反向迭代  传入迭代链表的长度，使用Previous
    ListIterator<Integer> it2 = list.listIterator(list.size());
    while (it2.hasPrevious()){
        System.out.print(it2.previous()+" ");
    }
}

五、ArrayList和LinkedList的区别

哈士奇的奥利奥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
无头双向链表
Fighting261的博客
05-02 218
class Node { public int data;//数据 public Node next;//后继信息 public Node prev;//前驱信息 public Node(int data) { this.data = data; } } public class MyLinkedList { public No...
无头双向链表方法
yanweiding的博客
10-29 114
public class DoubleLinkedList { //头插法 public void addFirst(int data); //尾插法 public void addLast(int data); //任意位置插入,第一个数据节点为0号下标 public boolean addIndex(int index,int data); //查找是否包含关键字key是否在单链表当中 public boolean contains(int key); //删除第一次出现关键字为key的节点 publi
Java实现无头双向链表
weixin_46660141的博客
08-02 155
创建空的成员变量并用构造函数初始化 class ListNode { public int data; public ListNode next;//节点引用 public ListNode prev;//节点前驱 public ListNode(int data) { this.data = data; } } 头节点和尾结点 public class DoubleLinkedList { public ListNode head.
链表之无头双向非循环链表（Java语言）
qq_57563254的博客
12-06 833
无头双向链表（Java语言）前言介绍无头双向非循环链表节点类——ListNode链表类——MyLinkedList打印链表得到链表的长度查找是否包含关键字key插入一个元素——头插法插入一个元素——尾插法插入一个元素——任意位置插入寻找index位置的节点删除第一次出现key的节点删除所有key的节点清空链表总代码 前言 经过对于顺序表和单链表的熟悉我们已经对于数据结构有了简单的认识，这次我们了解无头双向链表的相关知识。 介绍 首先我们先看一下双向链表的结构： 这就是一个非常简单的双向链表，一个节点可以找
无头双向链表基本操作：头插法，尾插法，删除key.....
zxjkl123的博客
11-17 257
无头双向链表基本操作：头插法，尾插法，删除key… //构造无头双向链表 class ListNode { public int data; public ListNode next; public ListNode prev; public ListNode(int data) { this.data=data; this.next...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
python实现数据结构中双向循环链表操作的示例
12-16
双向循环链表是一种重要的数据结构，它允许我们在链表的两端进行插入和删除操作，同时每个节点都包含指向其前一个和后一个节点的引用，形成一个闭合的循环。在给定的示例中，我们看到了如何用Python实现这种数据结构...
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
【数据结构】链式存储：链表（无头双向链表实现）
最新发布
m0_72161237的博客
01-04 800
🌈节点由val域(数据域)，prev(前驱），next(后继)，对于prev域，其是引用类型，存放上一个节点的地址；对于next域，其是引用类型，存放下一个节点的地址。
无头双向链表的实现
weixin_45662626的博客
02-24 219
上一篇：不带头节点的单链表的实现 无头双向链表的实现 无头双向链表就是没有头节点，每个节点都有next和前驱prev的链表。 如下图示意： 我们来开始写代码，无头双向链表的实现： class Node{ public int data; public Node next; public Node prev; public Node(int data) { this.data = data; } } public class MyLinkedList
链表之双向链表（有头and无头）
m0_48810566的博客
10-26 423
链表之双向链表 话不多说，直接看代码，你懂的！！！！！！ 无头双向链表的定义： class ListNode { public int val; public ListNode next; public ListNode prev; public ListNode(int val) { this.val = val; } } public class DoubleList { public ListNode head; public
【JAVA】双向链表的基本操作（增删查改）代码详解
qq_45864756的博客
06-16 362
关于双向链表的学习，简单易懂
无头双向链表的相关操作（Java实现）
better12038的博客
08-09 335
首先介绍一下双向链表： 双向链表也叫双链表，是链表的一种，它的每个Node结点都包含3个信息，分别是：数据域、前驱以及后继。与单链表的不同就是，它多了一个描述当前结点前驱的属性。 下面主要说的是不带头结点的，假设有一组数据（10, 20, 18, 46, 2），它们以双向链表的形式存储 ，那么就是下面这个样子： （链表中的第一个结点默认是头结点，所以head指向第一个结点；链表的最后一个...
不带头双向链表实现
wang_da_ye的博客
04-09 144
#include <stdio.h> #include <stdlib.h> #include "doubly.h" ////不带头双向链表 typedef struct DoublyNode { DoublyNode*next; DoublyNode*prior; int data; }DoublyNode; ////头插创建: 用指针f...
Java 实现无头双向链表的基本操作
近未来
07-13 254
无头双向链表的结构： 节点结构 class Node { private int data; private Node next; private Node prev; public Node(int data) { this.data = data; this.prev = null; this.next = n...
双向链表
qq_38353700的博客
10-05 457
一，目的。实现无头双链表，并完成其基本的操作，包括插入，删除等。二，为什么有单链表了还要有双向链表？双向链表，顾名思义，相对于单链表，每个节点不仅要有指向其后继的指针，还有指向其前驱的指针。首先我们来看节点的定义：template<class T> struct Node { T data; //节点的数据 Node<T>* _prev; //其前驱 Node<T>* _
不循环的双向链表
qq_59961968的博客
08-27 382
做初学者，我将向读者介绍如何去创建一个双向链表，和实现一些简单的功能
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哈士奇的奥利奥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值