数据结构和算法（二）--单向（循环）链表（LinkedList）

最新推荐文章于 2024-07-31 14:18:04 发布
最新推荐文章于 2024-07-31 14:18:04 发布
阅读量324 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 链表 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45405982/article/details/110792047
版权

数据结构和算法（二）–单向（循环）链表（LinkedList）

动态数组的缺点
  • 扩容和缩容时，会循环遍历所有元素，当数据量很大时，此操作会有一些效率问题
  • 再扩容和缩容之前会预留一部分空间，此空间是不存储内容的，而且数组长度越大预留的空间就会越多（按比例），会造成内存浪费
链表（是一种链式存储的线性表，内存地址不一定连续）
  • 链表本身有一个内部类表示一个一个的节点（Node），链表本身不存储数据，只是指向头节点
  • 节点是存储数据内容的真正的类，同时它也会指向下一个节点
  • 链表在进行添加操作时，会新建一个Node类来存储数据，并指向下一个节点，因此每一个节点的内存地址不一定是连续的
  • 通过控制节点的指针可以实现删除，改变顺序，增加等操作
    链表数据结构
链表方法设计思路
  1. getNode(int index)
    传入index，遍历此链表，返回一个node节点，这个方法是为了在链表内部可以快速找到任何index处的节点对象
  2. add(E element)
    调用add(E element,int index)方法，使用参数新建一个node节点获取到最后一个节点，并使最后一个节点的next指向新建的节点
  3. remove(int index)
    找到index-1处的节点，并使其next指向index+1处的节点，注意index==0时要特殊处理
  4. set(int index,E element)
    找到index处的节点，设置其element属性为传入的参数
  5. indexOf(E element)
    循环遍历每一个节点，使用equals判断，当传入是null时需要特殊处理
  6. clear()
    firstNode设置为null，size设置为0
代码实现（配合上面设计思路观看）
public class CustomLinkedList<E> implements CustomList<E> {

    private Node<E> firstNode; // 指向第一个节点

    private int size; // 表示链表长度

    public CustomLinkedList() {
        size = 0;
        firstNode = null;
    }

    /**
     * 内部类，表示每一个节点
     */
    private static class Node<E> {
        E element; // 存放数据的内容
        Node<E> next; // 指向下一个节点

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public void add(E element) {
        add(size,element);
    }

    @Override
    public E get(int index) {
        Node<E> node = getNode(index);
        return node.element;
    }

    @Override
    public E set(int index, E element) {
        E oldObj = get(index);
        getNode(index).element = element;
        return oldObj;
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new RuntimeException("索引越界错误");
        }
        if (index == 0){
            firstNode = new Node<E>(element, firstNode);
        }else {
            getNode(index - 1).next = new Node<E>(element, getNode(index - 1).next);
        }

        size++;
    }

    @Override
    public E remove(int index) {
        Object oldObj = get(index);
        if (index == 0){
            firstNode = firstNode.next;
        }else {
            getNode(index - 1).next = getNode(index).next;
        }
        size--;
        return (E) oldObj;
    }

    @Override
    public int indexOf(E element) {
        Node<E> node = this.firstNode;
        for (int i = 0; i < size; i++) {
            if (element == node.element){
                return i;
            }else if (element != null && element.equals(node.element)) {
                return i;
            }
            node = node.next;
        }
        return -1;
    }

    @Override
    public void clear() {
        size = 0;
        firstNode = null;
    }


    private Node<E> getNode(int index) {
        checkIndex(index);
        Node<E> node = this.firstNode;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }


    private void checkIndex(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界错误");
        }
    }

    @Override
    public String toString() {
        Node<E> node = this.firstNode;
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < size; i++) {
            if (i == 0) {
                stringBuilder.append("[");
            } else {
                stringBuilder.append(",");
            }
            stringBuilder.append(node.element);
            node = node.next;
        }
        stringBuilder.append("]").append(" ==> 链表长度为：").append(size);
        return stringBuilder.toString();
    }
}
时间复杂度分析
  1. add(int index, E element)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  2. get(int index)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  3. set(int index, E element)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  4. remove(int index)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  5. indexOf(E element)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
链表改造（不推荐）
  • 增加虚拟头节点，可以统一处理节点逻辑
    增加虚拟头节点
练习
1. 传入一个节点对象，删除一个节点
  • 链接：https://leetcode-cn.com/problems/delete-node-in-a-linked-list/
  • 思路：获取传入节点的下一个节点的element，覆盖掉传入节点的element，并使传入节点的next指向下一个节点的下一个节点
  • 代码实现：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}
2. 反转链表
  • 链接：https://leetcode-cn.com/problems/reverse-linked-list/
  • 思路1：递归执行，先保存head的值，后面的值往前一个节点移动，再把最后一个节点的值变为保存的值
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode fir = head;
        if(head != null){
            if(head.next != null){
                reverseList(head.next);
            }
            int a = head.val;
            while (head.next != null){
                head.val = head.next.val;
                head = head.next;
            }
            head.val = a;
        }
        return fir;
    }
}
  • 思路2：递归执行，变换指针，把节点看成一个一个的个体，别管执行过程中一个节点有多个指针指向的问题，关键是最后返回一个newHead（如果想返回原来的head会变得更复杂）
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next==null)return head;
        ListNode node = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return node;
    }
}
  • 思路3：迭代执行，创建临时遍历存储head的下一个节点，遍历每一个节点，先使当前节点的next指向newHead，再让newHead指向当前节点，再把当前节点指向零时存储的下一个节点
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode temp = null;
        ListNode now = head;
        ListNode newHead = null;
        while (now !=null ){
            temp = now.next;
            now.next = newHead;
            newHead = now;
            now = temp;
        }
        return newHead;
    }
}
3. 判断链表是否有环
  • 链接：https://leetcode-cn.com/problems/linked-list-cycle/
  • 思路：快慢指针
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) return false;
        ListNode fast = head.next;
        ListNode low = head;
        while (fast != null) {
            low = low.next;
            if(fast.next ==  null){
                return false;
            }
            fast = fast.next.next;
            if (low == fast){
                return true;
            }
        }
        return false;
    }
}
单向循环链表
  • 单向循环链表和单向链表的区别就是，在尾节点的next原本指向的是null，现在指向的是firstNode
循环链表实现思路分析
  1. 其中大部分方法和单向链表相同，只有增加或者删除的时候需要注意设置最后一个节点的next属性
  2. add(int index,E element)
    往index==0处添加节点时需要注意，先把最后一个节点找出来，然后添加新节点到0处，firstNode指向它，再把之前的最后一个节点指向firstNode节点。其中需要注意的是，要先查询出最后一个节点才能改变firstNode的值。
  3. remove(int index)
    对index==0处的节点进行删除操作时，先把最后一个节点查出来，然后把firstNode指向下一个节点，再把最后一个节点指向现在的firstNode。注意，查询最后一个节点必须要再移动firstNode之前，因为查询是传入的是size-1，而移动了firstNode之后size没有马上-1从而造成索引越界。
代码实现（重点看add和remove方法和原来的有什么区别）
/**
 * 单向循环链表
 * @author maolin yuan
 * @version 1.0
 * @date 2020/12/17 17:10
 */
public class CustomCircleLinkedList<E> implements CustomList<E>{

    private Node<E> firstNode; // 指向第一个节点

    private int size; // 表示链表长度

    public CustomCircleLinkedList() {
        size = 0;
        firstNode = null;
    }

    /**
     * 内部类，表示每一个节点
     */
    private static class Node<E> {
        E element; // 存放数据的内容
        Node<E> next; // 指向下一个节点

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "element=" + element +
                    ", next=" + next.element +
                    '}';
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public void add(E element) {
        add(size,element);
    }

    @Override
    public E get(int index) {
        Node<E> node = getNode(index);
        return node.element;
    }

    @Override
    public E set(int index, E element) {
        E oldObj = get(index);
        getNode(index).element = element;
        return oldObj;
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new RuntimeException("索引越界错误");
        }
        if (index == 0){
            if (size ==0){
                firstNode = new Node<E>(element, firstNode);
                firstNode.next = firstNode;
            }else {
                Node<E> node = getNode(size - 1);
                firstNode = new Node<E>(element, firstNode);
                node.next = firstNode;
            }
        }else {
            getNode(index - 1).next = new Node<E>(element, getNode(index - 1).next);
        }

        size++;
    }

    @Override
    public E remove(int index) {
        Object oldObj = get(index);
        if (index == 0){
            Node<E> node = getNode(size - 1);
            firstNode = firstNode.next;
            node.next = firstNode;

        }else {
            getNode(index - 1).next = getNode(index).next;
        }
        size--;
        return (E) oldObj;
    }

    @Override
    public int indexOf(E element) {
        Node<E> node = this.firstNode;
        for (int i = 0; i < size; i++) {
            if (element == node.element){
                return i;
            }else if (element != null && element.equals(node.element)) {
                return i;
            }
            node = node.next;
        }
        return -1;
    }

    @Override
    public void clear() {
        size = 0;
        firstNode = null;
    }


    private Node<E> getNode(int index) {
        checkIndex(index);
        Node<E> node = this.firstNode;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }


    private void checkIndex(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界错误");
        }
    }

    @Override
    public String toString() {
        Node<E> node = this.firstNode;
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < size; i++) {
            if (i == 0) {
                stringBuilder.append("[");
            } else {
                stringBuilder.append(",");
            }
            stringBuilder.append(node);
            node = node.next;
        }
        stringBuilder.append("]").append(" ==> 链表长度为：").append(size);
        return stringBuilder.toString();
    }
}
maolinyuan
关注
专栏目录
算法基础：排序基础：分区算法之单向循环法
知行合一 止于至善
10-29 1737
前一篇文章中介绍了快排的核心分区算法的双向循环法的实现，分区算法将待排序列根据基准值进行分区，形成整体有序局部无序的结果特征，加之每次执行都会使序列中的基准值就位，非常简洁和有效。双向循环虽然理解简单，但是实现稍微繁琐（虽然之后十来行，但是毕竟是经典算法，还是可以利用别的方式进一步的简化），这篇文章继续介绍一下另外一种方式：单向循环法。
数据结构与算法(C语言)------单向链表2
weixin_44912879的博客
04-01 194
#ifndef __LINKEDLIST_H #define __LINKEDLIST_H #include <stdio.h> #include <stdlib.h> #include <string.h> #define OK 1 #define ERROR 0 typedef int states; typedef int ElementType; /** 链表结点以及表头结构 */ typedef struct node{ ElementType
反转链表
诺小刀
09-12 207
反转链表1.反转链表题目过程2.代码实现（js） 1.反转链表 题目 过程 初始阶段：head为一个链表名，head指向链表的头节点，pre指向头节点的前一个节点，curr也指向头节点。 第一步：新命名一个next节点，让next指向第二个节点，即next = curr_next(curr_next指的是curr的后一个节点)； 第二步：让curr_next节点指向pre，即curr_next= pre； 第三步：让pre指向curr节点，即pre = curr； 第四步：让curr指向下一个节点，即c
《知识点020：Java中LinkedList遍历（7种）》
最新发布
大大大钢琴
07-31 503
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.，它和ArrayList一样实现了List接口，但是她执行插入和删除操作时比ArrayList更加高效，因为她是基于链表的，但同时也决定了她在随机访问方面要比ArrayList弱一点。
数据结构系列学习（四） - 单向循环链表(Circular Linked List)
曾铎的博客
11-07 3136
数据结构学习目录：数据结构系列学习(一) - An Introduction to Data Structure数据结构系列学习（二） - 顺序表（Contiguous_List） 数据结构系列学习（三） - 单链表(Linked_List)在上一篇文章中我们学习并使用C语言对不带头节点的单链表进行了实现，在这篇文章中我们将对另一种的链式存储结构——循环链表中的单向循环链表进行学习并使用代码实现。作为链式存储的另一种存储结构——循环链表，我们首先应该明确的是，单向循环链表和普通的单链表有什么区别？我们用两张
单链表，单向循环链表与双向循环链表（LinkedList）实现
MJ6666666的博客
01-17 722
动态链表 为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息（即直接后继的存储位置）我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称作指针或链。这两部分信息组成数据元素ai的存储映像，称为结点（Node） 头结点和头指针 头结点是指链表中的第一个结点，有真实头结点和虚拟头结点之分 真实头结点：其第一个结点用于存储数据 虚拟头结点：其第一个结点不许存储数据 头指针：仅仅
力扣：设计链表（单双链表实现）
K_CRACKING的博客
08-28 343
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一
数据结构与算法--双向链表(Double Linked List)、单向环形链表(Circular Linked List)
ZZay's
01-22 1419
此文章仅作为自己学习过程中的记录和总结，同时会有意地去用英文来做笔记，一些术语的英译不太准确，内容如有错漏也请多指教，谢谢！ 一、双向链表-概述 -双向链表的基本组成结构： Node：自定义的结点结构。 (Node) head：指向单链表头结点的“头指针”。 -自定义结点的基本组成结构： 数据域：存放具有实际意义的数据。 “指针”域(next)：存放一个指向下一结点的“指针”。 “指针”域(pre)：存放一个指向上一结点的“指针”。【与单链表的区别】 -优点： 遍历方向：单链表只能朝向一个方向
list-2_单链表_speakgfp_数据结构_循环链表_
10-02
在实际应用中，链表数据结构广泛用于各种场景，例如内存管理、数据库索引和图形算法等。理解并能熟练运用链表的不同变体是提升编程技能的重要组成部分。在这个项目中，通过实现和测试单链表、单向循环链表和双向循环...
链表-使用Python实现链表数据结构.zip
03-13
链表有多种变体，如单向链表、双向链表和循环链表。单向链表只能向前移动，而双向链表允许向前和向后移动。循环链表的最后一个节点指回列表的开头，形成一个环。 Python的内置数据结构如列表（list）已经实现了高效...
数据结构-单链表(Linked List)
Q75999的博客
01-02 346
#include <stdio.h> #include <stdlib.h> #define LIST_INIT_SIZE 10 #define LISTINCREMENT 100 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEAS...
链表(LinkedList)-单向环形链表
qq_30657195的博客
06-02 419
3.单向环形链表的应用场景 Josephu问题（丢手帕问题） 设编号为1，2，…，n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，以此类推，直到所有人出列为止，由此产生一个出队编号的序列。 提示： 用一个不带头结点的循环链表来处理josephu问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表
JAVA数据结构LinkedListSinglyCircular(单向循环链表)以及约瑟夫环的实现
sl1130398099的博客
03-30 395
package p02.动态链表; import p01.动态数组.List; public class LinkedListSinglyCircular<E> implements List<E>{ //单向循环链表 private Node head; //头指针 private Node rear; //尾指针 private int size; //元素个...
【数据结构】顺序表（三）：链表 之 单向循环链表
宫瑞阳的博客
07-27 351
单向循环链表的 概念、原理、源码
[042] 环形链表（Circle Single Linked List）和“约瑟夫（Josephu）问题”
yhxxhy978的博客
09-17 136
1、约瑟夫问题（丢手绢问题）： N个小孩围成一个圈，标号为1到N； 从编号为m的小孩开始报数，报到第k(1 <= k <= n)个小孩时，该小孩退出游戏； 然后下一个小孩继续从1开始报数，数到第k个小孩时，该小孩退出游戏； 如此循环，剩下最后一个小孩是胜利者。 2、JAVA代码 package DataStructures.LinkedList; /** * @author yhx * @date 2020/09/16 */ public class Josephu {
循环单链表(CircularLinkedList) 实现
TDC的专栏
07-12 303
/* 循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。循环链表的操作和单链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。 */ namespace DataStructure { public class CircularLinkedList { ListNode head; pub...
java连续循环_Java中的循环LinkedList
weixin_39847556的博客
02-27 317
小编典典如果您有一个循环链表，则每个节点都指向连续循环中的下一个节点。因此，没有最后也没有第一。在这种情况下，您只需要将一个指针指向数据结构(该问题称为“当前”)，因为您可以遍历整个列表，直到返回起点为止。一个节点可能看起来像这样：public class ListNode {private T element;private ListNode next;}因此，在这种环境下，当您将第一个节点添加...
《Java基础-集合：深入了解Java中LinkedList类的使用及实用技巧（最全篇）》
大大大钢琴
07-31 977
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.，它和ArrayList一样实现了List接口，但是她执行插入和删除操作时比ArrayList更加高效，因为她是基于链表的，但同时也决定了她在随机访问方面要比ArrayList弱一点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值