1-链表

参考链接

• 基本数据结构：链表（list）

谈到链表之前，先说一下线性表。线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表有两种存储方式，一种是顺序存储结构，另一种是链式存储结构。

顺序存储结构就是两个相邻的元素在内存中也是相邻的。这种存储方式的优点是查询的时间复杂度为O(1)，通过首地址和偏移量就可以直接访问到某元素，关于查找的适配算法很多，最快可以达到O(logn)。缺点是插入和删除的时间复杂度最坏能达到O(n)，如果你在第一个位置插入一个元素，你需要把数组的每一个元素向后移动一位，如果你在第一个位置删除一个元素，你需要把数组的每一个元素向前移动一位。还有一个缺点，就是当你不确定元素的数量时，你开的数组必须保证能够放下元素最大数量，遗憾的是如果实际数量比最大数量少很多时，你开的数组没有用到的内存就只能浪费掉了。

我们常用的数组就是一种典型的顺序存储结构，如图1。

链式存储结构就是两个相邻的元素在内存中可能不是相邻的，每一个元素都有一个指针域，指针域一般是存储着到下一个元素的指针。这种存储方式的优点是插入和删除的时间复杂度为O(1)，不会浪费太多内存，添加元素的时候才会申请内存，删除元素会释放内存，。缺点是访问的时间复杂度最坏为O(n)，关于查找的算法很少，一般只能遍历，这样时间复杂度也是线性（O(n)）的了,频繁的申请和释放内存也会消耗时间。

顺序表的特性是随机读取，也就是访问一个元素的时间复杂度是O(1)，链式表的特性是插入和删除的时间复杂度为O(1)。要根据实际情况去选取适合自己的存储结构。

链表就是链式存储的线性表。根据指针域的不同，链表分为单向链表、双向链表、循环链表等等。

一、 单向链表（slist）

链表中最简单的一种是单向链表，每个元素包含两个域，值域和指针域，我们把这样的元素称之为节点。每个节点的指针域内有一个指针，指向下一个节点，而最后一个节点则指向一个空值。如图2就是一个单向链表。

一个单向链表的节点被分成两个部分。第一个部分保存或者显示关于节点的信息，第二个部分存储下一个节点的地址。单向链表只可向一个方向遍历。

delete()函数，删除第一个值为x的节点，如图4。

insert()和insertHead()函数，在p节点后插入值为x的节点。如图5。

img

二、 双向链表

双向链表的指针域有两个指针，每个数据结点分别指向直接后继和直接前驱。单向链表只能从表头开始向后遍历，而双向链表不但可以从前向后遍历，也可以从后向前遍历。除了双向遍历的优点，双向链表的删除的时间复杂度会降为O（1），因为直接通过目的指针就可以找到前驱节点，单向链表得从表头开始遍历寻找前驱节点。缺点是每个节点多了一个指针的空间开销。如图6就是一个双向链表。

img

节点类，链表中的每一个节点就是一个节点类的对象。

class YYNode {
    var next: YYNode? = nil
    var prev: YYNode? = nil
    var value: T?
    
    init(value: T) {
        self.value = value
    }
    
    func unbind() {
        next = nil
        prev = nil
    }
    func cleanup() {
        unbind()
        value = nil
    }
}

链表类

class YYList {
    var head: YYNode?
    var tail: YYNode?
    var length: Int = 0
    
    func insertHead(value: T) {
        let node = YYNode(value: value)
        insertNodeHead(node)
    }
    func insertTail(value: T) {
        let node = YYNode(value: value)
        insertNodeTail(node)
    }
    func search(value: T) -> YYNode? {
        var temp = head
        while (temp != nil) {
            if value == temp!.value {
                return temp
            }
            temp = temp?.next
        }
        return nil
    }
    func delete(value: T) -> Bool {
        if let node = search(value) {
            deleteNode(node)
            return true
        }
        return false
    }
    
    func insertNodeHead(node: YYNode) {
        node.unbind()
        if length == 0 {
            head = node
            tail = node
        } else {
            node.next = head
            head?.prev = node
            head = node
        }
        length += 1
    }
    func insertNodeTail(node: YYNode) {
        node.unbind()
        if length == 0 {
            head = node
            tail = node
        } else {
            node.prev = tail
            tail?.next = node
            tail = node
        }
        length += 1
    }
    
    func deleteNode(node: YYNode) {
        if node === head {
            head = head?.next
        } else if node === tail {
            tail = tail?.prev
        } else {
            node.prev?.next = node.next
            node.next?.prev = node.prev
        }
        node.unbind()
        length -= 1
    }
}

三、 循环链表

循环链表就是让链表的最后一个节点指向第一个节点，这样就形成了一个圆环，可以循环遍历。单向循环链表可以单向循环遍历，双向循环链表的头节点的指针也要指向最后一个节点，这样的可以双向循环遍历。如图7就是一个双向循环链表。

img

四、 链表相关问题

1、如何判断一个单链表有环

采用快慢步长法。令两个指针p和q分别指向头结点，p每次前进一步，q每次前进两步，如果p和q能重合，则有环。可以这么理解，这种做法相当于p静止不动，q每次前进一步，所有肯定有追上p的时候。

2、如何判断一个环的入口点在哪里

分别从链表头和碰撞点，同步地一步一步前进扫描，直到碰撞，此碰撞点即是环的入口。

3、如何知道环的长度

从碰撞点开始，两个指针p和q，q以一步步长前进，q以两步步长前进，到下次碰撞所经过的操作次数即是环的长度。这很好理解，比如两个运动员A和B从起点开始跑步，A的速度是B的两倍，当A跑玩一圈的时候，B刚好跑完两圈，A和B又同时在起点上。此时A跑的长度即相当于环的长度。

4、如何知道两个单链表（无环）是否相交

法一：将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个新链表。问题转化为求这个新链表是否有环的问题。

法二：两个链表相交，则从相交的节点起，其后的所有的节点都是都是两个链表共有的。因此，如果它们相交，则最后一个节点一定是共有的。因此，判断两链表相交的方法是：遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交。

5、如果两个单链表（无环）相交，如何知道它们相交的第一个节点是什么

将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个环。问题转化为求这个环的入口问题。

6、如何知道两个单链表（有环）是否相交

分别判断两个链表A、B是否有环（注，两个有环链表相交是指这个环属于两个链表共有）

如果仅有一个有环，则A、B不可能相交

如果两个都有环，则求出A的环入口，判断其是否在B链表上，如果在，则说明A、B相交。

7、如果两个单链表（有环）相交，如何知道它们相交的第一个节点是什么

分别计算出两个链表A、B的长度LA和LB（环的长度和环到入口点长度之和就是链表长度），参照问题3。

如果LA>LB，则链表A指针先走LA-LB，链表B指针再开始走，则两个指针相遇的位置就是相交的第一个节点。

如果LB>LA，则链表B指针先走LB-LA，链表A指针再开始走，则两个指针相遇的位置就是相交的第一个节点。

答案