005数组链表

---

title: 05-07 数组和链表
date: 2019/11/23
tags: 数据结构与算法
categories:

• 算法

---

数组和链表

数组

数组是一种线性表数据结构。它用一种连续的内存空间，来存储一组具有相同类型的数据。

数组的关键词

1. 线性表
   • 除了数组，还有链表、队列、栈
   • 与之相对的叫非线性表，如二叉树、堆、图
2. 连续的内存空间和相同类型的数据
   • 随机访问
   • 插入删除需要做大量的数据搬移
3. 警惕数组访问越界问题
4. 容器能否完全替代数组
   • 如 Java 里的 ArrayList 。其优势：①.将很多数组操作的细节封装起来 ②.支持动态扩容
   • 使用经验
     1. Java ArrayList无法存储基本类型，比如int、long，需要封装为Integer、Long类，而Autoboxing、Unboxing则有一定的性能消耗，所以如果特别关注性能，或者希望使用基本类型，就可以选用数组。
     2. 如果数组大小事先已知，并且对数据的操作非常简单，用不到 ArrayList 提供的大部分方法，也可以直接使用数组。
     3. 还有一个作者个人喜好，当要表示多维数组时，用数组往往会更加直观。比如 Object[][]array ;而用容器的话需要这样定义：ArrayList< ArrayList >array。
   • 对于业务开发，直接使用容器就足够了，省时省力。毕竟损耗一点点性能，完全不会影响到系统的整体性能。
   • 但如果你是做一些非常底层的开发，比如开发网络框架，性能的优化就需要做到极致，这时候数组就会优于容器，成为首选。

练习

1. JVM的标记清除垃圾回收算法
   • 这是最基础的垃圾回收算法，之所以说它是最基础的是因为它最容易实现，思想也是最简单的。标记-清除算法分为两个阶段：标记阶段和清除阶段。标记阶段的任务是标记出所有需要被回收的对象，清除阶段就是回收被标记的对象所占用的空间。
   • 标记-清除算法实现起来比较容易，但是有一个比较严重的问题就是容易产生内存碎片，碎片太多可能会导致后续过程中需要为大对象分配空间时无法找到足够的空间而提前触发新的一次垃圾收集动作（gc）。
2. 二维数组的内存寻址公式
   • 二维数组A[m][n]采用行序为主方式存储，每个元素占K个存储单位，并且第一个元素的存储地址是LOC(A[0][0]),则A[i][j]的地址是LOC(A[0][0])+(n* i+j) *k；

链表

如何实现LRU缓存淘汰算法

• 缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的CPU缓存、数据库缓存、浏览器缓存等等。

• 缓存的大小有限，当缓存被用满时，哪些数据应该被保留？这就需要缓存淘汰策略来决定。常见的缓存淘汰策略有三种：

  • 先进先出策略FIFO (First In,First Out)
  • 最少使用策略LFU (Least Frequently Used)
  • 最近最少使用策略LRU (Least Recently Used)

• 思路

  • 维护一个有序单链表，越靠近链表尾部的结点是越早之前访问的。当有一个新的数据被访问时，我们从链表头开始顺序遍历链表。
  1. 如果此数据之前已经被缓存在链表中了，我们得遍历得到这个数据对应的节点，并将其从原来的位置删除，然后再插入到链表的头部。
  2. 如果此时缓存未满，则将此结点直接插入到链表的头部。
  3. 如果此时缓存已满，则链表尾结点删除，将新的数据节点插入链表的头部。
  • 缓存访问的时间复杂度是O(n)
  • 如果要优化这个思路，可以引入散列表（Hash Table）来记录每个数据的位置，将缓存访问的时间复杂度降到O(1)

链表结构

三种常见的链表结构：单链表、双链表和循环列表。

1. 单链表
   • 插入删除操作O(1)、随机访问O(n)
2. 循环链表
   • 一种特殊的单链表，跟单链表唯一区别就在尾结点：单链表的尾结点指针指向空地址，循环链表的尾结点指针指向链表的头结点。
   • 与单链表相比，循环链表优点在于从链尾到链头比较方便。
   • 当处理的数据具有环型结构特点时，就特别适合采用循环链表。比如著名的约瑟夫斯问题。
3. 双向链表
   • 单向链表只有一个方向，结点只有一个后继指针next指向后面的结点，而双向链表支持两个方向。
   • 每个节点不只有一个后继指针指向后面的节点，还有一个前驱指针指向前面的节点。
   • 从结构上看，双向链表可以支持O(1)时间复杂度的情况下找到前驱节点，正是这样的特点，也使双向链表在某些情况下的插入、删除等操作逗比单链表简单、高效。
   • 对于一个有序链表，双向链表的按值查询的效率也比单链表高一些。可以记录上次查找的位置p，每次查询时，根据要查找的值与p的大小关系，决定是否往前还是往后查找，所以平均只需要查找一半的数据。
   • 在实际的软件开发中，双向链表尽管比较费内存，但还是比单链表应用更广泛。
4. 双向循环列表

空间换时间思想

• 缓存实际上就是利用了空间换时间的设计思想。
  如果我们把数据存储在硬盘上，会比较节省内存，但每次查找数据都要访问一次硬盘，会比较慢。但如果我们通过缓存技术，事先将数据加载在内存中，虽然会比较耗费内存空间，但是每次数据查询的速度就大大提高了。
• 对于执行较慢的程序，可以通过消耗更多的内存来进行优化。（空间换时间）
• 而消耗过多内存的程序可以通过消耗更多时间来降低内存的消耗。（时间换空间）

课后思考

1. 判断一个字符串是回文字符串，如果字符串是单链表存储的，怎么判断？时间空间复杂度是多少？

• 解答
  1. 使用快慢指针找到链表中点
  2. 将后半部分 reversed
  3. 一个指针在头部，一个指针在中点再逐个比较

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        //只有一个点或空的情况
        if(head==null||head.next==null)
        {
            return true;
        }
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode fast=dummy;
        ListNode slow=dummy;
        //慢指针走一步，快指针走两步，快指针到终点的时候，慢指针到正中间。
        while(fast!=null&&fast.next!=null)
        {
            slow=slow.next;
            fast=fast.next.next;
        }
        //断开链表，快指针在后半段的起点，慢指针在前半段的起点
        fast=slow.next;
        slow.next=null;
        slow=dummy.next;
        //反转后半段
        ListNode pre=null;
        while(fast!=null){
            ListNode nextTmp=fast.next;
            fast.next=pre;
            pre=fast;
            fast=nextTmp;
        }
        //挨个比较前后半段
        while(pre!=null){
            if(slow.val!=pre.val){
                return false;
            }
            slow=slow.next;
            pre=pre.next;
        }
        return true;        
    }
}

如何轻松写出正确的链表代码

技巧

1. 理解指针或引用的含义
   • C语言中叫指针，Java、Python中叫引用。
   • 将某个变量赋值给指针，实际就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。
   • 如 p->next=q 意思是p结点中的next指针存储了q结点的内存地址。
   • p->next=p->next->next 表示p结点的next指针存储了p结点的下下一个结点的内存地址。
2. 警惕指针丢失和内存泄露
   • 插入结点时，一定要注意操作的顺序。
   • 删除节点是，记得手动释放内存空间。（Java虚拟机自动管理内存的编程语言不需要考虑这么多）
3. 利用哨兵简化实现难度
   • 链表的插入删除操作，对于插入第一个结点和删除最后一个结点需要特殊处理，代码繁琐，因此可以引入哨兵结点。这种带哨兵的链表也叫带头链表。
   • 很多代码实现中都用到利用哨兵简化编程难度，比如插入排序、归并排序、动态规划等。
4. 重点留意边界条件处理
   • 如果链表为空时，代码能否正常工作？
   • 如果链表只包含一个结点时，代码能否正常工作？
   • 如果链表只包含两个结点时，代码能否正常工作？
   • 代码逻辑在处理头结点和尾结点的时候，是否能正常工作？
5. 举例画图，辅助思考
6. 多写多练，没有捷径

精选五个链表操作

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

1. 单链表反转

//迭代方法：每个节点指向前一个节点
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode perv=null;
        ListNode curr=head;
        
        while(curr!=null)
        {
            ListNode nextTmp=curr.next;
            curr.next=perv;
            perv=curr;
            curr=nextTmp;
        }
        return perv;
    }
}
//我放弃递归方法

2. 链表中环的检测

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

3. 两个有序的链表合并

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead=new ListNode(0);
        ListNode prev=prehead;
        while(l1!=null&&l2!=null){
            if(l1.val<=l2.val){
                 prev.next=l1;
                 l1=l1.next;
            }else{
                 prev.next=l2;
                 l2=l2.next;
            }
            prev=prev.next;
        }
        if(l1==null)
        {
            prev.next=l2;
        }else{
            prev.next=l1;
        }
        
        return prehead.next;
    }
}

4. 删除链表倒数第n个结点

//方法一：两次遍历，先算出链表长度length，再删掉第length-n的节点
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next=head;
        int length=0;
        ListNode first=head;
        while(first!=null)
        {
            first=first.next;
            ++length;
        }
        first=dummy;
        length-=n;
        while(length>0)
        {
            length--;
            first=first.next;
        }
        first.next=first.next.next;
        return dummy.next;
    }
}
//方法二：双指针
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next=head;
        ListNode first=dummy;
        ListNode second=dummy;
        for(int i=0;i<n;i++)
        {
            first=first.next;
        }
        while(first.next!=null)
        {
            first=first.next;
            second=second.next;
        }
        second.next=second.next.next;
        return dummy.next;
    }
}

5. 求链表的中间结点

• 上面思考题中有通过快慢指针求出中间结点。

课后思考

1. 还有什么场景可以利用哨兵大大地简化代码难度？

链表VS数组性能比拼

1. 时间复杂度

   • 数组：插入删除O(n) 随机存储O(1)
   • 链表：插入删除O(1) 随机存储O(n)
   • 对比不能仅仅局限于时间复杂度，实际开发中不能仅仅利用复杂度分析就决定使用哪个数据结构来存储数据。

2. 数组简单易用，实现上使用的是连续的内存空间，可以借助CPU的缓存机制，预读数组中的数据，所以访问效率更高。而链表在内存中并不是连续存储，所以对CPU缓存不友好，没办法预读。

3. 数组的缺点是大小固定，一经声明就要占用整块连续内存空间。如果声明的数组过大，系统可能没有足够的连续内存空间分配给它，导致内存不足（out of memory）。如果声明的数组过小，则可能出现不够用的情况，这时只能再申请一个更大的内存空间，把原数组拷贝进去，非常费时。链表本身没有大小的限制，天然地支持动态扩容，我觉得这也是它与数组最大的区别。

4. 如果你的代码对内存的使用非常苛刻，那数组就更适合你。因为链表中的每个节点都需要消耗额外的存储空间去存储一份指向下一个结点的指针，所以内存消耗会翻倍。而且，对链表进行频繁的插入、删除操作，还会导致频繁的内存申请和释放，容易造成内存碎片，如果是Java语言，就有可能会导致频繁的GC（Garbage Collection，垃圾回收）

5. 所以，在实际的开发中，针对不同类型的项目要根据具体情况，权衡是选择数组还是链表。