数据结构03——链表

最新推荐文章于 2024-07-13 19:51:15 发布
最新推荐文章于 2024-07-13 19:51:15 发布
阅读量62 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/hsdy/p/10011654.html
版权

 

一.开头语

对于链表是我们一个非常熟悉的数据结构，它的定义：链表是一种递归的数据结构，它或者为空（null），或者指向一个节点（node）的引用，该节点含有一个泛型的元素和一个指向另一条链表的引用。当然这只是一种比较教科书式的定义。对于链表的数据是存储在“节点”中的，它的优点是真正的动态，不需要处理固定容量的问题，但它的缺点是丧失了随机访问的功能。因此它与数组相比，其优缺点就非常明显了。在本篇文章，我们将手写实现一个链表的功能，且最后我们还将会用链表来实现栈和队列的功能，大家应该非常期待吧！那我们就开始吧！

 

二.手写一个链表的功能

 

package com.zfy.linkedlist;

public class LinkedList<E> {
    
    //节点内部类
    private class Node {
        public E e;//存放元素
        public Node next;//存放指向next的node
        
        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
        
        public Node(E e) {
            this(e, null);
        }
        
        public Node() {
            this(null, null);
        }
        
        @Override
        public String toString() {
            return e.toString();
        }
    }
    
    private Node dummyHead;//表头，设置一个虚拟头结点，只是为了编写程序方便而设置的，对用户是没有意义的，对用户也是屏蔽的
    private int size;
    
    public LinkedList() {
        dummyHead = new Node(null, null);
        size = 0;
    }
    
    //获取链表中的元素个数
    public int getSize() {
        return size;
    }
    
    //返回链表是否为空
    public boolean isEmpty() {
        return getSize() == 0;
    }
    
    // 在链表的index(0-based)位置添加新的元素e
        // 在链表中这不是不是一个常用的操作，仅练习用
    public void add(int index, E e){
        if(index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");
        
        Node prev = dummyHead;
        //遍历到待插入节点的前一个位置(因为这里设置的dummyHead是为null的，而dummyHead是这个位置的元素的前一个节点，所以我们此时遍历到index的位置)
        for (int i = 0; i < index; i++) 
            prev = prev.next;
//            Node node = new Node(e);
//            node.next = prev.next;//将prev.next赋给待插入节点的next,是为了指向下一个元素
//            prev.next = node;//将新的节点node指向prev.next 
        //上面代码更优雅的一个写法
        prev.next = new Node(e, prev.next);
        size ++;
    }
    
    //在链表头添加新的元素e
    public void addFirst(E e) {
        add(0, e);
    }
    
    
    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }
    
    // 获得链表的第index(0-based)个位置的元素
    // 在链表中不是一个常用的操作，仅练习用
    public E get(int index) {
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed. Illegal index.");
        
        Node cur = dummyHead.next;//当前元素从dummyHead.next开始，也就是从链表的第一个位置开始
        for (int i = 0; i < index; i++) 
            cur = cur.next;
        return cur.e;
    }
    
    //获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    //获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }

    //修改链表的第index(0-based)个位置的元素为e
    //在链表中不是一个常用的操作，仅练习用
    public void set(int index, E e){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Set failed. Illegal index.");
        Node cur = dummyHead.next;
        for (int i = 0; i < index; i++)
            cur = cur.next;
        cur.e = e;
    }
    
    //查找链表中是否有元素e
    public boolean contains(E e){
        
        Node cur = dummyHead.next;
        while (cur != null) {
            if (cur.e.equals(e)) 
                return true;
            cur = cur.next;//如果cur.e.equals(e)    ，就返回true，否则看下一个节点
        }
        return false;
    }

    // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    // 在链表中不是一个常用的操作，练习用：）
    public E remove(int index){
        
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed. Index is illegal.");

        Node prev = dummyHead;
        for (int i = 0; i < index; i++) 
            prev = prev.next;//删除index节点的元素就是先找到待删除节点的前一个位置然后做相应的 删除操作
        
        Node retNode = prev.next;//找到当前待删除的节点
        prev.next = retNode.next;//把当前待删除节点的next赋给prev.next
        retNode.next = null;//最后把retNode.next置为null
        size --;
        return retNode.e;
    }
    
    //从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    //从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }
    
    //从链表中删除元素e
    public void removeElement(E e){

        Node prev = dummyHead;
        while(prev.next != null){
            if(prev.next.e.equals(e))
                break;
            prev = prev.next;
        }

        if(prev.next != null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size --;
        }
    }
    
    @Override
    public String toString() {
        
        StringBuilder res = new StringBuilder();
//        Node cur = dummyHead.next;
//        while (cur != null) {
//            res.append(cur + "->");
//            cur = cur.next;
//        }
        for(Node cur = dummyHead.next ; cur != null ; cur = cur.next)
            res.append(cur + "->");
        res.append("NULL");
        
        return res.toString();
    }
}

 

 

 在链表表头插入和删除速度很快，其时间复杂度O(1)。如果均摊的话，查找、删除和在指定节点后面插入都需要进行遍历，其时间复杂度为O(N)。但是在数组中执行这些样的操作也需要O(N)的（数组查询除外），但是对于链表如果只在表头进行增删，那么其复杂度也只是为O(1)，而链表的修改功能意义本来就不大，如果查也只是查表头，其复杂度也只是为O(1)。但是由于链表是动态的，因此是不会浪费大量的空间的，所以具有一定的优势。其实链表本身是一种最基础的动态数据结构，对这种动态数据结构有深刻的理解和掌握后，对后面的二叉树、平衡二叉树、AVL或者红黑树等等，都是有巨大的帮助的。

 

三.使用链表实现栈

因为这里我们的功能是基于上一篇文章的代码的，因此这里我们就不贴代码了。

package com.zfy.linkedlist;

public class LinkedListStack<E> implements Stack<E> {
    
    private LinkedList<E> list;
    
    public LinkedListStack() {
        list = new LinkedList<>();
    }

    @Override
    public int getSize(){
        return list.getSize();
    }

    @Override
    public boolean isEmpty(){
        return list.isEmpty();
    }

    @Override
    public void push(E e){
        list.addFirst(e);
    }

    @Override
    public E pop(){
        return list.removeFirst();
    }

    @Override
    public E peek(){
        return list.getFirst();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Stack: top ");
        res.append(list);
        return res.toString();
    }

    public static void main(String[] args) {

        LinkedListStack<Integer> stack = new LinkedListStack<>();

        for(int i = 0 ; i < 5 ; i ++){
            stack.push(i);
            System.out.println(stack);
        }

        stack.pop();
        System.out.println(stack);
    }
}

 

 

四.使用链表实现队列:带有尾指针的链表

 

这里我们的功能是基于上一篇文章的代码的，因此这里我们就不贴代码了。

 

package com.zfy.linkedlist;
public class LinkedListQueue<E> implements Queue<E> {
    
    private class Node{
        public E e;
        public Node next;

        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }

        public Node(E e){
            this(e, null);
        }

        public Node(){
            this(null, null);
        }

        @Override
        public String toString(){
            return e.toString();
        }
    }
    
    private Node head, tail;
    private int size;
    
    public LinkedListQueue(){
        head = null;
        tail = null;
        size = 0;
    }
    
    @Override
    public int getSize(){
        return size;
    }

    @Override
    public boolean isEmpty(){
        return size == 0;
    }
    
    @Override
    public void enqueue(E e){
        
        if (tail == null) {
            tail = new Node(e);
            head = tail;
        }else {
            tail.next = new Node(e);
            tail = tail.next;
        }
        size ++;
    }
    
    @Override
    public E dequeue(){
        if(isEmpty())
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        
        Node retNode = head;
        head = head.next;
        retNode.next = null;
        
        if(head == null)
            tail = null;
        size --;
        return retNode.e;
    } 
    
    @Override
    public E getFront(){
        if(isEmpty())
            throw new IllegalArgumentException("Queue is empty.");
        return head.e;
    }
    
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Queue: front ");

        Node cur = head;
        while(cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL tail");
        return res.toString();
    }

    public static void main(String[] args){

        LinkedListQueue<Integer> queue = new LinkedListQueue<>();
        for(int i = 0 ; i < 10 ; i ++){
            queue.enqueue(i);
            System.out.println(queue);

            if(i % 3 == 2){
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }

}

 

 

最后语：不积跬步，无以至千里；不积小流，无以成江海。其实以上的功能还有很多其他的实现方式，有时间笔者还将继续探索！在这里还要感谢一些前辈给我的动力，虽然我们素未谋面，但是他们的学识让我深感佩服，也让我有了更多的学习动力。

参考：bobobo老师的玩转数据结构和算法（第四版）

 

版权声明：尊重博主原创文章，转载请注明出处 https://www.cnblogs.com/hsdy

转载于:https://www.cnblogs.com/hsdy/p/10011654.html

de330392
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
Python数据结构实战——链表(LinkedList)
12-21
本文将重点介绍如何通过实践来创建和操作链表（LinkedList）这一数据结构。链表是一种动态数据结构，与数组不同，它允许在不相邻的位置进行插入和删除操作，这得益于每个元素（称为节点）都包含指向下一个元素的引用...
数据结构实验——链表实现XXX管理系统
04-06
数据结构的实验：实验题目是**管理系统。要求用带头结点的单链表实现具有插入、删除、显示、修改、保存至文件以及读入文件等功能的**管理系统。加至少3个结构成员，其中必须包含一个字符类或字符数组类，并使用排序...
图解数据结构（使用Python）——链表
12-21
【链表】是一种基本的数据结构，它在计算机科学中扮演着重要的角色，特别是在处理动态数据集合时。链表不同于数组，它的元素在内存中不是连续存储的，而是通过每个节点的指针链接起来。这样的设计使得链表在某些操作...
数据结构实验——链表
12-14
数据结构实验——链表 数据结构实验——链表
LCR 155. 将二叉搜索树转化为排序的双向链表
weixin_61067952的博客
07-09 265
中序遍历可以得到排序的序列，遍历时维护当前节点和前一个节点，改变左右指针。头节点设为null，遍历开始判断一下然后初始化。尾节点中序遍历时一直更新。
7.10飞书一面面经
东篱君的博客
07-10 1135
B+树的⾮叶⼦节点不存放实际的记录数据，仅存放索引，所以数据量相同的情况下，相⽐存储即存索引⼜存记录的 B 树，B+树的⾮叶⼦节点可以存放更多的索引，因此 B+ 树可以⽐ B 树更「矮胖」，查询底层节点的磁盘 I/O次数会更少。主从复制：单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，可以搭建主从集群，实现读写分离。B+ 树有⼤量的冗余节点（所有⾮叶⼦节点都是冗余索引），这些冗余索引让 B+ 树在插⼊、删除的效率都更⾼，⽐如删除根节点的时候，不会像 B 树那样会发⽣复杂的树的变化；
[高频 SQL 50 题(基础版)]第一千七百五十七题，可回收且低脂产品
weixin_45201305的博客
07-10 259
low_fats 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品是低脂产品，'N' 表示不是低脂产品。recyclable 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品可回收，而 'N' 表示不可回收。没什么难度，作为基础题五十题的第一题练手，现在也开始陆续写一些SQL，作为记录，和leetcode一起，大家都加油。编写解决方案找出既是低脂又是可回收的产品编号。是该表的主键（具有唯一值的列）。
leetcode--验证二叉搜索树
liulanba的博客
07-09 657
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
Redis数据结构-String篇
时间如瑾 代码如诗
07-12 598
对⼀个内部表示成long型的string执行append, setbit, getrange这些命令，针对的仍然是string的值（即⼗进制表示的字符串），而不是针对内部表⽰的long型进⾏操作。因此，在这些命令的实现中，会把long型先转成字符串再进行相应的操作。String 的内部存储结构⼀般是 sds（Simple Dynamic String，可以动态扩展内存），但是如果⼀个String 类型的 value 的值是数字，那么 Redis 内部会把它转成 long 类型来存储，从⽽减少内存的使用。
文章检查敏感词速度提升10倍+
陈海龙的格物之路
07-09 697
如何对文章进行高效的敏感词检查？
7.深度学习概述
MechMaster
07-10 940
1. 线性回归 1.1 线性回归一般表达式 1.2 线性回归内积表达方式： 1.3 多个样本时，线性回归的进一步表达： 1.4 线性回归方程的解析 1.5 线性回归就是求loss函数的最小值 2. 如何求函数最小值 2.1 一个例子 2.2 求导法——求最小值 2.3 求导法存在的问题 2.4 迭代法——求最小值 3. 代码实现 3.1 手动求函数最小值 3.2 使用pytorch求函数最小值
代码随想录算法训练营第33天
m0_62262158的博客
07-10 148
【代码】代码随想录算法训练营第33天。
Leetcode刷题——7 滑动窗口 双指针
as_your_heart的博客
07-09 183
注：以下代码均为c++
C++：哈希表
m0_61088872的博客
07-12 485
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
智能优化算法之模拟退火算法SA
Argulo的博客
07-13 221
模拟退火算法（Simulated Annealing, SA）是一种基于热力学原理的随机优化算法，最早由 S. Kirkpatrick, C. D. Gelatt 和 M. P. Vecchi 于 1983 年提出。在优化过程中，算法允许在一定概率下接受较差的解，以避免陷入局部最优解。在每次迭代中，从当前路径的邻域中随机选择一个新路径。计算新路径的长度，并根据接受准则决定是否接受新路径。：绘制城市坐标图和优化过程中最佳路径长度的变化曲线。：调用模拟退火算法，并输出最佳路径和最佳路径长度。
C++学习笔记
qq_45882170的博客
07-09 1010
默认参数值只能在函数声明中指定，而不能在函数定义中指定。如果同时有声明和定义，并且两者都试图为同一个参数指定默认值，这会导致编译错误。
【代码随想录】【算法训练营】【第62天】 [卡码108]冗余连接 [卡码109]冗余连接II
weixin_54954007的博客
07-08 585
思路及算法思维，指路。题目来自。day 62，又是一个周一，ding~
【刷题汇总 -- 删除公共字符、两个链表的第一个公共结点、mari和shiny】
最新发布
m0_69455439的博客
07-13 936
今日刷题汇总day012 -- 删除公共字符、两个链表的第一个公共结点、mari和shiny
数据结构课程设计.docx
06-18
关于链表的操作

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值