链表的java实现（单向、双向链表，单向链表的反转）

最新推荐文章于 2023-10-22 11:51:43 发布
最新推荐文章于 2023-10-22 11:51:43 发布
阅读量510 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 链表 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45801177/article/details/113955585
版权
本文深入探讨了链表的存储结构，特别是单向链表和双向链表。详细介绍了它们的API设计、代码实现及复杂度分析。通过示例展示了如何创建链表节点、插入、删除、查询元素，以及链表反转的操作。链表在增删操作上的高效性使其成为数据结构中的重要组成部分。
摘要由CSDN通过智能技术生成

链表

链表

虽然顺序表的查询很快，时间复杂度为O(1),但是增删的效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢？有，我们可以使用另外一种存储结构实现线性表，链式存储结构。
链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成，结点可以在运行时动态生成。
在这里插入图片描述
按照面向对象的思想，我们可以设计一个类，来描述结点这个事物，用一个属性描述这个结点存储的元素，用来另外一个属性描述这个结点的下一个结点。

类名Node
构造方法Node(T t,Node next)：创建Node对象
成员变量T item:存储数据
Node next：指向下一个结点

结点类实现：

public class Node<T> {
    //存储元素
    public T item;
    //下一个元素的地址
    public Node next;
    
    public Node (T item,Node next){
        this.item = item;
        this.next = next;
    }
}

生成链表：

public static void main(String[] args) throws Exception{
        //构建结点
        Node<Integer> first = new Node<>(11,null);
        Node<Integer> second = new Node<>(13,null);
        Node<Integer> third = new Node<>(12,null);
        Node<Integer> forth = new Node<>(7,null);
        Node<Integer> fifth = new Node<>(8,null);
        //生成链表
        first.next = second;
        second.next = third; 
        third.next = forth; 
        forth.next = fifth;
    }

单向链表

单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。
在这里插入图片描述

单向链表API设计

类名LinkList
构造方法LinkList()：创建LinkList对象
成员方法1.public void clear()：空置线性表
2.publicboolean isEmpty()：判断线性表是否为空，是返回true，否返回false
3.public int length():获取线性表中元素的个数
4.public T get(int i):读取并返回线性表中的第i个元素的值
5.public void insert(T t)：往线性表中添加一个元素；
6.public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。
7.public T remove(int i):删除并返回线性表中第i个数据元素。
8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
成员内部类private class Node:结点类
成员变量1.private Node head:记录首结点
2.private int N:记录链表的长度

单向链表代码实现

单向链表类：

import java.util.Iterator;

public class LinkList<T> implements Iterable<T> {
    //头节点
    private Node head;
    //链表长度
    private int N;

    public LinkList(){
        //初始化
        head = new Node(null,null);
        N = 0;
    }

    //清空链表
    public void clear(){
        head.next = null;
        head.item = null;
        N = 0;
    }

    //判断是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    //获取元素个数
    public int length(){
        return N;
    }

    //获取第i个元素
    public T get(int i){
        if (i < 0 || i >= N){
            throw new RuntimeException("位置不合法");
        }
        Node n = head.next;
        for (int index = 0;index < i;index++){
            n = n.next;
        }
        return n.item;
    }

    //添加一个元素
    public void insert(T t){
        //找到最后一个节点
        Node n = head;
        while (n.next != null){
            n = n.next;
        }
        Node newOne = new Node(t,null);
        n.next = newOne;
        //链表长度++
        N++;
    }

    //在i位置添加一个元素
    public void insert(int i,T t){
        if (i<0||i>=N){
            throw new RuntimeException("位置不合法！");
        }

        //寻找i位置之前的节点
        Node pre = head;
        for (int j = 0; j <= i-1; j++) {
            pre = pre.next;
        }
        //找到位置i的节点
        Node curr = pre.next;
        //构建新节点，让新节点指向i节点
        Node newNode = new Node(t,curr);

        //让i位置之前的节点指向这个节点
        pre.next = newNode;
        //链表长度++
        N++;
    }

    //删除并返回第i个位置的元素
    public T delete(int i){
        if (i<0||i>=N){
            throw new RuntimeException("位置不合法！");
        }
        //寻找i之前的元素
        Node pre = head;
        for (int index = 0; index <=i-1; index++) {
            pre = pre.next;
        }
        //当前i位置的结点
        Node curr = pre.next;

        //前一个结点指向下一个结点，删除当前结点
        pre.next = curr.next;

        //长度-1
        N--;
        return curr.item;
    }

    //返回链表中首次出现指定元素的序号，弱不存在返回-1
    public int indexOf(T t){
        Node n = head;
        for (int i = 0;n.next!=null;i++){
            n = n.next;
            if (n.item.equals(t)){
                return i;
            }
        }
        return -1; }

    //节点类
    private class Node{
        //存储数据
        T item;
        //下个结点
        Node next;

        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
    }

    @Override
    public Iterator iterator() {
        return new LIterator();
    }
    
    private class LIterator implements Iterator<T>{
        private Node n;
        
        public LIterator(){
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public T next() {
            n = n.next;
            return n.item;
        }
    }
}

测试类：

public class LinkListTest {
    public static void main(String[] args) throws Exception{

        LinkList<Integer> list = new LinkList<>();
        System.out.println(list.length());
        list.insert(0,1);
        list.insert(1,2);
        list.insert(2,3);
        list.insert(3,4);
        list.insert(4,5);

        //测试length方法
        for (int i : list) {
            System.out.println(i);
        }
        System.out.println(list.length());
        System.out.println("-------------------");

        //测试get方法
        System.out.println(list.get(2));
        System.out.println("------------------------");

        //测试remove方法
        int remove = list.remove(1);
        System.out.println(remove);
        System.out.println(list.length());
        System.out.println("----------------");
        for (int i : list) { System.out.println(i); }
    }
}

0
1
2
3
4
5
5
---------------
3
---------------
2
4
---------------
1
3
4
5

双向链表

双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。
在这里插入图片描述

结点API设计

类名Node
构造方法Node(T t,Node pre,Node next)：创建Node对象
成员变量T item:存储数据
Node next：指向下一个结点
Node pre:指向上一个结点

双向链表API设计

类名TowWayLinkList
构造方法TowWayLinkList()：创建TowWayLinkList对象
成员方法1.public void clear()：空置线性表
2.publicboolean isEmpty()：判断线性表是否为空，是返回true，否返回false
3.public int length():获取线性表中元素的个数
4.public T get(int i):读取并返回线性表中的第i个元素的值
5.public void insert(T t)：往线性表中添加一个元素；
6.public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。
7.public T remove(int i):删除并返回线性表中第i个数据元素。
8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
9.public T getFirst():获取第一个元素
10.public T getLast():获取最后一个元素
成员内部类private class Node:结点类
成员变量1.private Node first:记录首结点
2.private Node last:记录尾结点
2.private int N:记录链表的长度

双向链表代码实现

双向链表类：

import java.util.Iterator;

public class TwoWayLinkList<T> implements Iterable<T> {
    //结点类
    private class Node{
        public Node(T item, Node pre, Node next){
            this.item = item;
            this.pre = pre;
            this.next = next;
        }

        //存储数据
        private T item;
        //存储上一个结点
        private Node pre;
        //存储下一个节点
        private Node next;
    }

    //首结点
    private Node head;
    //尾结点
    private Node last;
    //链表长度
    private int N;

    //构造方法
    public TwoWayLinkList(){
        last = null;
        head = new Node(null,null,null);
        N = 0;
    }

    //清空链表
    public void clear(){
        N = 0;
        last = null;
        head.next = last;
        head.pre = null;
        head.item = null;
    }

    //判断是否为空
    public boolean isEmpty(){
        return N==0;
    }

    //获取元素个数
    public int length(){
        return N;
    }

    //获取位置i的元素值
    public T get(int i){
        if (i<0 || i>= N){
            throw new RuntimeException("位置不合法");
        }
        Node curr = head.next;
        for (int j = 0; j < i; j++) {
            curr = curr.next;
        }
        return curr.item;
    }

    //添加一个元素在末尾
    public void insert(T t){
        if(last == null){
            last = new Node(t,head,null);
            head.next = last;
        }else{
            Node oldlast = last;
            Node node = new Node(t,oldlast,null);
            oldlast.next = node;
            last = node;
        }
        N++;
    }

    //在i位置添加一个元素
    public void insert(int i, T t){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }

        //找到i位置的前一个结点
        Node pre = head;
        for (int index=0; index < i;index++){
            pre = pre.next;
        }

        //设置当前结点
        Node curr = pre.next;
        //构建这个结点
        Node newNode = new Node(t,pre,curr);
        curr.pre = newNode;
        pre.next = newNode;
        //长度++
        N++;
    }

    //删除并返回第i个元素
    public T remove(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }
        //找到前一个结点
        Node pre = head;
        for (int index=0; index < i;index++){
            pre = pre.next;
        }
        //设置当前结点
        Node curr = pre.next;
        //找到后一个结点
        Node curr_next = curr.next;

        pre.next = curr_next;
        curr_next.pre = pre;
        N--;
        return curr.item;
    }

    //返回表中某元素首次出现的index，如果不存在就返回-1
    public int indexOf(T t){
        Node n = head;
        for (int i = 0; n.next != null ; i++) {
            n = n.next;
            if (n.next.equals(t)){
                return i;
            }
        }
        return -1;
    }

    //获取第一个元素
    public T getFirst(){
        if (isEmpty()){
            return null;
        }
        return head.next.item;
    }

    //获取最后一个元素
    public T getLast(){
        if (isEmpty()){
            return null;
        }
        return last.item;
    }

    @Override
    public Iterator<T> iterator() {
        return new TIterator();
    }

    private class TIterator implements Iterator{
        private Node n =head;

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}

Test类：

public class TwoWayLinkListTest {
    public static void main(String[] args) throws Exception{

        TwoWayLinkList<Integer> list = new TwoWayLinkList<>();
        System.out.println(list.length());
        list.insert(0,1);
        list.insert(1,2);
        list.insert(2,3);
        list.insert(3,4);
        list.insert(4,5);

        //测试length方法
        for (int i : list) {
            System.out.println(i);
        }
        System.out.println(list.length());
        System.out.println("-------------------");

        //测试get方法
        System.out.println(list.get(2));
        System.out.println("------------------------");

        //测试remove方法
        int remove = list.remove(1);
        System.out.println(remove);
        System.out.println(list.length());
        System.out.println("----------------");
        for (int i : list) { System.out.println(i); }
    }
}

0
1
2
3
4
5
5
---------------
3
---------------
2
4
---------------
1
3
4
5

链表的复杂度分析

  • get(int i):每一次查询，都需要从链表的头部开始，依次向后查找，随着数据元素N的增多，比较的元素越多，时间复杂度为O(n)
  • insert(int i,T t):每一次插入，需要先找到i位置的前一个元素，然后完成插入操作，随着数据元素N的增多，查找的元素越多，时间复杂度为O(n);
  • remove(int i):每一次移除，需要先找到i位置的前一个元素，然后完成插入操作，随着数据元素N的增多，查找的元素越多，时间复杂度为O(n)

相比较顺序表，链表插入和删除的时间复杂度虽然一样，但仍然有很大的优势，因为链表的物理地址是不连续的，它不需要预先指定存储空间大小，或者在存储过程中涉及到扩容等操作,同时它并没有涉及的元素的交换。

相比较顺序表，链表的查询操作性能会比较低。因此，如果我们的程序中查询操作比较多，建议使用顺序表，增删操作比较多，建议使用链表。

链表反转

单链表的反转是非常经典的一个题目。需求非常明确：将链表中的元素按照相反的顺序排列。

  • API设计：
  1. public void reverse()：对整个链表反转 public Node
  2. reverse(Node curr)：反转链表中的某个结点curr,并把反转后的curr结点返回

使用递归可以完成反转，递归反转其实就是从原链表的第一个存数据的结点开始，依次递归调用反转每一个结点，直到把最后一个结点反转完毕，整个链表就反转完毕。

在这里插入图片描述

  • 代码实现
//单链表的反转
public void reverse(){
    //判断当前链表是不是空链表，如果是则结束，如果不是则调用重载的reverse方法完成反转
    if (isEmpty()){
        return;
    }
    reverse(head.next);
}

//反转指定节点curr并返回指定节点
public Node reverse(Node curr){
    if (curr.next==null){
        head.next = curr;
        return curr;
    }
    //递归地反转当前节点curr的下一个节点,返回值就是链表反转后当前节点的上一个节点
    Node pre = reverse(curr.next);
    //让返回的节点的下一个节点变为curr
    pre.next = curr;
    //把当前节点的下一个节点变为null
    curr.next = null;

    return curr;
}

Test:

public class ReverseLinkListTest {
    public static void main(String[] args) throws Exception{

        LinkList<Integer> list = new LinkList<>();
        list.insert(1);
        list.insert(2);
        list.insert(3);
        list.insert(4);
        list.insert(5);

        for (Integer i : list){
            System.out.println(i+' ');
        }
        System.out.println("--------------");
        list.reverse();
        for (Integer i : list){
            System.out.println(i+' ');
        }
    }
}

33
34
35
36
37
--------------
37
36
35
34
33
枸杞仙人
关注
专栏目录
【java】Java实现单向链表反转
九师兄
06-04 256
1.概述 转载：https://www.jb51.net/article/136185.htm 遇到了这个问题，记录一下 2.案例1 2.1 实现思路 递归：从尾部开始处理 非递归：从头部开始处理 2.2 实现 package com.algorithm.common.link.reverse; /** * @author: chuanchuan.lcc * @date: 2021-06-03 22:50 * @modifiedBy: chuanchuan.lcc * @version: 1.
JAVA双向链表反转实现
06-10
通过java实现的双向链表，及反转功能，可能对面试有用哦
Java：双向链表反转实现
weixin_34245169的博客
04-21 836
有个小需求要求实现一个双向链表的反转于是就有了下边代码： 链表元素结构定义： package com.util; public class LinkedNode&lt;T&gt;{ private T value; private LinkedNode&lt;T&gt; prev; private LinkedNode&lt;T&gt; next; ...
java 单向链表 双向链表_java实现单链表、双向链表
weixin_28912017的博客
02-19 258
本文实例为大家分享了java实现单链表、双向链表的相关代码，供大家参考，具体内容如下java实现单链表：package code;class Node{Node next;int data;public Node(int data){this.data=data;}}class LinkList{Node first;//头部public LinkList(){this.first=null;}p...
java实现双向链表+链表反转
nojie1的博客
07-06 364
双向链表通过java实现
Java之链表的反转
timewilltell12的博客
03-24 5260
主要使用递归的思想完成完成反转，递归反转其实就是从原链表的第一个存数据的结点开始，依次递归调用反转每一个结点，直到把最后一个结点反转完毕，整个链表就反转完毕。
Java实现单向链表反转
08-27
Java实现单向链表反转 Java实现单向链表反转是指将单向链表的顺序颠倒，例如原链表为A->B->C->D->E->F，反转后变为F->E->D->C->B->A。这种操作在实际开发中非常有用，例如在数据处理、数据分析等领域。 单向链表...
Java实现单向链表反转示例
技术小青年一枚
02-15 2759
例如有一单向链表 54-&gt;30-&gt;37-&gt;61-&gt;1-&gt;60-&gt;25-&gt;76-&gt;60-&gt;95 原链表头节点54，尾节点：95 实现效果： 95-&gt;60-&gt;76-&gt;25-&gt;60-&gt;1-&gt;61-&gt;37-&gt;30-&gt;54 新链表头节点95，尾节点54 实现原理： 从头
python实现反转部分单向链表
12-24
给定一个单链表的头指针 head， 以及两个整数 a 和 b，在单链表中反转 linked_list[a-b] 的结点，然后返回整个链表的头指针。 例如： 单链表[1000, 5, 12, 100, 45, ‘cecil’, 999]， a = 4， b = 6， 返回的...
反转链表(java)
最新发布
ye_zo的博客
10-22 645
反转链表 ListNode nextTemp = curr.next; //5 curr.next = prev; // 6 prev = curr; //7 curr = nextTemp; //8
Java - 反转链表
分数没二舅血压高
12-06 5950
算法基础-反转链表
Java实现链表反转
Happy_wu的专栏
07-14 756
一直以来习惯了些算法用C++，换java反而不会写了。今天感觉算是找回来了。 要反转的链表结构： package reverce; //要逆转的链表 /* * Java实现链表翻转 * author:wyr * 2016-7-14 */ public class Node { private String data; private Node next; public Str
Java反转链表
weixin_45395062的博客
06-10 311
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 限制： 0 <= 节点个数 <= 5000 leetCode 剑指Offer24.反转链表 public class Main { static class ListNode{ int val; ListNode ne
Java链表反转
卑微程序猿的野心和梦想
03-15 333
题目描述 输入一个链表，反转链表后，输出新链表的表头。 输入：{1,2,3} 输出：{3,2,1} 输入输出的形式我们不用考虑，主要是实现链表反转的算法。 首先，为什么引入tmp呢，因为当head的next指向newHead的时候，head跟2就断开了。。。所以我们需要一个临时节点tmp。 以上是第一步，tmp指向head.next 第二步，head.next 指向 newHead 第三步，newHead指向head 第四步 ，head指向tmp 然后 tmp指向head.next 进行迭代。。。
Java 链表反转
尚未佩妥剑 转眼便江湖
12-05 261
单链表是一种常见的数据结构，由一个个节点通过指针方式连接而成，每个节点由两部分组成：一是数据域，用于存储节点数据。二是指针域，用于存储下一个节点的地址。 单链表反转，就是把每个节点的指针域由原来的指向下一个节点变为指向其前一个节点。但由于单链表没有指向前一个节点的指针域，因此我们需要增加一个指向前一个节点的指针pre，用于存储每一个节点的前一个节点。此外，还需要定义一个保存当前节点的指针cur，以及下一个节点的next。定义好这三个指针后，遍历单链表，将当前节点的指针域指向前一个节点，之后将定义三个指.
java链表的反转
m566666的博客
12-06 1517
链表的反转思想其实就是交换，定义两个游标分别为left和right， right指向链表头指针的下一个目的是当反转链表时断开链表时可以找到下一个链表的头，left指向链表头指针的前一个目的是反转链表时可以找到要反转的那个一个节点。 说一下顺序： 1）先让right指向head的下一个节点 2）再让头指针指向的那个节点反转到left节点上，此时节点left指向的是head的前一个节点 3）再让left节点指向头结点的位置 ...
java反转链表
qq_43018213的博客
07-23 467
java反转链表 关于单链表的基本定义以及操作参考java单链表的基本增删改查的实现 反转机制与实现 设置反转节点，相当于单链表中的头结点。 HeroNode reverseHead = new HeroNode(0, "", "");//设置的反转头结点 遍历整个链表，从头到尾，每遍历一个节点，都放在reverseHead的最前端。 while(cur != null) { nex...
java—链表反转
yurong33333的博客
11-23 368
关键代码块 private void reverseMyList(Node currentNode) { Node tmpNode=null; if(current==null||current.next==null){ return ; } while(current....
链表反转(Java)
qq_54802338的博客
04-18 3445
基本思想： 反转入口从head.next开始，通过递归，如果当前结点有下一个结点，就递归调用反转函数，直到到最后一个结点时，让头结点指向这个结点。其他的结点：让后一个结点指向前一个结点 代码： //用于反转整个链表 public void reverse(){ if (isEmpty()){ return; } reverse(head.next); } //反转每一个结点,参数curr是当前被反转的
C语言链表反转实现详解及示例
对于单向链表，我们可以利用两个指针，一个用于遍历当前节点，另一个用于存储下一个节点的位置，从而实现节点的反转。 **链表反转的基本步骤：** 1. **定义结构体和指针类型**： 定义一个`struct_node`结构体，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值