【JAVA】数据结构-链表

于 2024-08-16 21:30:58 发布
阅读量663 收藏 15
点赞数 7
文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhj25802580/article/details/141269681
版权

​​​​​​​

一、链表
1.1 链表的概念
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。

数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。

链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。

链表的优点是可以高效地插入和删除节点，而无需移动其他节点。然而，由于链表中的节点不是连续存储的，访问特定位置的节点需要从头部开始遍历，因此随机访问的效率较低。

1.2 链表的结构

在实际的应用场景中，链表的结构非常多样，以下是常见的链表结构：

  1. 单向链表
    单向链表（Singly Linked List）是一种基本的链表结构，每个节点包含两个主要部分：数据域和指针域。以下是单向链表的结构示意图：

在单向链表中，每个节点包含一个数据域，用于存储节点所需的数据，以及一个指针域，指向链表中的下一个节点。最后一个节点的指针域通常指向空值（NULL），表示链表的结束。

通过这种方式，节点之间通过指针链接在一起，形成一个链表结构。链表的头部节点通过外部引用进行访问，然后可以依次遍历访问链表中的每个节点。

由于单向链表只有一个方向的指针，所以只能从头部节点开始顺序遍历访问，无法直接访问后续节点，也无法在常量时间内进行反向遍历。

单向链表在插入和删除节点时具有较好的性能，因为只需要修改节点的指针，而不需要移动其他节点。然而，在访问特定位置的节点时，需要从头部节点开始遍历整个链表，导致访问效率较低。

2.双向链表
双向链表（Doubly Linked List）的每个节点包含两个指针，分别指向前一个节点和后一个节点。这使得节点可以在两个方向上进行遍历和访问，提供了更多的灵活性和功能。

在双向链表中，每个节点包含一个数据域和两个指针域。除了指向下一个节点的指针域（Next Pointer），还有一个指向前一个节点的指针域（Prev Pointer）。头部节点的 Prev Pointer 通常指向空值（NULL），尾部节点的 Next Pointer 也指向空值。

通过 Prev Pointer 和 Next Pointer，双向链表允许在链表的两个方向上遍历和访问节点。这使得在某些情况下，例如在链表末尾插入或删除节点，可以更高效地操作链表。

与单向链表相比，双向链表的操作稍微复杂一些，因为每个节点需要维护两个指针。但双向链表提供了更多的功能和灵活性，如可以从头部或尾部快速插入或删除节点，以及可以在两个方向上进行遍历和搜索。

3.带头节点的链表
带头结点的链表在头部添加了一个额外的节点作为头结点（Header Node）或哑节点（Dummy Node），这个头结点不存储任何实际的数据。

头结点位于链表的起始位置，其主要作用是方便链表的操作和管理。它不存储实际的数据，只包含一个指针域，指向链表中的第一个实际节点。

带头结点的链表的优点在于简化了链表的操作。它确保链表中始终存在一个非空节点，简化了插入、删除和遍历等操作的实现。此外，头结点可以用于存储链表的一些统计信息或提供其他便利的功能。

在带头结点的链表中，链表的第一个实际节点为头结点的下一个节点。通过头结点，可以轻松地访问链表中的实际数据节点，并进行相应的操作。

当遍历带头结点的链表时，通常从头结点的下一个节点开始，直到遇到指针域为 NULL 的节点，表示链表结束。

4.循环链表
循环链表（Circular Linked List）是一种特殊的链表结构，其中最后一个节点的指针指向链表的头部节点，形成一个闭环。
在循环链表中，每个节点仍然包含数据域和指针域，但最后一个节点的指针域不再指向空值（NULL），而是指向链表的头部节点。

这样的设计使得链表形成一个循环结构，可以通过任何节点开始遍历整个链表。从任何节点出发，通过指针的循环跳转，可以访问链表中的所有节点。

循环链表的优点在于在遍历和操作链表时，不需要考虑链表的结束位置。无论从哪个节点开始遍历，总能回到起始位置，避免了在常规链表中遇到的空指针异常。

二、LinkedList的简介

在Java中，LinkedList（链表）是Java集合框架提供的一个实现了List接口的类。它是基于双向链表结构实现的，可以用于存储和操作元素的有序集合。

三、模拟实现链表

1.display方法

思路：从头结点开始遍历，若该结点不等于null就打印输出该结点的元素。

问题：

  1. 怎么从一个结点走到下一个结点？：head = head.next;
  2. 怎么判断所有结点都已经走完了？：head= null;
  public void display() {
        ListNode cur = head;
        int count = 0;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
            count++;

        }
        System.out.println();
        System.out.println(count);
    }

【解释】：为什么创建一个cur代替head：如果直接用head遍历那么当打印输出结束后head就为null，相当于链表就空了，因此用cur代替head。

2.size方法

思路：定义一个计数器，从头开始遍历链表，每走一个结点计数器加一，最后返回计数器结果。

 public int size() {
        ListNode cur = head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
3.contains方法

思路：遍历链表，每走一步判断结点的元素是否等于key，等于则直接返回true，若遍历完成仍没有则返回false

public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
4.addFirst方法

思路：

  1. 创建一个结点
  2. 改变插入结点的next域
  3. 改变head
 public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }
5.addLast方法

思路：

  1. 实例化一个结点
  2. 找到最后一个结点cur
  3. cur.next = node;
 public void addLast(int data) {

        ListNode node = new ListNode(data);
        if (head == null) {
            return;
        }
        ListNode cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }
6.addIndex方法
public void addIndex(int index, int val) {
        if (index < 0 || index > size()) {
            return;
        }
        if (index == 0) {
            addFirst(val);
            return;
        }
        if (index == size()) {
            addLast(val);
            return;
        }

        ListNode cur = findIndex(index);

        ListNode node = new ListNode(val);
        node.next = cur.next;
        cur.next = node;

    }
7.remove方法
   public void remove(int k) {
        if (head == null)
            return;
        if (head.val == k) {
            head = head.next;
            return;
        }
        ListNode cur = finKey(k);
        if (cur == null) {
            return;//没有要删除的数据
        }
        ListNode del = cur.next;
        cur.next = del.next;

    }
8.removeAllKey方法
  public void removeAllKey(int key) {
        if (head == null) return;
        ListNode cur = head.next;
        ListNode prev = head;
        while (cur != null) {
            if (cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            } else {
                prev = cur;
                cur = cur.next;
            }

        }
        if (head.val == key) {
            head = head.next;
        }
    }
9.clear方法
public void clear() {
        ListNode cur = head;
        while (cur != null) {
            ListNode curN = cur.next;
            cur.next = null;
            cur = curN;
        }
        head = null;
    }

四、双向链表的实现

package demolinkedlist;

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;

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

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

    public void addIndex(int index,int data){
        if (index<0||index>size()){
            return;
        }

        if (index==0){
            addFirst(data);
        }
        if (index==size()){
            addLast(data);
        }

        ListNode cur=searchIndex(index);
        ListNode node=new ListNode(data);

        node.next=cur;
        cur.prev.next=node;
        cur.prev=node.prev;
        cur.prev=node;


    }

    private ListNode searchIndex(int index){
        ListNode cur=head;
        int count=0;
        while (count!=index){
            cur=cur.next;
            count++;
        }
        return cur;

    }

    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 {
                        last=null;
                    }

                }else {
                    if (cur.next==null){
                        cur.prev.next=cur.next;
                        last=cur.prev;
                    }else {
                        cur.prev.next=cur.next;
                        cur.next.prev=cur.prev;
                    }
                }
                return;
            }else {
                cur=cur.next;
            }
        }
    }

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

    public int size(){
        ListNode cur=head;
        int count=0;
        while (cur!=null){
          count++;
          cur=cur.next;
        }
        return count;
    }
    public void display(){
        ListNode cur=head;
        while (cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }

    }

    public void removeAllKey(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 {
                        last=null;
                    }

                }else {
                    if (cur.next==null){
                        cur.prev.next=cur.next;
                        last=cur.prev;
                    }else {
                        cur.prev.next=cur.next;
                        cur.next.prev=cur.prev;
                    }
                }
            }
                cur=cur.next;
        }
    }

    public void clear(){
        ListNode cur=head;
        ListNode curN=head.next;
        while (cur!=null){
            cur.next=null;
            curN.prev=null;
            cur=curN;
            curN=curN.next;
        }
        head=null;
        last=null;
    }


}

双链表与单链表相似！！

Java小混子
关注
java 链表
qq_57163230的博客
06-25 644
Java实现单链表，双向链表，循环链表。
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 1023
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
【Java】链表LinkedList
热门推荐
qq_61635026的博客
07-06 1万+
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
Java中的LinkedList
weixin_52758364的博客
01-16 2457
以实践为线索，逐步深入数据结构和算法，提升编程能力和思维能力。
Java数据结构——链表（LinkedList）
最新发布
2201_75685905的博客
07-24 852
在Java中，链表是一种基本的数据结构，用于按照线性方式存储数据集合。与数组不同，链表中的元素在内存中不是连续存储的，而是通过指针（或引用）连接在一起。动态大小：链表的大小可以根据需要动态增长或缩小，不需要像数组那样预先定义固定的大小。元素访问：链表不提供像数组一样的随机访问能力。访问链表中的元素通常需要从头开始遍历。插入和删除操作：在链表中插入或删除元素通常比数组更快，特别是对于不是在链表末尾的操作，因为不需要移动其他元素来腾出空间或填补空位。内存使用。
数据结构-链表(LingkedList)介绍和Java示例代码
07-01
链表是一种重要的线性数据结构，它与数组相比具有独特的特性和优势。链表由一系列节点构成，每个节点包含两部分：数据元素和指向下一个节点的引用。这种结构允许链表在内存中不连续分布，提供了动态扩展和收缩的能力...
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
Java数据结构是编程中至关重要的组成部分，它们定义了如何有效地存储和操作数据。在这个话题中，我们将重点关注两种常见的数据结构——链表和数组，并探讨它们如何被用来实现栈这一特定的抽象数据类型。 栈是一种...
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
Java链表
xiangsuixinsheng的专栏
06-11 7158
使用Java实现链表，首先定义链表的数据结构，也就是定义一个类，LinkedListNode。这个定义了链表的节点，链表节点分两部分，数据info和链接link。public class LinkedListNode {   public int info;   public LinkedListNode link;//这里就是链接，指向下一个节点的内存地址}link开始没看懂，怎么l
JAVA中的Linkedlist （链表）
KuzumiRin的博客
05-31 456
A linked data structure consists of capsules of data known as nodes that are connected via links, Links can be viewed as arrows and thought of as one way passages from one node to another. In Java, nodes are realized as objects of a node class. The data in
Java集合类--LinkedList
weixin_33881140的博客
10-14 2133
2019独角兽企业重金招聘Python工程师标准>>> ...
java集合系列之LinkList
weixin_30362233的博客
03-28 145
概要 第1部分 LinkedList介绍第2部分 LinkedList数据结构第3部分 LinkedList源码解析(基于JDK1.6.0_45)第5部分 LinkedList示例 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3308807.html 第1部分 LinkedList介绍 LinkedList简介 LinkedLis...
Java基础之LinkedList
qq_45344586的博客
04-09 1736
Java基础之LinkedList
Java集合之LinkedList
骑着猪猪去旅行的博客
10-30 2503
LinkedList是实现了List和Deque接口的双向链表，实现了所有可选列表的操作，允许存放所有元素（包括null）
Java LinkedList实现
baidu_28610773的博客
03-24 798
链表是由一个个节点连接在一起，这里就先创建一个节点类： package cn.mesie.dataStructure.list; public class Node<T> { /**新元素与链表结合节点**/ Node<T> next; /**新元素数据**/ T data; public Node() { } ...
Java集合之LinkedList详解
qq_39939541的博客
06-25 2311
例如containsAll、removeAll、retainAll等方法，这些方法可以被ArrayList直接继承和使用，从而避免了重复实现这些操作。同时，AbstractCollection也提供了一些抽象方法，例如size、iterator、toArray等方法，这些方法需要由具体的集合类去实现，LinkedList也需要实现这些方法以完成自身的功能。AbstractList是List接口的一个抽象实现，实现了List接口的大部分方法，包括添加、删除、获取元素、遍历等。
Java数据结构：链表定义与实现详解
本文档提供了一个关于Java中简单链表数据结构的详细教程，涵盖了链表的基本概念、工作原理以及如何在Java中实现链表。链表是一种动态数据结构，它的每个元素（节点）包含数据和一个指向下一个节点的引用。在链表中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值