链表的相关知识

最新推荐文章于 2024-07-07 18:26:58 发布
最新推荐文章于 2024-07-07 18:26:58 发布
阅读量350 收藏 9
点赞数 7
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shootingmemory/article/details/135686286
版权

物理上(内存)不一定连续

逻辑上连续的一种结构

链表的分类

单向 双向

带头 不带头

循环 非循环

public class MySingleList implements iList {
    class Solution{
        public ListNode middleNode(ListNode head){
            ListNode slow=head;
            ListNode fast=head;
            while(fast!=null&&fast.next!=null){//不可以反转，当后端先判断的时候会导致fast为空。
                slow=slow.next;
                fast=fast.next.next;
            }
            System.out.println(slow.next);
            return slow;
        }
    }

    static class ListNode {
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    //链表的属性  链表的头节点
    public ListNode head;//null

    public void createList() {
        ListNode node1 = new ListNode(12);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        this.head = node1;
    }


    @Override
    public void display() {
        ListNode cur = head;//防止head最后定义表头时候为空
        while (cur != null) {//cur为空则停止循环
            System.out.print(cur.val + " ");//打印他的数值
            cur = cur.next;//下移
        }
        System.out.println();
    }


    public void display(ListNode newHead) {
        ListNode cur = newHead;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }


    /**
     * 求当前链表 是否存在Key
     *
     * @param key
     * @return
     */
    @Override
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    /**
     * 求当前链表 有多少个节点
     *
     * @return
     */
    @Override
    public int size() {
        int count = 0;//cur走到空
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }


    @Override
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = this.head;
        this.head = node;
    }

    @Override
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
        } else {
            ListNode cur = head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;//cur走到了最后一个节点的位置
        }
    }

    @Override
    public void addIndex(int index, int data) throws IndexException {
        if (index < 0 || index > size()) {
            throw new IndexException("index不合法的: " + index);
        }
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        //中间插入
        ListNode cur = searchPrevIndex(index);
        node.next = cur.next;
        cur.next = node;
    }

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

    @Override
    public void remove(int key) {
        if (head == null) {
            return;
        }
        if (head.val == key) {
            head = head.next;
            return;
        }
        ListNode cur = findPrevKey(key);
        if (cur == null) {
            return;//没有你要删除的数字
        }
        ListNode del = cur.next;
        cur.next = del.next;
    }

    private ListNode findPrevKey(int key) {
        ListNode cur = this.head;
        while (cur.next != null) {
            if (cur.next.val == key) {
                return cur;
            } else {
                cur = cur.next;
            }

        }
        return null;
    }



    @Override
    public void removeAllKey(int key) {
        if(head == null) {
            return;
        }
        ListNode prev = head;
        ListNode cur = head.next;

        while (cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        //除了头节点都删除完成了之后再运行如果放在前面的情况下，如果12都是想删除的数据。就会造成数据删除补干净，第二个删除不了
        if(head.val == key) {
            head = head.next;
        }
    }
    @Override
    public void clear() {
        head = null;
    }


    public ListNode reverseList() {
        if(head == null) {return head;}
        if(head.next == null) { return head;}
        ListNode cur = head.next;
        head.next = null;

        while(cur != null) {
            ListNode curNext = cur.next;
            cur.next = head;
            head = cur;
            cur = curNext;
        }
        return head;
    }

    public ListNode middleNode() {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

    public ListNode findKthToTail(ListNode head,int k) {//让fast先走k-1步，然后fast和slow一起走，最后返回slow的值就是倒数的值
        if(k <= 0) {
            return null;
        }
        if(head == null) {//防止头指针为0
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        int count = 0;
        while(count != k-1) {
            if(fast.next != null) {//防止那个数字超过链表长度
                fast = fast.next;
                count++;
            }else {
                return null;
            }
        }
        while(fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

    public ListNode partition(int x) {
        // write code here
        //定义一个cur 指向链表的头节点
        ListNode cur = head;

        ListNode bs = null;
        ListNode be = null;
        ListNode as = null;
        ListNode ae = null;
        //使用cur来遍历 所有的节点
        while (cur != null) {
            if(cur.val < x) {
                if(bs == null) {
                    bs = cur;
                    be = cur;
                }else {
                    be.next = cur;
                    be = be.next;
                }
            }else {
                // >= x
                if(as == null) {
                    as = cur;
                    ae = cur;
                }else {
                    ae.next = cur;
                    ae = ae.next;
                }
            }
            cur = cur.next;
        }
        if(bs == null) {
            return as;
        }
        be.next = as;
        if(as != null) {
            ae.next = null;
        }
        return bs;
    }


    public boolean chkPalindrome() {
        // write code here
        if(head == null) {
            return true;
        }
        //1. 找中间节点
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }

        //2.翻转
        ListNode cur = slow.next;
        while (cur != null) {
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        //3.一个往前 一个往后
        while (slow != head) {
            if(slow.val != head.val) {
                return false;
            }
            //偶数情况
            if(head.next == slow) {
                return true;
            }
            head = head.next;
            slow = slow.next;
        }
        return true;
    }

    public boolean hasCycle() {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                return true;
            }
        }
        return false;

    }

    public ListNode detectCycle() {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                break;
            }
        }
        if(fast == null || fast.next == null) {
            //因为循环条件退出
            return null;//证明连环都没有
        }
        slow = head;
        while(slow != fast) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }


}
public class IndexException extends RuntimeException {
    public IndexException(String s) {

        System.out.println(s);
    }
}
public interface iList {
    void addFirst(int data);
    void addLast(int data);
    void addIndex(int index,int data);
    boolean contains(int key);
    void remove(int key);
    void removeAllKey(int key);
    int size();
    void clear();
    void display();
}

 这里的headA和headB指的是两个独立链表，而headA=headA.next；指的是下一个next域里面的所有head下面的值，而cur=head则是将head的值替换到cur。两个易搞混，应该细细品味。

环形链表中， 

 快指针的速度是慢指针的2倍，路程也是二倍。

2. 假设 快指针 只走了一圈就和慢指针相遇了

3.假设起始点 到 入口点距离为X，相遇点到入口点距离为Y环的长度为C

经过计算X=(N-1)+Y，当N=1的时候，相遇点和起始点道入口路程相同

public ListNode detectCycle() {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                break;
            }
        }
        if(fast == null || fast.next == null) {
            //因为循环条件退出
            return null;//证明连环都没有
        }
        slow = head;
        while(slow != fast) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

 

Shootingmemory
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
链表的相关知识PPTX
08-06
链表的相关知识PPTX 链表是一种基本的数据结构，它是一种线性表，元素逐个链接，每个元素都是一个独立的对象。链表的每个元素都包含两个信息：元素的值和指向下一个元素的指针。链表可以分为单链表、双链表和循环...
关于链表基础知识的详解
07-20
"链表.sln"可能是一个Visual Studio解决方案文件，包含了链表相关项目的配置信息。".vs"文件夹是Visual Studio的工作区设置，可能包含了一些用户特定的配置和调试信息。"x64"可能是指项目编译的目标平台为64位。这些...
链表知识点总结
Lookdrama的博客
10-27 1084
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。每一个结构均含有元素和指向该元素后继结构的指针。
链表相关知识
m0_73858159的博客
11-28 180
链表
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 16万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
链表相关知识总结
m0_61478092的博客
11-20 776
链表相关知识 目录 链表的定义 链表的分类 单链表的相关操作 链表的优缺点 链表的定义 n个结点离散分配 彼此通过指针相连 每个结点只有一个前驱结点，每个节点只有一个后续结点 首节点没有前驱结点，尾节点没有后续结点 专业术语： 首结点：第一个有效节点 尾节点：最后一个有效结点 头节点：第一个有效结点之前的结点，头结点不存放有效数据，且头结点主要为了方便对链表的操作 头指针：指向头结点的指针变量，且存放头结点的地址 尾指针：指向尾节点的指针变量 注：确定一个数组，需要三个参数：元素个数，首地址，
链表相关知识点
qq_40636008的博客
05-01 276
链表2.0
链表基础知识总结
闲适_
02-28 1万+
什么是链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点都包括两部分：一是数据域，用来存储元素数值数据，另一个是存储直接后继结点地址的指针域，该指针一般称为next，用来指向下一个结点的位置。由于下一个结点也是链表类型，所以next的指针也要定义为链表类型。 链表中的一些基本定义和特点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中存储的第一个数据元素的结
C语言链表超详解
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表基础知识
weixin_50616848的博客
05-28 1083
目录 1、单链表 2、双链表 3、循环链表 4、删除节点 5、添加节点 6、链表定义 1、单链表 单链表是多个节点通过指针串联起来的线性结构，每个节点分为两部分，一个是数据域，一个为指针域，最后一个节点的指针域胃为空 （1）数据域：存放数据； （2）指针域：指向下一个节点的指针。 2、双链表 双链表中每一个节点有两个指针域，一个指针域指向上一个节点，一个指针域指向下一个节点，可以查询前也可以查询后。如下图： 3、循环链表 循环链表就是链表的首....
链表相关知识内容
2401_83703513的博客
04-11 921
单向链表，节点的定义，malloc，free，memset，双向链表
链表相关知识整理
Zephyr的博客
11-28 267
标语：如果惧怕前面跌宕的山岩，生命永远只能是死水一潭 链表 定义：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 比较： 数组 链表 如何建立链表 头插法 将元素插入链表头的后面 尾插法 将元素顺序插入链表当中 如何逆序一个链表 非递归 需要三个辅助变量前驱（pre），当前节点（p），后继节点（next） 递归 递归到最后...
python的链表基础知识点
12-17
python中的链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。链表有两种类型：单链表和双链表。 链表的数据结构如下图所示： 在链表中删除操作...
数据结构 第一章 前置知识 链表
12-16
数据结构第一章前置知识链表 本章主要讲链表的知识，包括链表的创建、增删改查。下面是对链表的详细介绍： 什么是链表？ 链表是一种数据结构，它是一种动态分配的数据结构，通过指针将零散的内存块串联起来。链表...
6、Redis系统-数据结构-06-跳表
qq_29434541的博客
07-07 416
在 Redis 中，跳表通过高效的多级链表结构，实现了有序集合的快速插入、删除和查询操作，适用于需要有序数据存储的场景。跳表通过多级链表的形式实现，每一级链表都跳过一些元素，从而在查询时能够快速跳过不必要的元素。跳表的每个节点包含一个或多个前进指针，这些前进指针指向不同级别的节点，使得跳表具有高效的查询性能。删除节点时，通过查找操作确定节点位置，然后在每一级链表中移除该节点，并调整相关节点的前进指针和跨度。插入新节点时，首先确定新节点的级别，然后在每一级链表中找到插入位置，将新节点插入到相应的位置。
数据结构第14节 加权图
最新发布
hummhumm的专栏
07-07 1089
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
数据结构——带环链表、循环队列问题
2402_83657626的博客
07-02 516
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。以上便是本期讨论的两个数据结构问题，欢迎大家评论讨论交流。快指针一次走两步慢指针一次走一步。代码实现：（链表的实现请跳转☞。
数据结构第07节：队列
hummhumm的专栏
07-04 458
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 572
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
python链表基础知识
10-22
Python中的链表是一种数据结构，它由一组节点组成，每个节点包含一个数据项和一个指向下一个节点的链接。链表有两种类型：单链表和双链表。在Python中，我们可以使用类来定义链表和节点。链表的基本操作包括增、删、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值