【数据结构】链表(含链式前向星)

链表为什么断不了？是拿振金做的吗？
说了队列，说了栈，无论什么数据结构都离不开只能按一定顺序储存的结果，向特定位置加入某值的复杂度达不到O(1)O(1)O(1)。天空一声巨响，链表闪亮登场链表就是这千千万万数据结构中的一个例外。

链表的模型就是一条链（废话）！我们可以向这条链的任意一个地方加入一个新的节点，也可以删除任意的一个节点。

1.模型

链表，顾名思义，是以链的形式来储存一个表。而这个链就很有意思了，有条件的可以哪一个项链看一下，我们从任意一个节点出发，都可以直接找的它前后的节点，为了满足这个性质，我们可以对每个节点增加两个储存的量：指向前一个点的指针 fromfromfrom，指向后一个点的指针 tototo 。这样，每个点除了储存这个点的值，还储存了分别指向前后点的指针。

可以发现，项链总有个首尾，链表也一样。我们可以设立两个坐标，代表链表的头和链表的尾，即 headheadhead 和 tailtailtail 坐标。我们链表的第一个节点的前节点指针指向 headheadhead 坐标，最后一个节点的后节点指针指向 tailtailtail 坐标。所以链表的模型如图所示：
代码：

/*指针版*/                      /*下标版*/
struct link {                   struct link{int value;/*数据*/                int value;/*数据*/link* from, to;/*指针*/       int from, to;/*指针*/
};/*数据结构*/                  }Link[Size];/*数据结构*/    link* head, tail;               int head, tail, tot;void init() {                   void init() {                   head = new link();             head = 1, tail = 2;tail = new link();                tot = 2;head->to = tail;               Link[head].to = tail;tail->from = head;                Link[tail].from = head;
}/*初始化链表*/                  }

2.操作

1.添加节点

由于链表的性质，链表的添加节点操作支持在任意一个你能找到的节点添加。

当我们在某一位置添加节点时，我们需要知道这个位置所对应的的 fromfromfrom 指针和 tototo 指针。例如图示链表，我们要在 222 号节点后加入 777 号节点。
我们首先要找到 222 号节点，再通过 222 号节点的 tototo 指针找到 333 号节点。接下来，为了让 777 号节点紧跟在 222 号节点的后面，我们需要将 222 号节点的 tototo 指针从指向 333 变为指向 777 。同时，为了不破坏链表的连通性，我们需要将 777 的 tototo 指针指向 333。然后将 777 号、333 号的 fromfromfrom 指针更新。
在其他位置的除收尾外与上述情况相似。如果在收尾添加节点的话，只需要将首节点的 fromfromfrom 指针（或尾节点的 tototo 指针）指向所添加的节点，在将该节点的 tototo 指针（或 fromfromfrom 指针）指向首节点（或尾节点）并将其 fromfromfrom 指针指向 headheadhead 位置（或将其 tototo 指针指向 tailtailtail）位置。

代码：

/*指针版*/                          /*下标版*/
void insert(Link* p, int val) {     void insert(int p, int val) {link *q = new Link();             int q = ++tot;q->value = val;                        Link[q].value = val;p->to->from = q;                    Link[Link[p].to].from = q;q->to = p->to;                        Link[q].to = Link[p].to;p->to = q;                         Link[p].to = q;q->from = p;                        Link[q].from = p;
}                                   }

2.删除节点

与添加节点相似，链表中删除节点只需要知道被删除节点的 fromfromfrom （或tototo ）指针指向的节点就能进行删除操作。如图，要将 222 号节点与 444 号节点之间的 333 号节点删除时。我们首先要知道 333 号节点的位置，然后，将 333 号节点 fromfromfrom 指针指向的节点的 tototo 指针指向 333 号节点 tototo 指针指向的节点。最后维护链表连通性即可。

可以看到，对点的删除，实际上是将链表中的某个点从链表中孤立出来。

代码：

/*指针版*/                                  /*下标版*/
void remove(Link* p) {                      void remove(int p) {p->to->from = p->from;                            Link[Link[p].to].from = Link[p].from;p->from->to = p->to;                            Link[Link[p].from].to = Link[p].to;delete p;//一定要有，否则内存泄漏就gg了   }
}

3.遍历

遍历是链表的一个短板，由于插入和输出是没有考虑储存空间的连续性，链表中连续的数据的储存空间可能是不连续的，所以链表没法在 O(1)O(1)O(1) 的复杂度下找到某一特定点，只能通过遍历的方法来查找。
代码：

/*指针版*/                          /*下标版*/
//正向搜索特定值
Link* search(Link* p, int val) {            int search(int p, int val) {if (p->value == val)                       if (Link[p].value == val)return p;                                    return p;search(p->to, val);                         search(Link[p].to, val);
}                                           }
//int main() 内
search(head, val);                          search(head, val);//反向搜索特定值
Link* search(Link* p, int val) {            int search(int p, int val) {if (p->value == val)                       if (Link[p].value == val)return p;                                    return p;search(p->from, val);                       search(Link[p].from, val);
}                                           }
//int main() 内
search(tail, val);                          search(tail, val)

此时，我们可以发现，在添加和删除节点时，只有 tototo 或 fromfromfrom 指针中的任意一个也可以正常进行操作，唯一的不同是遍历是只能从某一方向遍历，而不能双向遍历。

4.内存归还

当我们用指针实现链表时，虽然这个链表可以动态变化长度，但是一个问题也随之而来：内存泄漏！！！因此，我们必须在指针实现的链表上加一步操作：归还所调用的内存。
代码：

void recycle() {while (head != tail) {head = head->to;delete head->from;}delete tail;
}

3.拓展——链式前向星

我们储存图时，常常需要储存大量的边，此时如何调用又成了一个问题，但我们可以发现，无论是那一条边，他们总是从某个点到另一个点（自环除外），也就是说，我们可以用出发的点 ppp 来代表一些边的集合 SSS，位于集合 SSS 的边都从 ppp 出发到另外一个点。当我们调用边时，只需要以它的出发点作为关键字，就能在一定的时间内找到这条边。

可以发现，上述方法不要求边按某种特定顺序储存，也不需要按某种顺序去遍历，只需要将所有从点 ppp 出发的边用某种方式联系起来就行了。由于 ppp 是不可能改变的，所以我们可以联想到链表的性质。链表的 headheadhead 坐标就对应这里的点 ppp ，由于没有顺序要求，可以在 O(1)O(1)O(1) 时间内在任意位置加入任意一点的链表自然成了更加方便快捷的选择。