数据结构算法设计大总结——链表篇

1.顺序表

顺序表分为静态存储的和动态存储的

1.1 顺序表的结构体

内核就是记录表+表长

静态存储结构体：

#define MAX_SIZE 100

typedef ElemType int;
typedef struct sqList
{
	ElemType list[MAX_SIZE];
	int length;  //每存储一个，就length++；
}

动态存储结构体：

typedef ElemType int;
typedef struct sqList
{
	ElemType *plist;
	int length;  //每存储一个，就length++；
}

2.链表

2.1 链表的结构体

链表结构体的核心：数据域和指针域
链表无容质疑是动态存储

单链表的结构体：

typedef int ElemType;
typedef struct LinkNode
{
	ELemType int data;
	struct LinkNode *next;
}LinkNode,*LinkList; 

双链表的结构体：

typedef  int ElemType;
typedef struct DuLinkNode
{
    ElemType data;
    struct DuLinkNode* prior;
    struct DuLinkNode* next;
}DuLinkNode,*DuLinkList;

2.2 链表的头插法与尾插法

对比记忆:
尾插法相比头插法要多设置一个tail指针，起始指向L，随着插入的数据不断发生变化，保持在始终指向最后一个元素。

链表的头插法：

int value[MAX_SIZE]={1,2,3,4}; // value 数组表示输入的数据
int value_length=4;
int index=0; //作为数据数组的下标值

--------------------------- 以下是模版--------------------------- 
//先定义头结点
L=(LinkNode *)malloc(sizeof(LinkNode));
L->next=NULL;

//头插法
while(value_length--)
{
	linkNode *p=(LinkNode *)malloc(sizeof(LinkNode));
	p->data=value[index++];
	p->next=L->next;
	L->next=p;
}

链表的尾插法：

int value[MAX_SIZE]={1,2,3,4}; // value 数组表示输入的数据
int value_length=4;
int index=0; //作为数据数组的下标值

--------------------------- 以下是模版--------------------------- 
//先定义头结点
L=(LinkNode *)malloc(sizeof(LinkNode));
L->next=NULL;

LinkNode *tail=L;


//尾插法
while(value_length--)
{
	linkNode *p=(LinkNode *)malloc(sizeof(LinkNode));
	p->data=value[index++];
	p->next=tail->next;
	tail->next=p;
	tail=p;
}

2.3 【巧用两个指针模版】找链表中倒数第n个结点

模版：
两个指针，一个先走n下，然后一起移动，直到后一个指针指到空。另一个指针所在位置就是倒数第n个结点

2.4 人为创造头指针，进行一些删除操作

在有些题目不好操作的时候，可以人为引入头指针，再进行操作

LinkNode *headLa=NULL;
headLa=(LinkNode *)malloc(sizeof(LinkNode));

2.5 合并两个有序链表为一个有序链表

再定一个空的指针，利用尾插法，将两个链表穿起来，这两个链表每次的移动，也，也变相的相当于删除了结点。当其中的某一个链表被全部加入完，结束循环。将剩下另一条链表的后序全部结点加入到新构造的链表中。

2.6【快慢指针模版】寻找链表的中间结点

定义一个快指针，定义一个慢指针。快指针走两步，慢指针走一步。快指针走完之后，慢指针肯定走了一半，故返回慢指针所指向的结点。
值得讨论的点，在于，奇数链表返回中间结点，偶数返回哪个结点？在本题中我们不难发现，偶数返回后一半的第一个结点。根据修改while（）里的条件，我们可以控制偶数返回前一半的最后一个结点或后一半的第一个结点。

    while(fast!=NULL&&fast->next!=NULL)   //返回后一半的第一个结点
    {
        fast=fast->next->next;
        slow=slow->next;
    }
    while(fast->next!=NULL&&fast->next->next!=NULL)   //返回前一半的最后一个结点
    {
        fast=fast->next->next;
        slow=slow->next;
    }

2.7 两个链表的公共后缀

两种方法：

第一种就是：
求出La，Lb的长度，然后找到较长的那个，两个链表做差，得到链表差，然后让较长的链表先移动差值个单位，然后两个链表就等长了。就可以一直后移找公共的后缀。这两个指针指向指向相同的位置即可得到公共后缀

第二种方法：
让headA指针，从头走到结束，再将headA指针从headB的路径走
让headB指针，从头走到结束，再将headB指针从headA的路径走
可以理解为，公共部分都是它们要走的长度，由于前面的部分两个指针都走的路径不同，假如让俩都走一遍这两条路径，走的就相同了。

方法二参考题解：160. 相交链表（双指针，清晰图解）

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *pA=headA;  //pA=headA->next 这个是不对的，假如只有一个元素是公共后缀，就会变成NULL和NULL，不会返回那一个元素，而是NULL
        ListNode *pB=headB;

        while(pA!=pB)
        {
            if(pA!=NULL)
            {
                pA=pA->next;
            }else{
                pA=headB;
            }
             if(pB!=NULL)
            {
                pB=pB->next;
            }else{
                pB=headA;
            }
        }
    return pA;
    }
};

2.8 【反转链表模版】将A->B->C变成C->B->A

文字描述：
定义一个pre指针，定义一个cur指针，pre最开始指向NULL，pre指向第一个结点，然后开始进行链表的反转,在这个过程中还需要一个指针p，记录cur

while(cur!=NULL)
{
	LinkNode *p=cur;
	cur->next=pre;
	pre=cur;
	cur=p;
}

2.9【拓展】排序链表