现在还不懂什么是链表？

最新推荐文章于 2023-08-30 15:02:34 发布
最新推荐文章于 2023-08-30 15:02:34 发布
阅读量1.8k 收藏 6
点赞数 1
文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37681665/article/details/130828757
版权

一、什么是链表

链表和数组一样，也是一种线性表。只不过不同于数组，从内存结构来看，链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。

链表中的每一个内存块被称为节点Node。节点除了存储数据外，还需记录链上下一个节点的地址，即后继指针next，在特殊的链表结构中，甚至还需要保留上一个节点的地址，即前驱指针。

 

二、链表和数组的区别

比如说：Java中 ArrayList 和 LinkedList 的之间区别？

  • 数组的随机访问快，插入和删除慢

  • 链表的插入删除快，随机访问慢

  • 频繁增删的情况下，用链表比较合适

  • 在随机查找多的情况下，用数组比较合适

因为数组是连续存储的，支持随机访问，所以根据首地址和下标，通过寻址公式就能直接计算出对应的内存地址，时间复杂度为 O(1)。

三、常用链表

🍃3.1 单链表

3.1.1 单链表特点

单链表作为最常见的链表结构,如图所示:

 

  • 单链表的每个节点包含下一个节点的地址指针，即后继指针；

  • 头结点，即链表的第一个结点，用来记录链表的基地址，我们只要知道这个结点，就可以开始遍历整条链表；

  • 尾结点，即最后一个结点，因此尾结点后继指针next指向的不再是下一个节点。而是指向一个空地址null。

3.1.2 为什么单链表的尾结点指向一个空地址

单链表的尾结点指向空地址的好处是:防止尾节点的后继指针next成为一个野指针，导致遍历链表根本停不下来，或者出现一堆本不属于该链表的垃圾数据；

3.1.3 单链表操作复杂度分析

插入时，只需要更改指针指向的对象地址即可，无需迁移数据，因此链表的插入和删除操作时间复杂度为O(1)。找到前驱节点的时间复杂度为O(n)，所以总时间复杂度为O(1)+O(n)=O(n)。

如果是要在链表中实现随机访问或者是根据下标访问，那么需要根据头结点进行遍历查询，时间复杂度为O(n)。

 

 

🍃3.2 循环链表

循环链表和单链表非常类似，唯一区别在于：循环列表的尾节点后继指针指向首节点的地址，因此又称为单循环列表。

 

 

  • 循环链表是无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理更加方便灵活。

  • 循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p-＞next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。

  • 在单链表中，从一已知结点出发，只能访问到该结点及其后续结点，无法找到该结点之前的其它结点。而在单循环链表中，从任一结点出发都可访问到表中所有结点，这一优点使某些运算在单循环链表上易于实现。

但是在实际应用中，循环列表好像只适用于简单的循环列表类型的问题处理。

🍃3.3 双向链表

双向链表的结点除了存储数据和后继指针next之外，还会存储前一个结点的地址，即前驱指针pre，用来向前查询当然，尾结点的后继指针依旧指向一个空地址，头结点的前驱指针也是如此。

和单链表相比，存储相同的数据，由于需要存放两个指针数据，需要消耗更多的存储空间。

 

 

双向链表在各种操作时的复杂度分析会是什么样的呢？

3.3.1 插入操作

双向链表的插入操作也是O(1)级别，好像在效率上没有提升，甚至好像还有些降低，因为单链表只需要修改后继结点，双向链表需要修改前驱结点和后继结点的值。但是如果是删除操作，那么复杂度的提升还是比较明显；

 

3.3.2 删除操作

 

删除操作分为2种情况：给定数据值删除对应节点和给定节点地址删除节点。

对于给定数据值删除对应节点，单链表和双向链表都需要从头到尾进行遍历从而找到对应节点进行删除，时间复杂度为O(n)。

删除给定指针指向的结点:这种情况是已经找到了要删除的元素,我们只需要执行删除操作即可.

对比分析：

  • 针对单链表而言:单链表如果要删除一个结点q.必须要知道这个结点的前驱结点是谁,修改前驱结点的指针指向即可.单链表找某个结点的前驱结点,只能从头开始遍历. 临界值 p->next == q;说明p就是q的前驱结点.所以在单链表中,找这个前驱结点的平均时间复杂度为O(n),然后执行删除操作的时间复杂度为O(1). 根据时间复杂度分析的加法法则: 删除给定指针指向的结点 --> 单链表的总的时间复杂度为O(n).

  • 针对双链表而言: 双链表要删除一个结点q.也必须得知道这个结点的前驱结点和后继结点. 修改前驱结点的后继指针next和后继结点的前驱指针prev即可.而针对双链表而言,找q的前驱结点和q的后继结点的时间复杂度都为O(1).而执行删除操作(修改指针指向)的时间复杂度也为O(1). 根据时间复杂度分析的加法法则: 删除给定指针指向的结点 --> 双链表的总的时间复杂度为O(1).

至于查找，的时间复杂度均为O(n)。 对于最基本的CRUD操作，双链表优势在于删除给定节点。但其劣势在于浪费存储空间（若从工程角度考量，则其维护性和可读性都更低）。

3.3.3 查找操作

无序链表，那么查询元素都需要从头结点进行遍历查询，双向链表并没有什么优势。

有序链表，双向链表的按值查询效率要比单链表高一些。因为我们可以记录上次查找的位置p，每一次查询时，根据要查找的值与p的大小关系，决定是往前还是往后查找，所以平均只需要查找一半的数据。

🍃3.4 双向循环链表

了解了上面的循环链表以及双向链表，两者结合就是双向循环链表，即：首节点的前驱指针指向尾节点，尾节点的后继指针指向首节点，如图所示。

 

 

 

单链表的缺点是只能往前，不能后退，虽然有循环单链表，但后退的成本还是很高的，需要跑一圈。在这个时候呢，双向链表就应运而生了，再加上循环即双向循环链表就更加不错了。所谓双向链表只不过是添加了一个指向前驱结点的指针，而双向循环链表是将最后一个结点的后继指针指向头结点。

四、使用链表的目的？

“链表是为了解决什么问题而出现的”、

“有没有更优方案”、“如何找出更优方案”、

“如何证明方案更优”……从而

“当我遇到某个难题时，该如何优雅的解决它？”

🍃3.1 为了解决什么问题而出现的？

为了解决动态数量的数据存储。

举个例子：我们要管理一堆票据，可能有一张，但也可能有一亿张。

怎么办呢？申请50G的大数组等着？万一用户只有一百张票据要处理呢？万一申请少了又不够用呢？

用数组的话，删除然后添加票据，是每次删除让后面五百万张往前移一格呢等等，有太多问题。

那么，此时链表就是个很有效的数据结构，可以很有效的管理这类不定量的数据。

🍃3.2 有没有更优方案？

  • 时间上：链表无法支持搜索，想找到特定数据只能遍历。

  • 空间上：链表每个数据要额外占用一个指针的空间；对于int等基本数据类型，数据量暴增一倍（单链表）甚至两倍。

所以，为了在时间上优化它，可以搞成二叉树；然后通过先序/后序/中序遍历取得按一定规律排布的数据；也可以通过和根节点比较来快速确定数据在排序二叉树的左还是右子树上——这就得到了O(logN)的时间复杂度的查询效率。那么二叉树的查询效率怎样才能更高，性能更稳定，于是就有了满二叉树、平衡树、红黑树等概念/算法。

堆是一种优化到极致的二叉树；它实际上就是一个数组，左右节点对应的数组下标可以直接计算出来——这就省掉了指向子节点的指针。

五、链表的面试算法题

🍃1.环形链表

题目

 

思路一：哈希表法

  • HashSet的底层是HashMap实现

/**
     * 思路一：哈希表
     * @param head
     * @return
     */ 
public boolean hasCycle(ListNode head) {
        //创建hashSet
        HashSet<ListNode> hashSet = new HashSet<ListNode>();
        while (head != null) {
            //hashSet.add(head) 如果里面没有该节点返回true，并且将head节点添加到hashSet里面
            //如果里面有该节点返回false
            if (!hashSet.add(head)) {
                return true;
            }
            head = head.next;
        }
​
        return false;
    }
​
    public class ListNode {
        int val;
        ListNode next;
​
        ListNode() {
        }
​
        ListNode(int val) {
            this.val = val;
        }
​
        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

思路二：快慢指针

/**
     * 思路二：快慢指针
     * @param head
     * @return
     */
    public boolean hasCycle2(ListNode head) {
        if(head == null) return false;
        //创建快慢指针，同时指向head
        ListNode fast = head,slow = head;
        //使用do while处理特殊情况：指针从头开始
        do{
            //无环情况：快指针或快指针的下一个指针域指向null
            if(fast  == null || fast.next == null){
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
​
        }while(fast != slow);
        //有环情况：fast=slow，且没有返回false
        return true;
    }
​
    //默认链表结构体
    public class ListNode {
        int val;
        ListNode next;
​
        ListNode() {
        }
​
        ListNode(int val) {
            this.val = val;
        }
​
        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

🍃2.环形链表 II

题目

 

思路一：哈希表法

/**
     * 思路一：哈希表
     * @param head
     * @return
     */
    public ListNode detectCycle(ListNode head) {
        //创建hashSet
        HashSet<ListNode> hashset = new HashSet<ListNode>();
        while(head != null){
            //有环情况：当存入重复值代表有环，add返回false，进入if循环，返回head。
            if(!hashset.add(head)){
                return head;
            }
            head = head.next;
        }
        //无环情况：在哈希表里存的所有值都没有重复，则表示无环
        return null;
    }

思路二：快慢指针

 

解题步骤：
1.找到相遇点
2.找对入环点

解题思路：
找到入环点关键：
相遇点到入环点距离=起始点到入环距离（相遇时一个指针往后走，另一个指针从开头走，两指针在入环点相遇）
分析：
1.fast快指针每步比slow慢指针快一步
2.当slow指针到环时距离为a，fast指针速度是slow的2倍，所以距入环点也是a，假设剩余环长度为x，所环长为a+x。
3.此时slow指针距离fast指针长度为a，fast指针追上slow指针需要追x步，每一轮fast指针会追上slow指针一步，所以入环点到相遇点的距离为x，相遇点到入环点距离=a，起始点到入环点距离也等于a。

细节：ListNode fast = head, slow = head;
快慢指针同时出发利于计算


/**
     * 思路二：快慢指针
     */
    public ListNode detectCycle2(ListNode head) {
        if (head == null) return null;
        ListNode fast = head, slow = head;
        do {
             //无环情况：快指针或快指针的下一个指针域指向null
            if (fast == null || fast.next == null) return null;
            slow = slow.next;
            fast = fast.next.next;
        } while (fast != slow);
        fast = head;
        while (fast != slow) {
            fast = fast.next;
            slow = slow.next;

        }
        return fast;
    }

    //默认链表结构体
    public class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

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

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }                         
                 

🍃3.快乐数

题目

 

解题思路：
1.快慢指针法
2.每个位置平方和getNext方法
3.无环fast == 1 || getNext(fast) == 1时，是快乐数
3.有环，快慢指针相遇。则不是快乐数

 

 

思路一：快慢指针

/**
     * 思路：快慢指针法
     */
//    public static boolean isHappy(int n) {
//        int fast = n, slow = n;
//        do {
//            //无环情况：即无无限循环且最终为1，即为快乐数
//            if (fast == 1 || getNext(fast) == 1) return true;
//            slow = getNext(slow);
//            fast = getNext(getNext(fast));
//
//        } while (fast != slow);
//        //有环情况：即快慢指针相遇，有环且无限循环，所以不是快乐数
//        return false;
//    }

    /**
     * 优化
     * @param n
     * @return
     */
    public static boolean isHappy(int n) {
        int fast = n, slow = n;
        do {
            slow = getNext(slow);
            fast = getNext(getNext(fast));

        } while (fast != slow && fast != 1);
        //有环情况：即快慢指针相遇，有环且无限循环，或者fast != 1,所以不是快乐数
        //无环情况：循环结束后，fast = 1，是快乐数。
        return fast == 1;
    }
    //求每个位置上的数字的平方和
    public static int getNext(int n) {
        int sum = 0;
        while (n > 0) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }

    /**
     * 测试
     * @param args
     */
    public static void  main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(isHappy(n));
    }

优化详解：

do {
            slow = getNext(slow);
            fast = getNext(getNext(fast));

        } while (fast != slow && fast != 1);
        //有环情况：即快慢指针相遇，有环且无限循环，或者fast != 1,所以不是快乐数
        //无环情况：循环结束后，fast = 1，是快乐数。
        return fast == 1;

将if (fast == 1 || getNext(fast) == 1) return true;移出来是因为并不会报空指针异常，从而减少运算次数。

🍃4.反转链表

题目

 

思路一：迭代-三指针移动法

public  ListNode reverseList(ListNode head) {
        ListNode pre = null,curr = head,next = null;
        while(curr != null){
            //第一步处理next指针在curr后面
            next = curr.next;
            //反转
            curr.next = pre;
            //指针向后移动
            pre = curr;
            curr = next;
        }
        //curr=null,反转结束，返回pre。
        return pre;
    }

    //默认链表结构体
    public  class ListNode{
        int val;
        ListNode next;

       ListNode(){

       }
       ListNode(int val){
           this.val = val;
       }
       ListNode(int val,ListNode next){
           this.val = val;
           this.next = next;
       }
    }

思路二：递归

 

 

递去：

 

 

归来：子问题解决措施：head.next.next = head、head.next = null。

 

 

依次归去解决每个子问题。

 

    public  ListNode reverseList(ListNode head) {
    	//递归终止条件
      if (head == null || head.next == null) {
            return head;
        }
    	//递归到最小子问题后，返回最小子问题的head节点。
        ListNode p = reverseList(head.next);
    	//归来处理
        head.next.next = head;
        head.next = null;
    	//返回反转后的头节点
        return p;
    }

🍃5.反转链表 II

 

迭代-三指针移动法

 public ListNode reverseBetween(ListNode head,int left,int right){
        //创建虚拟头节点pre，con指向pre
        ListNode pre = new ListNode(0,head),con =pre;
        int n = right - left + 1;
        //将con指向left的前一个节点
        while(left > 1){
            con = con.next;
            left--;
        }
        //将[left-right]范围的几点反转，并将[left-right]的第一个节点指向[left-right]最后一个节点的下一个节点。
        con.next = reverseList(con.next,n);
        //返回头节点，因为pre虚拟头节点在头节点前面
        return pre.next;
    }
    //反转[left-right]范围节点函数
    public  ListNode reverseList(ListNode head,int n) {
        ListNode pre = null,curr = head,next = null;
        //[left-right]范围需要反转的次数n
        while(n > 0){
            //第一步处理next指针在curr后面
            next = curr.next;
            //反转
            curr.next = pre;
            //指针向后移动
            pre = curr;
            curr = next;
            n--;
        }
        //反转结束，此时curr在right.next，head.next位于left.next上。
        head.next = curr;
        //返回pre，pre位于right节点上
        return pre;
    }


    //默认链表结构体
    public class ListNode {
        int val;
        ListNode next;

        ListNode() {

        }

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

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

🍃6.k个一组翻转链表

 

源码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {

            ListNode hair =new ListNode(0,head),pre = hair,tail = null;
            while(head != null){
                tail = pre;
                for(int i = 0;i<k;i++){
                    tail = tail.next;
                    if(tail == null){
                        return hair.next;
                    }
                }
                ListNode[] reverse = reverse(head,tail);
                head = reverse[0];
                tail = reverse[1];
                pre.next = head;
                pre = tail;
                head = pre.next;
            }
            return hair.next;

    }
    public ListNode[] reverse(ListNode head ,ListNode tail){
        ListNode pre = tail.next,curr = head ,next = null;
        while(pre != tail){
            next = curr.next;
            curr.next = pre;
            pre = curr;
            curr = next;
        }
        return new ListNode[]{tail,head};
    }
}

🍃7. 旋转链表

 

源码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null||head.next == null) return head;
        int length =1;
        ListNode oldTail = head;
        //计算链表长度
        while(oldTail.next != null){
            oldTail = oldTail.next;
            length++;
        }
        //成环
        oldTail.next = head;
        //找到新的尾节点
        ListNode newTail = head;
        for(int i =0 ;i<length-k%length -1;i++){
            newTail = newTail.next;
        }
        //找到新的头节点
        ListNode newHead = newTail.next;
        //断尾
        newTail.next = null;
        return newHead;
    }
}

🍃8.两两交换链表中的节点

 

源码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        //定义虚拟头节点
        ListNode hair  = new ListNode(0,head),pre = hair;
        while(pre.next != null && pre.next.next != null){
            ListNode one = pre.next;
            ListNode two = pre.next.next;
            one.next = two.next;
            two.next = one;
            pre.next = two;
            pre = one;
        }
        return hair.next;
    }
}

🍃9. 删除链表的倒数第 N 个结点

 

源码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode hair = new ListNode(0,head),slow = hair, fast = head;
        while(n>0){
            fast = fast.next;
            n--;
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return hair.next;
    }
}

🍃10 . 删除排序链表中的重复元素

 

源码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
            ListNode curr = head;
            while(curr != null && curr.next != null){
                if(curr.val == curr.next.val){
                    curr.next = curr.next.next;
                }else{
                    curr = curr.next;
                }

            }
            return head;
    }
}

🍃11. 删除链表中的重复元素II

源码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode hair = new ListNode(0,head),pre = hair,curr = head;
        while(curr != null){
            while(curr.next != null && curr.val == curr.next.val){
                curr = curr.next;
            }
            if(pre.next == curr){
                pre = pre.next;
            }else{
                pre.next = curr.next;
            }
            curr = curr.next;
        }
        return hair.next;
    }
}

super_zjl
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
什么是链表
m0_68990465的博客
05-02 2534
文章目录 单向链表 双向链表 链表的概念 1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。 我们可以把链表类比成火车，每一列火车由若干个车厢组成，每个车厢就是一个Node结点，由多个Node结点组成的对象就是链表对象。火车的不同车厢之间都是通过挂钩连接的，当两个车厢之间脱钩之后，两个车厢就没有任何关系了。 1.单向链表 2.双向链表 代码如下...
linux内核链表
09-22
博客详细讲解Linux内核链表，教你看懂Linux内核链表与普通链表有什么不一样
10.Python修炼之路【14-链表】2018.05.11
youyouwuxin1234的博客
05-11 766
关键字 
什么是链表？（图解）
热门推荐
十二匹的博客
09-09 4万+
一：链表是什么 1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。 2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。 3、相对于线性表顺序结构，操作复杂。 4.链表分为 （1）单链表 （2）双链表 （3）单向循环链表 （4）双向循环链表 二：...
链表是什么？
weixin_30737363的博客
08-05 598
链表是由一个一个的结点组成的。什么是结点呢？请看下图…… 2.那么结点的组成是什么呢？也就是说怎么才能实现那样的结点呢？请看下图…… 其实上面的图也没有解决我刚刚说的问题， 好了，直接说了吧， 结点的实现是用结构体来实现的。 没错，就是 结构体 了。 上面的图像能够让我们更加清楚的认识到 写链表用的结构体和平常用的结构体的区别。 真的是这样的，你看出来了吗？ 没有的...
看完还不懂HashMap算我输（附职场面试常见问题）
12-21
1. 为什么使用链表+数组而不是单纯的链表？答案是数组提供了快速的索引访问，而链表解决哈希冲突，两者的结合实现了高效且灵活的存储。 2. 为什么不用LinkedList代替数组？虽然LinkedList实现了动态增长，但在...
C语言实现冒泡排序，如果你还不懂请查看
最新发布
11-08
//什么是冒泡排序？ //冒泡排序是一种简单的排序算法，它的工作原理是比较列表中的相邻元素，如果元素不符合指定顺序，则交换它们。它是一种就地且稳定的排序算法，可以对数组和链表等数据结构中的项进行排序。 // /...
Python双向循环链表实现方法分析
12-23
如果不懂什么是双向循环链表的伙伴，需要补习一下数据结构的基础之后哦~~~ 在python当中 用一个类Node 来实现链表的节点，节点数据有三个变量： prev：前驱指针： 用于指向当前节点前一个节点 next: 后继指针 ...
C#模拟链表数据结构的实例解析
12-31
模块化编程是大多数初学者必经之路，然后可能你走向了结构化编程，链表是一种典型结构模式，它的出现克服了数组必须预先知道大小的缺陷，听不懂?你只需要记住，链表结构非常牛叉就可以了，学习这种结构对我们的逻辑...
什么是链表？
weixin_60297362的博客
09-29 1857
目录 一、链表是什么 二、链表的作用 三、链表和数组的区别 一、链表是什么 1.链表是一种常见的存储解构，它有着非连续性、非顺序性的特点。数据元素的逻辑顺序是通过链表中每个节点里的指针地址所实现的，又一些列节点组成，节点可动态生成。 2.每个节点包括两个区域 存储数据内容的数据区域 存储下一个节点地址的指针区域，其示意如下图： 每个结点的存储单元是独立的，若干个结点通过指针域依次相链接可构成一个链表。其示意如下图： 3.链表可分为： （1）单链表 （2...
链表是什么（循环链表、双向链表）
Seina
03-28 2716
链表 链表不需要一块连续的内存空间，它通过指针将一组零散的内存块串联起来使用。其中每个内存块叫做链表的结点，记录下个结点地址的指针叫做后继指针。 一 单链表 链表的插入和删除是非常快速的，因为不需要做数据搬移，但是链表想要随机访问第k个元素就没有数组那么高效了，因为链表的数据不是连续的，没办法将首地址和下标带入寻址公式直接计算出对应的内存地址，而是需要根据指针一个结点一个结点的一次遍历，直到找到相...
链表
ChiBa_YAO
04-17 574
什么是链表链表是一种用于存储数据集合的数据结构。链表有以下属性： - 相邻元素之间通过指针连接 - 最后一个元素的后继指针值为null - 在程序执行过程中，链表的长度可以增加或者缩小 - 链表的空间能够按需分配（直到系统内存耗尽） - 没有内存空间的浪费（但是链表中的指针需要一些额外的内存开销）
[数据结构]什么是链表?
菜鸟腾飞
07-14 1万+
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的–百度百科 大致分为单链表和双向链表 1.单链表:每个节点包含两部分,一部分存放数据变量的data,另一部分是指向下一节点的next指针 2.双向链表:除了包含单链表的部分,还增加的pre前一个节点的指针 链表的优点在于,不需要连续的存储单元,修改链表的复杂度为O(1) (在不考虑查找时) 但是...
链表是啥？如何搞定它?
村雨遥
07-06 332
链表是一种递归的数据结构，或者为空null，或者指向一个结点（node）的引用，一个结点含有一个泛型元素和一个指向另一条链表的引用。单向链表：结点被分成两个部分。第一个部分保存或者显示关于结点的信息，第二个部分存储下一个结点的地址，只能向一个方向遍历。双向链表：每个数据结点中都有两个指针，分别指向直接后继和直接前驱。循环链表：一种链式存储结构，它的最后一个结点指向头结点，形成一个环。
链表（详解）
m0_69323023的博客
08-30 7919
1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。3、相对于线性表顺序结构，操作复杂。
我画了20张图，终于让女朋友学会了翻转链表
weixin_41385912的博客
12-29 367
前言 如果说数据结构是算法的基础，那么数组和链表就是数据结构的基础。因为像堆，栈，树，图等比较复杂的数组结基本上都可以由数组和链表来表示，所以掌握数组和链表的基本操作十分重要。 链表的知识点蛮多的，所以分成上下两篇，这篇主要讲解链表翻转的解题技巧，下篇主要讲关于链表快慢指针的知识点，干货很多，建议先收藏再看。认真看完保证收获满满！ 今天就来看看链表的基本操作及其在面试中的常见解题思路,本文...
什么是链表，要求新手能看懂
03-26
链表是一种常见的数据结构，在计算机编程中用于存储和管理数据。链表是由一系列节点组成的，每个节点包含了数据和指向下一个节点的指针。节点之间通过指针相互连接，形成一个链式的结构。 与数组相比，链表可以动态地添加或删除元素，因此更加灵活。另外，链表并不要求所有的节点在内存中连续存储，因此可以节省空间。 链表可以分为单向链表和双向链表。单向链表只能从头节点顺序遍历到尾节点，而双向链表则可以从头节点或尾节点开始往后或往前遍历。 总之，链表是一种重要的数据结构，在编程中被广泛应用。学习链表有助于提高编程能力和解决复杂的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值