链表实现——c语言

链表是一种经典的数据结构，在很多软件里大量使用。在面试中链表题目数量少，类型也相对固定，考察频率却非常高，因此我们只需将常见题目都学完即可。

一、单链表的概念

   任何数据结构的基础都是`创建+增删改查`，由于几个操作可以构造很多算法题，因此我们也将从这五项开始学习链表。

1.1什么是链表？

使用链表存储数据，不强制要求数据在内存中集中存储，各个元素可以分散存储在内存中，例如，使用链表存储{4，15，7，40}，各个元素在内存中的存储状态可能如下图所示：

        显然，我们只需记住元素4的存储位置，通过他的指针就可以找到元素15，通过元素15的指针就可以找到元素7，并以此寻找接下来的元素。

        可以看到数据不仅没有集中存放，在内存中的存储次序也是混乱的。链表存储数据间逻辑关系的实现方案是：为每一个元素配置一个指针，每个元素的指针都指向自己的直接后继元素。

        像图上这样，数据元素随机存储在内存中，通过指针维系数据之间“一对一”的逻辑关系，这样的存储结构就是链表。

思考你是否理解了链表的含义呢？思考下面两幅图，是否都满足单链表的要求，为什么？

        上面第一个图是满足单链表的要求的，因为我们说链表要求环环相扣，核心是一个节点只能有一个被指向。第一个图中，c1被a2和b3同时指向，这是没有问题的。
        图二不满足需求，因为c1有两个后继节点a5和b4。
        另外在做题的时候要注意比较的是值还是节点，有时可能两个节点的值相等，但并不是同一个节点，如下图所示：

1.2链表的相关概念

节点和头节点
        在链表中，每个点都由值和指向下一个结点的地址组成的独立单元，称为一个结点，有时也称节点，其含义是一样的。
        对于单链表如果知道了第一个元素，就可以通过遍历访问整个链表，因此，第一个节点最重要，一般被称为——头节点
虚拟节点
        在做题以及工程里经常会看到虚拟节点的概念，其实就是一个节点dummyNode，其next指针指向head，也就是dummyNode.next=head。
        因此，如果我们在算法中使用了虚拟节点，则要注意如果要获得head节点，或者从方法（函数）里返回的时候，则因使用dummyNode.next。
        另外注意，dummyNode的val不会被使用，初始化0或者-1等都是可以的。既然值不会使用，那虚拟节点有啥用呢？简单来说，就是为了方便我们处理首部节点，否则我们要在代码里单独处理首部节点的问题。在链表反转里，我们可以看到该方式可以大大降低解题难度。

二、如何构造链表？

        链表的基本单位是节点，在链表中，每个节点元素都配有一个指针，这意味着，链表上的每个元素都长成下图样子：

        数据域用来存储元素的值，指针域用来存放指针。数据结构中，通常将上图这样的整体成为节点。也就是说，链表中实际存放的是一个个节点，数据元素放在各个节点的数据域中，举个简单的例子，图三中{1，2，3}的存储状态用链表表示：

由此我们可以给出以下定义：

typedef struct link{
    char elem;//代表数据
    struct link * next;//代表指针，指向直接后继元素
}Link;

不过呐，在LeetCode中一般采取如下的方式：

struct LisNode{
    int val;//代表数据
    struct LisNode *next;//代表指针
};

为了保证我i们的代码在LeetCode中可以直接执行，我们后面的代码都采用此方式进行。
如果我们要创建一个值为{0，1，2，3，4}的链表，可以这么做：
参考文件basic_linklist.cpp

struct LisNode* initLink{
    int i;
    //创建头指针
    struct ListNode* p = NULL;
    //创建头节点
    struct ListNode* temp = (struct ListNode*)malloc(sizeof(struct ListNode));
    temp->val = 0;
    temp->next = NULL;
    //头指针指向头节点
    p = temp;
    //每创建一个节点。都令其直接前驱节点的指针指向它
    for (i = 1;i < 5;i++){
        //创建一个节点
        struct ListNode* a = (struct ListNode*)malloc(sizeof(struct ListNode));
        a->val = i;
        a->next = NULL;
        //每次temp指向的节点就是a的直接前驱节点
        temp->next = a;
        //temp指向下一个节点(也就是a)，为下次添加节点做准备
        temp = temp->next;
    }
    return p;
}

测试方法：

int main(){
    struct LisNode* p = NULL;
    printf("初始化列表为：\n");
    //创建链表{1，2，3，4}
    p = initLink();
    return 0;
}

三、链表的增删改查

3.1遍历链表

参考文件basic_linklist.cpp
对于单链表，不管进行什么操作，一定是从头开始逐个向后访问，所以操作之后是否还能找到表头非常重要。一定要注意“狗熊掰棒子”的问题，也就是只顾当前位置而将标记头的指针丢掉了。

代码如下：

//打印链表
void printList(struct ListNode* p){
    struct ListNode* temp = p;//temp指针用来遍历链表
    //只要temp指向的next值不是NULL，就执行输出语句
    while(temp){
        //struct ListNode* f = temp;//准备释放链表中的节点
        printf("%d",temp->val);
        temp = temp->next;
        //free(f);
    }
    printf("\n");
}


//获取链表的长度
int32_t getLength(struct ListNode* p){
    struct ListNode* temp = p;//temp指针用来遍历链表
    int length = 0;
    //只要temp指向的next值不是NULL，就执行输出语句
    while(temp){
        //struct ListNode* f = temp;//准备释放链表中的节点
        length++;
        temp = temp->next;
        //free(f);
    }
    return length;
}

测试方法：

int main() {
    struct ListNode* p = NULL;
    printf("create list:\t\n");
    //创建链表{1，2，3，4}
    p = initLink();
    printList(p);
    int length = getLength(p);
    printf("List length:%d\n",length);
    return 0;
}

3.2链表插入

参考文件basic_Linklist_crud.cpp
单链表的插入和数组的插入一样，过程不复杂，但是在编码时会发现处处是坑。单链表的插入操作要考虑三种情况：

• 首部插入
• 中部插入
• 尾部插入

（1）在链表的表头插入

        链表表头插入新节点非常简单，容易出错的是经常忘了head需要重新指向表头。我们创建一个新节点newNode，怎样连接到原来的链表上呢？执行newNode->next = head即可。之后我们要遍历新链表就从newNode开始一路next向下就行了，但是我们还是习惯让head来表示，所以让head = newNode就行了。

（2）在链表中间插入

        在中间位置插入，我们必须先遍历找到要插入的位置，然后将当前位置接入到前驱节点和后去节点之间，但是到了该位置我们是无法获取前驱节点的，也就无法将节点接入进来了。就好比“一边过河一边拆桥”。接过导致无法回溯。
为此我们要在目标节点的前一个结点停下来，也就是用cur->next=node(7)了就应该停下来，此时cur->val=15。然后需要给newNode前后接两根线，此时只能先让newNode->next = Node(15)->next(图中虚线)；然后Node(15)->Next=newNode,而且顺序不能出错。
为什们不能颠倒顺序？
        由于每个节点都只有一个next，因此执行了Node(15)->Next=newNode之后，节点15和7之间的连线就自动断开了，如下图所示：

总结
先处理后面的线，在处理前面的线。否则会出现断链的情况

（3）在单链表的结尾插入节点

表尾插入就比较容易了，我们只需要将尾节点指向新节点就行了。

综上，我们写出链表插入的方法如下图所示

struct ListNode* insertNode(struct ListNode* head,struct ListNode* nodeInsert,int position){
    if (head == NULL){
        //这里可以认为待插入的节点就是链表的头节点，也可以抛出不能插入的异常
        return nodeInsert;
    }
    int size = getLength(head);
    if (position > size + 1 || position < 1){
        printf("位置参数越界");
        return head;
    }
    //插入节点到头部
    if (position == 1){
        nodeInsert->next = head;
        head = nodeInsert;
        return head;
    }
    struct ListNode* pNode = head;
    int count = 1;
    //遍历列表，找到插入位置前的一个节点
    while (count < position - 1){
        pNode = pNode->next;
        count++;
    }
    nodeInsert->next = pNode->next;
    pNode->next = nodeInsert;
    return head;
}

测试方法：

void testInsert() {
    struct ListNode* head = NULL;
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = 1;
    //插入第一个元素
    head = insertNode(head,node,1);
    printfList(head);

    //插入第二个元素，因为前面有一个元素，这里就在尾部插入即可
    node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val=3;
    head = insertNode(head,node,2);
    printfList(head);

    //插入第三个元素，前面插了两个，所以这里就是中间位置插入了
    node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = 2;
    head = insertNode(head,node,2);
    printfList(head);
}

        这里需要补充一点，head == null的时候，我们应该采取什么样的操作？如果是null的话，你要插入的节点就是链表的头节点，也可以不插入抛出异常即可，一般来说我们更加倾向于前者。
如果链表是单调递增的，一般会让你插入到合适的位置，序列任然保持单调。

3.3链表的删除

参考文件basic_linklist_crud.cpp

• 删除头部元素
• 删除中间元素
• 删除尾部元素

（1）删除表头节点

        删除头部元素还是比较简单的，一般只需要执行head = head->next就行了。如下图所示，将head向前移动一次后，原来的节点不可达，然后就将其删掉了。

（2）删除最后一个节点

        删除的过程不算复杂，也是找到要删除结点的前驱节点，这里同样要在提前一个位置进行判断，例如下图中的删除40，其前驱节点为7.遍历的时候需要判断cur->next是否为40，如果是，则只要执行cur->next = NULL即可;此时几点40就可以放心删除。

（3）删除中间节点

        删除中间节点时，也要会用cur.next来比较，找到位置后，将cur->next指针的值更新为cur->next->next，然后就可以放心的将nod（7）删除掉了。

完整实现：

struct ListNode* deleteNode(struct ListNode*head,int position){
    if(head == NULL){
        return NULL;
    }
    int size = getLength(head);
    if (position > size||position < 1){
        printf("输入的参数有误\n");
        return head;
    }
    if (position == 1){
        struct ListNode* curNode = head;
        head = head->next;
        free(curNode);
        return head;
    }
    else{
         struct ListNode* cur = head;
        int count = 1;
        while(count < position - 1){
            cur = cur->next;
            count++;
        }
        struct ListNode*tmp = cur->next;
        cur->next = tmp->next;
        free(tmp);
        return head;
    }
}

测试方法：

void testDelete(){
    struct ListNode* p = NULL;
    printf("create list:\t\n");

    //创建链表0~9
    p = initLink();
    printfList(p);

    //删除第一个元素0
    p = deleteNode(p,1);
    printfList(p);

    //删除中间元素
    p = deleteNode(p,5);
    printfList(p);

    //删除尾部元素
    p = deleteNode(p,8);
    printfList(p);
}