链表---数据结构-黑马

最新推荐文章于 2024-08-26 23:12:47 发布
最新推荐文章于 2024-08-26 23:12:47 发布
阅读量1k 收藏 33
点赞数 29
文章标签： 数据结构 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49326024/article/details/141174390
版权

链表

定义

链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上是不连续的。

分类

  • 单向链表，每个元素只知道自己的下一个元素是谁。
    在这里插入图片描述
  • 双向链表，每个元素知道自己的上一个元素和下一个元素。
    在这里插入图片描述
  • 循环链表，通常链表尾部节点 tail 指向的为null，而循环链表的tail指向链表的头部节点 head。
    在这里插入图片描述

链表中还有一种特殊的节点称之为，哨兵(Sentinel)节点，也称之为 哑元(Dummy)节点， 不存储数据，一般作为头尾，简化边界判断，如下如所示。
在这里插入图片描述

性能

随机访问

根据 i n d e x index index 查询，时间复杂度为 O ( n ) O(n) O(n) 。

插入或删除

  • 起始位置，时间复杂度为， O ( 1 ) O(1) O(1)
  • 结束位置，若已知尾部节点 tail ，时间复杂度为， O ( 1 ) O(1) O(1) ；否则为 O ( n ) O(n) O(n)
  • 中间位置，根据 index 查找的时间复杂度 + O ( 1 ) O(1) O(1)

单项链表实现

方法实现

节点类、头部添加、循环遍历、尾部添加

// 单项链表
public class SinglyLinkedList implements Iterable<Integer>() {
    
    private Node head = null;  // 头指针
    
    // 节点类
    private static class Node() {
        int value;  // 值
        Node node;  // 下一个节点
        
        public Node(int value, Node node) {
            this.value = value;
            this.node = node;
        }
    }
    
    @Override
    public Iterator<Integer> iterator() {
        // 匿名内部类 -> 带名字的内部类
        return new NodeIterator();
    }
    
    // 1.链表头部添加元素
    public void addFirst(int value) {
        // 1.当链表为空时
        // head = new Node(value, null);  因为 head = new Node(value, head);这行代码可以处理链表为空的情况，则注释
        // 2.当链表非空时
        head = new Node(value, head);
    }
    
    // 寻找最后一个节点
    private Node findLast() {
        // 链表为空
        if (head == null) {
            return null;
        }
        Node p;
        for(p = head; p.next != null; p = p.next) {
            
        }
        return p;
    }
    
    // 3.尾部添加元素
    private void addLast(int value) {
        Node last = findLast();
        if (last == null) {
            // 头部添加
            addFirst(value);
            return;
        }
        last.next = new Node(value, null);
    }
    
    // 4.根据索引值查找结点
    public Node findNode(int index) {
        int i = 0;
        for(Node p = head; p != null; p = p.next, i++) {
            if (index == i) {
                return p;
            }
        }
        // 未找到
        return null;
    }
    
    // 5.根据index找到对应节点，并返回节点值
    public int get(int index) {
        Node p = findNode(index);
        if (p == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index))；
        }
        return p.value;
    }
    
    // 6.向索引位置插入元素
    public void insert(int index, int value) {
        if (index == 0) {  // 索引为0，向链表头部添加
            addFirst(value);
            return;
        }
        // 1.找到插入索引位置的上一个节点
        Node p = findNode(index - 1);
        // 判断p节点是否为空
        if (p == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node n = p.next;
        // p存在的情况
        p.next = new Node(value, n);
    }
    
    // 7.删除头部节点
    public void removeFirst() {
        if (head == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        // 头节点的下一个节点赋给头
        head = head.next;
    }
    
    // 8.按索引位置删除节点
    public void remove (int index) {
        if (index == 0) {
            removeFirst();
            return;
        }
        Node p = findNode(index - 1);  // 找到待删除节点的上一个节点
        if (p == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node n = p.next;               // 待删除节点
        if (n == null) {
            // 未找到待删除节点
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        p.next = n.next;			   // 待删除节点的上一个节点p的next指向待删除结点的下一个节点
    }
    
    // 6.遍历链表，方法1
    public void loop1(Consumer<Integer> consumer) {
        Node p = head; // 头节点赋给p
        while (p != null) {
            consumer.accept(p.value);
            p = p.next;
        }
    }
    // 循环遍历，方法2
    public void loop2(Consumer<Integer> consumer) {
        for(Node p = head; p != null; p = p.next) {
            consumer.accept(p.value);
        }
    }
    
    // 遍历，方法3，使用迭代器，实现接口Iterable
    public class NodeIterator implements Iterator<Integer> {
        Node p = head;
        
        @Override
        public boolean hasNext() {  //判断是否有下一个元素
            return p != null;
        }

        @Override
        public Integer next() {     //返回当前节点值
            int value = p.value;
            p = p.next;
            return value;      
        }
    }
}

测试

public class TestSinglyLinkedList() {
	
    // 尾部添加, 根据索引查找对应节点值测试
    @Test
    public void test3() {
        SinglyLinkedList list = new SinglyLinkedList();
        list.addLast(1);
        list.addLast(2);
        list.addLast(3);
        list.addLast(4);
        
        // Assertions.assertIterableEquals(List.of(1, 2, 3, 4), list);
        
        int i = list.get(2);
        System.out.println(i);  //i = 3
        
    }
    
     @Test
    public void test4() {
        SinglyLinkedList list = new SinglyLinkedList();
        list.addLast(1);
        list.addLast(2);
        list.addLast(3);
        list.addLast(4);
       
		list.insert(2, 5); 向索引为2的位置插入元素5
        for(Integer value : list) {
            System.out.print(value);
        }
        
    }
}

带哨兵的单向链表

// 单项链表
public class SinglyLinkedList implements Iterable<Integer>() {
    
    private Node head = new Node(666, null);  // 头指针
    
    // 节点类
    private static class Node() {
        int value;  // 值
        Node node;  // 下一个节点
        
        public Node(int value, Node node) {
            this.value = value;
            this.node = node;
        }
    }
    
    @Override
    public Iterator<Integer> iterator() {
        // 匿名内部类 -> 带名字的内部类
        return new NodeIterator();
    }
    
    // 1.链表头部添加元素
    public void addFirst(int value) {
		insert(0, value);
    }
    
    // 寻找最后一个节点
    private Node findLast() {
        Node p;
        for(p = head; p.next != null; p = p.next) {
            
        }
        return p;
    }
    
    // 3.尾部添加元素
    private void addLast(int value) {
        Node last = findLast();
        last.next = new Node(value, null);
    }
    
    // 4.根据索引值查找结点
    public Node findNode(int index) {
        int i = -1;
        for(Node p = head; p != null; p = p.next, i++) {
            if (index == i) {
                return p;
            }
        }
        // 未找到
        return null;
    }
    
    // 5.根据index找到对应节点，并返回节点值
    public int get(int index) {
        Node p = findNode(index);
        if (p == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        return p.value;
    }
    
    // 6.向索引位置插入元素
    public void insert(int index, int value) {
        // 1.找到插入索引位置的上一个节点
        Node p = findNode(index - 1);
        // 判断p节点是否为空
        if (p == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node n = p.next;
        // p存在的情况
        p.next = new Node(value, n);
    }
    
    // 7.删除头部节点
    public void removeFirst() {
		remove(0);
    }
    
    // 8.按索引位置删除节点
    public void remove (int index) {
        Node p = findNode(index - 1);  // 找到待删除节点的上一个节点
        if (p == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node n = p.next;               // 待删除节点
        if (n == null) {
            // 未找到待删除节点
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        p.next = n.next;			   // 待删除节点的上一个节点p的next指向待删除结点的下一个节点
    }
    
    // 6.遍历链表，方法1
    public void loop1(Consumer<Integer> consumer) {
        Node p = head.next; // 头节点赋给p
        while (p != null) {
            consumer.accept(p.value);
            p = p.next;
        }
    }
    // 循环遍历，方法2
    public void loop2(Consumer<Integer> consumer) {
        for(Node p = head.next; p != null; p = p.next) {
            consumer.accept(p.value);
        }
    }
    
    // 遍历，方法3，使用迭代器，实现接口Iterable
    public class NodeIterator implements Iterator<Integer> {
        Node p = head.next;
        
        @Override
        public boolean hasNext() {  //判断是否有下一个元素
            return p != null;
        }

        @Override
        public Integer next() {     //返回当前节点值
            int value = p.value;
            p = p.next;
            return value;      
        }
    }
}

双向链表–哨兵

public class DoublyLinkedListSentinel implements Iterator<Integer> {
     
    static class Node {
        Node prev;		// 上一节点
        int value;		// 值
        Node next;		// 下一节点
        
        public Node (Node prev, int value, Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }
    
    private Node head; //头哨兵节点
    private Node tail; //尾哨兵节点
    
    public DoublyLinkedListSentinel () {
        head = new Node(null, 666, null);
        tail = new Node(null, 888, null);
        head.next = tail;
        tail.prev = head;
    }
    
    // 根据索引位置找节点
    private Node findIndex(int index) {
        int i = -1;
        for(Node p = head; p != tail; p = p.next, i++) {
        	if (index == i) {
                return p;
            }    
        }
        return null;
    }
    
    // 头部插入元素
    public void addFirst(int value) {
        insert(0, value);
    } 
    // 1.对应索引位置插入元素
    public void insert(int index, int value) {
        Node prev = findIndex(index - 1);		// 插入索引位置前一个结点
        if (prev == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node next = prev.next;					// 成为待插入元素节点的下一个节点
        Node node = new Node(prev, value, next); 
        prev.next = node;
        next.prev = node;
    }
    
    // 尾部添加元素
    public void addLast(int value) {
        Node last = tail.prev;
        Node added = new Node(last, value, tail);
        last.next = added;
        tail.prev = added; 
    }
    
    // 删除最后一个节点
    public void removeLast() {
        Node removed = tail.prev;
        if (removed == head) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node prev = removed.prev;
        prev.next = tail;
        tail.prev = prev;
    }
    
    // 删除头节点
    public void removeFirst() {
        remove(0);
    }
    
    // 删除节点
    public void remove(int index) {
        Node prev = findIndex(index - 1);		// 删除索引位置前一个结点
        if (prev == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node next = prev.next.next;					// 待删除元素节点的下一个节点
        if (next == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
		prev.next = next;
        next.prev = prev;
    }
    
    // 迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = head.next;
            @Override
            public boolean hasNext() {
                return p != tail;
            }
            
            @Override 
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        }
    }
    
}

环形链表

双向环形链表带哨兵，哨兵既作为头哨兵，又作为尾哨兵
在这里插入图片描述

public class DoublyLinkedListSentinel {
     
    private static class Node {
        Node prev;		// 上一节点
        int value;		// 值
        Node next;		// 下一节点
        
        public Node (Node prev, int value, Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }
    
    private Node sentinel = new Node(null, -1, null);
    
    public DoublyLinkedListSentinel () {
        sentinel.prev = sentinel;
        sentinel.next = sentinel;
    }
    
    // 根据索引位置找节点
    private Node findIndex(int index) {
        int i = -1;
        for(Node p = sentinel; p != sentinel; p = p.next, i++) {
        	if (index == i) {
                return p;
            }    
        }
        return null;
    }
    
    // 头部插入元素
    public void addFirst(int value) {
        Node a = sentinel;
        Node b = sentinel.next;
        Node added = new Node(a, value, b);
        a.next = added;
        b.prev = added;
    } 
    
    // 1.对应索引位置插入元素
    public void insert(int index, int value) {
        Node prev = findIndex(index - 1);		// 插入索引位置前一个结点
        if (prev == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node next = prev.next;					// 成为待插入元素节点的下一个节点
        Node node = new Node(prev, value, next); 
        prev.next = node;
        next.prev = node;
    }
    
    // 尾部添加元素
    public void addLast(int value) {
        Node b = sentinel;
        Node a = sentinel.prev;
        Node added = new Node(a, value, b);
        b.prev = added;
        a.next = added;
    }
    
    // 删除头节点
    public void removeFirst() {
        Node removed = sentinel.next;
        if (removed == sentinel) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node a = sentinel;
        Node b = removed.next;
        a.next = b;
        b.prev = a;
    }
    
    // 删除最后一个节点
    public void removeLast() {
        Node removed = sentinel.prev;
        if (removed == sentinel) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node a = sentinel;
        Node b = removed.prev;
        a.prev = b;
        b.next = a;
    }
    
    // 根据节点值查找该节点
    public Node findByValue(int value) {
        Node p = sentinel.next;
        whlie (p != sentinel) {
            if (p.value == value) {
                return p;
            }
            p = p.next;
        }
        return null;
    }
    
    // 根据节点值删除节点
    public void remove(int vlaue) {
        Node removed = findByValue(value);
        if (removed == null) {
            // 节点为空，抛出异常
            threw new IllegalArgumentException(String.format("index [%d]不合法%n", index));
        }
        Node a = removed.prev;
        Node b = removed.next;
        a.next = b;
        b.prev = a;
    }
    
    // 迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = sentinel.next;
            @Override
            public boolean hasNext() {
                return p != sentinel;
            }
            
            @Override 
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        }
    }
}
莫陌尛.
关注
  • 29
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法--黑马课堂
Tmimi222的博客
05-18 449
改进 把代码简化。
黑马程序员 黑马 数据结构与算法 课件 源代码.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
循环链表-线性表-数据结构和算法
gaogzhen的博客
10-27 120
循环链表-线性表-数据结构和算法
应用-单向链表-数据结构和算法
gaogzhen的博客
10-19 280
应用-单向链表-数据结构和算法
单向链表-线性表-数据结构和算法
gaogzhen的博客
10-11 331
数据结构和算法 线性表 单向链表
递归--数据结构--黑马
weixin_49326024的博客
08-18 1243
递归是一种解决计算问题的方法，其中解决方案取决于同一类问题的更小子集。return;自己调用自己，如果每个函数对应一个解决方案，自己调用自己意味着解决方案一样(有规律)。每次调用，函数处理的数据会较上次缩减（子集），而且最后会缩减至无需继续递归。内层函数调用（子集处理）完成，外层函数才能算调用完成。例如，// 假如链表是，1 -> 2 -> 3 -> nullreturn;根据递归的性质，从链表头节点开始遍历，打印第一个节点值nodevalue1node。
数据结构--链表
weixin_73618012的博客
10-14 154
在计算机科学中，链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上并不连续。可以分类为5单向链表，每个元素只知道其下一个元素是谁双向链表，每个元素知道其上一个元素和下一个元素循环链表，通常的链表尾节点 tail 指向的都是 null，而循环链表的 tail 指向的是头节点 head链表内还有一种特殊的节点称为哨兵（Sentinel）节点，也叫做哑元（ Dummy）节点，它不存储数据，通常用作头尾，用来简化边界判断，如下图所示1.2随机访问性能。
黑马笔记---常见数据结构
weixin_65440201的博客
06-29 565
目录1.常见数据结构1.1数据结构概述、栈、队列数据结构概述常见的数据结构1.2数组1.3链表链表的特点链表的种类 1.4二叉树、 二叉查找树二叉树概述二叉树的特点 二叉查找树的特点1.5平衡二叉树1.6红黑树红黑树概述红黑规则添加节点红黑树小结：各种数据结构的特点和作用是什么样的1.数据结构是计算机底层存储、组织数据的方式。是指数据相互之间是以什么方式排列在一起的。2.通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。1.栈2.队列3.数组4.链表5.二叉树6.二叉查找树7.平衡二叉树8.红
五、链表-双向链表
qq_58210976的博客
03-01 223
自学JAVA数据结构笔记，跟学视频为：黑马程序员Java数据结构与java算法全套教程，数据结构+算法教程全资料发布，包含154张java数据结构图_哔哩哔哩_bilibili 3.双向链表API 4双向链表实现 二、快慢指针 1.含义 快慢指针指的是定义两个指针，这两个指针的移动速度一块一慢，以此来制造出自己想要的差值，这个差值可以然 我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的两倍 3.判断链表是否有环 4.获取环形链表入口 三、约瑟夫问
链表--单向链表
m0_60333804的博客
09-11 48
哔哩黑马程序员最棒
黑马程序员java数据结构教程源码
01-13
本教程源码由黑马程序员提供，旨在帮助学习者深入理解和掌握Java中的数据结构及其算法。以下是对这些关键知识点的详细阐述： 1. **数组**：Java中最基础的数据结构，用于存储相同类型元素的集合。数组提供了直接...
Java项目-黑马斗地主完整Java代码
04-23
5. **数据结构和算法**：斗地主游戏涉及到牌的存储、排序、洗牌等操作，这需要用到数组、链表、栈、队列等数据结构，以及排序算法（如快速排序、冒泡排序等）。 6. **游戏逻辑**：斗地主的规则实现是一个复杂的逻辑...
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 943
Redis 底层数据结构详解
【数据结构】线性表的顺序表示（顺序表的定义和基本操作）
zhousanguhe的博客
08-23 375
线性表的顺序表示（顺序表的定义和基本操作：初始化/插入/删除/查找）
二叉搜索树：数据结构之美
最新发布
wgr050505的博客
08-26 544
本文介绍了二叉搜索树的基本概念、主要操作以及一些高级主题。通过学习这些内容，您不仅能够理解二叉搜索树的工作原理，还能够掌握如何有效地使用它们来解决实际问题。此外，本文还探讨了自平衡二叉搜索树的概念，这是处理大规模数据集时的一个重要工具。
重新理解操作系统（linux）、编程语言和算法与数据结构
crawer
08-23 464
怎样理解操作系统（linux）、编程语言和算法与数据结构
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
业精于勤，荒于嬉
08-22 874
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
数据结构（邓俊辉）学习笔记】优先级队列 08——左式堆：结构
weixin_44399845的博客
08-23 1087
学习左式堆的结构
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值