【数据结构-链表】链表的基本操作

编写插入函数和删除函数的思路：

先考虑一般情况；
再考虑在链表头部的操作；
最后考虑在链表尾部的操作。

1 单向链表

1.1 有头结点的单向链表

1.1.1 数据结构定义

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

1.1.2 初始化建立链表

头插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head;
    int x;

    // 建立头结点
    head = (LinkList) malloc(sizeof(LinkList));
    head->next = NULL;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->next = head->next; // 新结点的指针域指向头结点的后继结点
        head->next = newNode; // 头结点的指针域指向新结点
    }
    
    return L;
}

尾插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head, *tail;
    int x;

    // 建立头结点
    head = (LinkList) malloc(sizeof(LinkList));
    head->next = NULL;
    tail = head;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->next = NULL;
        tail->next = newNode; // 原先尾结点的指针域指向新结点
        tail = newNode; // 尾指针指向新结点
    }
    
    return L;
}

1.1.3 按序号查找结点

LinkNode *GetNumNode (LinkList &L, int pos){
    LinkNode *findNode = L; // 初始指向头结点
    
    if (pos == 0) // 第 0 个结点即头结点
        return L;
    else if (pos < 0) // 必须为非负值
        return NULL;
    
    while ((findNode != NULL) && (pos != 0)){
        findNode = findNode->next;
        pos--;
    }
    return findNode;
}

1.1.4 按值查找结点

LinkNode *GetDataNode (LinkList &L, const int x){
    LinkNode *findNode = L;
    
    while ((findNode != NULL) && (findNode->data != x))
        findNode = findNode->next;

    return findNode;
}

1.1.5 插入操作

新结点插入到第 pos 个位置上（找到其前驱结点即第 pos-1 个结点，进行后插操作）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    
    if (pos <= 0) // 不能插在头结点的位置上
        return false;
    
    posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
    if (posPrev == NULL)
        return false;
    posNode = posPrev->next;
    
    newNode = (LinkNode *) malloc(sizeof(LinkNode));
    newNode->data = x;
    newNode->next = posNode; // 新结点的指针域指向原先第 pos 个结点
    posPrev->next = newNode; // 第 pos-1 个结点的指针域指向新结点
    
    return true;
}

新结点插入到第 pos 个位置上（找到该结点即第 pos 个结点，进行伪前插操作，实质是新结点插入到第 pos 个结点的后面，然后交换数据域）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posNext; // 记录第 pos+1 个结点
    
    if (pos <= 0) // 不能插在头结点的位置上
        return false;
    
    posNode = GetNumNode(L, pos); // 先找到第 pos 个结点
    if (posNode == NULL)
        return false;
    posNext = posNode->next; // 记录第 pos+1 个结点
    
    newNode = (LinkNode *) malloc(sizeof(LinkNode));
    newNode->data = posNode->data; // 交换数据，posNode 变为新结点，newNode 变为旧结点
    newNode->next = posNext; 
    posNode->data = x;
    posNode->next = newNode; 
    
    return true;
}

1.1.6 删除操作

删除第 pos 个结点（找到其前驱结点即第 pos-1 个结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posNext; // 记录第 pos+1 个结点
    
    if (pos <= 0) // 不能删除头结点
        return false;
    
    posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
    if (posPrev == NULL)
        return false;
    posNode = posPrev->next; // 记录第 pos 个结点
    posNext = posNode->next; // 记录第 pos+1 个结点
    
    posPrev->next = posNext; // 第 pos-1 个结点的指针域指向原先第 pos 个结点的后继结点（即原先第 pos+1 个结点）
    free(posNode);
    
    return true;
}

删除第 pos 个结点（找到该结点即第 pos 个结点，将其后继结点的值赋值给第 pos 个结点，然后删除其后继结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posNext; // 记录第 pos+1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    
    if (pos <= 0) // 不能删除头结点
        return false;
    
    posNode = GetNode(L, pos); // 先找到第 pos 个结点
    if (posNode == NULL)
        return false;
    posNext = posNode->next; // 记录第 pos+1 个结点
    
    if (posNext != NULL){ // 如果第 pos 个结点不是最后一个结点
        posNode->data = posNext->data; // 将其后继结点的值赋值给第 pos 个结点
        posNode->next = posNext->next; // 更新指针域
        free(posNext);
    }
    else{ // 如果第 pos 个结点是最后一个结点
        free(posNode);
        前驱结点的指针域 = NULL; // 这里还是需要再遍历一遍链表找到前驱结点，比较麻烦
    }
    
    return true;
}

1.2 无头结点的单向链表

1.2.1 数据结构定义

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

1.2.2 初始化建立链表

头插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head;
    int x;

    // 建立第一个结点
    x = 读入数据;
    head = (LinkList) malloc(sizeof(LinkList));
    head->data = x;
    head->next = NULL;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->next = head;
        head = newNode; // 头指针指向新结点
        L = head; // 更新头指针（即链表的入口）
    }
    
    return L;
}

尾插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head, *tail;
    int x;

    // 建立第一个结点
    x = 读入数据;
    head = (LinkList) malloc(sizeof(LinkList));
    head->data = x;
    head->next = NULL;
    tail = head;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->next = NULL;
        tail->next = newNode; // 原先尾结点的指针域指向新结点
        tail = newNode; // 尾指针指向新结点
    }
    
    return L;
}

1.2.3 按序号查找结点

LinkNode *GetNumNode (LinkList &L, int pos){
    LinkNode *findNode = L; // 初始时指向链表头部
    
    if (pos < 1) // 必须为非负值
        return NULL;
    
    while ((findNode != NULL) && (pos != 0)){
        findNode = findNode->next;
        pos--;
    }
    return findNode;
}

1.2.4 按值查找结点

LinkNode *GetDataNode (LinkList &L, const int x){
    LinkNode *findNode = L; // 初始时指向链表头部
    
    while ((findNode != NULL) && (findNode->data != x))
        findNode = findNode->next;

    return findNode;
}

1.2.5 插入操作

新结点插入到第 pos 个位置上（找到其前驱结点即第 pos-1 个结点，进行后插操作）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    
    if (pos <= 0) // 不能插在头结点的位置上
        return false;
    
    if (pos == 1){ // 如果要插入到第 1 个位置
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->next = L; // 指针域指向头结点
        L = newNode; // 更新头指针（即链表的入口）
    }
    else{
        posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
        if (posPrev == NULL)
            return false;
        posNode = posPrev->next; // 记录第 pos 个结点
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->next = posNode; // 新结点的指针域指向原先第 pos 个结点
        posPrev->next = newNode; // 第 pos-1 个结点的指针域指向新结点
    }
    
    return true;
}

新结点插入到第 pos 个位置上（找到该结点即第 pos 个结点，进行伪前插操作，实质是新结点插入到第 pos 个结点的后面，然后交换数据域）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posNext; // 记录第 pos+1 个结点
    
    if (pos <= 0) // 不能插在头结点的位置上
        return false;
    
    posNode = GetNumNode(L, pos); // 先找到第 pos 个结点
    if (posNode == NULL)
        return false;
    posNext = posNode->next;
    
    newNode = (LinkNode *) malloc(sizeof(LinkNode));
    newNode->data = posNode->data; // 交换数据，posNode 变为新结点，newNode 变为旧结点
    newNode->next = posNext; 
    posNode->data = x;
    posNode->next = newNode; 
    
    return true;
}

1.2.6 删除操作

删除第 pos 个结点（找到其前驱结点即第 pos-1 个结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posNext; // 记录第 pos+1 个结点
    
    if (pos <= 0)
        return false;
    
    if (pos == 1){ // 如果要删除第 1 个结点
        posNext = L->next; // 记录第 2 个结点
        free(L);
        L = posNext; // 头指针指向第 2 个结点
    }
    else{
        posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
        if (posPrev == NULL)
            return false;
        posNode = posPrev->next; // 记录第 pos 个结点
        posNext =  posNode->next; // 记录第 pos+1 个结点
        posPrev->next = posNext; // 第 pos-1 个结点的指针域指向原先第 pos 个结点的后继结点（即原先第 pos+1 个结点）
        free(posNode);
    }
    
    return true;
}

删除第 pos 个结点（找到该结点即第 pos 个结点，将其后继结点的值赋值给第 pos 个结点，然后删除其后继结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posNext; // 记录第 pos+1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    
    if (pos <= 0)
        return false;
    
    posNode = GetNumNode(L, pos); // 先找到第 pos 个结点
    if (posNode == NULL)
        return false;
    posNext = posNode->next; // 记录第 pos+1 个结点
    
    if (posNext != NULL){ // 如果第 pos 个结点不是最后一个结点
        posNode->data = posNext->data; // 将其后继结点的值赋值给第 pos 个结点
        posNode->next = posNext->next; // 更新指针域
        free(posNext);
    }
    else{ // 如果第 pos 个结点是最后一个结点
        free(posNode);
        前驱结点的指针域 = NULL; // 这里还是需要再遍历一遍链表找到前驱结点，比较麻烦
    }
    
    return true;
}

2 双向链表

2.1 有头结点的双向链表

2.1.1 数据结构定义

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

2.1.2 初始化建立链表

头插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head;
    int x;

    // 建立头结点
    head = (LinkList) malloc(sizeof(LinkList));
    head->prev = NULL;
    head->next = NULL;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = head;
        newNode->next = head->next; // 新结点的指针域指向头结点的后继结点
        head->next = newNode; // 头结点的指针域指向新结点
    }
    
    return L;
}

尾插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head, *tail;
    int x;

    // 建立头结点
    head = (LinkList) malloc(sizeof(LinkList));
    head->prev = NULL;
    head->next = NULL;
    tail = head;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = tail;
        newNode->next = NULL;
        tail->next = newNode; // 原先尾结点的指针域指向新结点
        tail = newNode; // 尾指针指向新结点
    }
    
    return L;
}

2.1.3 按序号查找结点

LinkNode *GetNumNode (LinkList &L, int pos){
    LinkNode *findNode = L; // 初始指向头结点
    
    if (pos == 0) // 第 0 个结点即头结点
        return L;
    else if (pos < 0) // 必须为非负值
        return NULL;
    
    while ((findNode != NULL) && (pos != 0)){
        findNode = findNode->next;
        pos--;
    }
    return findNode;
}

2.1.4 按值查找结点

LinkNode *GetDataNode (LinkList &L, const int x){
    LinkNode *findNode = L;
    
    while ((findNode != NULL) && (findNode->data != x))
        findNode = findNode->next;

    return findNode;
}

2.1.5 插入操作

新结点插入到第 pos 个位置上（找到其前驱结点即第 pos-1 个结点，进行后插操作）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    
    if (pos <= 0) // 不能插在头结点的位置上
        return false;
    
    posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
    if (posPrev == NULL)
        return false;
    posNode = posPrev->next; // 记录第 pos 个结点
    
    newNode = (LinkNode *) malloc(sizeof(LinkNode));
    newNode->data = x;
    newNode->prev = posPrev; // 新结点的前驱指针域指向第 pos-1 个结点
    newNode->next = posNode; // 新结点的后继指针域指向第 pos 个结点
    posPrev->next = newNode; // 第 pos-1 个结点的后继指针域指向新结点
    posNode->prev = newNode; // 第 pos 个结点的前驱指针域指向新结点
    
    return true;
}

新结点插入到第 pos 个位置上（找到该结点即第 pos 个结点，进行前插操作）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    
    if (pos <= 0) // 不能插在头结点的位置上
        return false;
    
    posNode = GetNumNode(L, pos); // 先找到第 pos 个结点
    if (posNode == NULL)
        return false;
    posPrev = posNode->prev; // 记录第 pos-1 个结点
    
    newNode = (LinkNode *) malloc(sizeof(LinkNode));
    newNode->data = x;
    newNode->prev = posPrev; // 新结点的前驱指针域指向第 pos-1 个结点
    newNode->next = posNode; // 新结点的后继指针域指向第 pos 个结点
    posPrev->next = newNode; // 第 pos-1 个结点的后继指针域指向新结点
    posNode->prev = newNode; // 第 pos 个结点的前驱指针域指向新结点
    
    return true;
}

2.1.6 删除操作

删除第 pos 个结点（找到其前驱结点即第 pos-1 个结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posNext; // 记录第 pos+1 个结点
    
    if (pos <= 0) // 不能删除头结点
        return false;
    
    posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
    if (posPrev == NULL)
        return false;
    posNode = posPrev->next; // 记录第 pos 个结点
    posNext = posNode->next; // 记录第 pos+1 个结点
    posPrev->next = posNext; // 第 pos-1 个结点的后继指针域指向原先第 pos 个结点的后继结点（即原先第 pos+1 个结点）
    posNext->prev = posPrev; // 第 pos+1 个结点的前驱指针域指向原先第 pos 个结点的前驱结点（即原先第 pos-1 个结点）
    free(posNode);
    
    return true;
}

删除第 pos 个结点（找到该结点即第 pos 个结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posNext; // 记录第 pos+1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posPrev; // 记录第 pos-1 个结点
    
    if (pos <= 0) // 不能删除头结点
        return false;
    
    posNode = GetNumNode(L, pos); // 先找到第 pos 个结点
    if (posNode == NULL)
        return false;
    posNext = posNode->next; // 记录第 pos+1 个结点
    posPrev = posNode->prev; // 记录第 pos-1 个结点
    
    if (posNext != NULL){ // 如果第 pos 个结点不是最后一个结点
        posPrev->next = posNext;
        posNext->prev = posPrev;
        free(posNode);
    }
    else{ // 如果第 pos 个结点是最后一个结点
        posPrev->next = NULL;
        free(posNode);
    }
    
    return true;
}

2.2 无头结点的双向链表

2.2.1 数据结构定义

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

2.2.2 初始化建立链表

头插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head;
    int x;

    // 建立第一个结点
    x = 读入数据;
    head = (LinkList) malloc(sizeof(LinkList));
    head->data = x;
    head->prev = NULL;
    head->next = NULL;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = NULL;
        newNode->next = head;
        head = newNode; // 头指针指向新结点
        L = head; // 更新头指针（即链表的入口）
    }
    
    return L;
}

尾插法：

LinkList InitList (LinkList &L){
    LinkNode *newNode, *head, *tail;
    int x;

    // 建立第一个结点
    x = 读入数据;
    head = (LinkList) malloc(sizeof(LinkList));
    head->data = x;
    head->prev = NULL;
    head->next = NULL;
    tail = head;
    L = head;
    
    while (不符合终止条件){
        x = 读入数据;
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = tail;
        newNode->next = NULL;
        tail->next = newNode; // 原先尾结点的指针域指向新结点
        tail = newNode; // 尾指针指向新结点
    }
    
    return L;
}

2.2.3 按序号查找结点

LinkNode *GetNumNode (LinkList &L, int pos){
    LinkNode *findNode = L; // 初始时指向链表头部
    
    if (pos < 1) // 必须为非负值
        return NULL;
    
    while ((findNode != NULL) && (pos != 0)){
        findNode = findNode->next;
        pos--;
    }
    return findNode;
}

2.2.4 按值查找结点

LinkNode *GetDataNode (LinkList &L, const int x){
    LinkNode *findNode = L; // 初始时指向链表头部
    
    while ((findNode != NULL) && (findNode->data != x))
        findNode = findNode->next;

    return findNode;
}

2.2.5 插入操作

新结点插入到第 pos 个位置上（找到其前驱结点即第 pos-1 个结点，进行后插操作）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    
    if (pos <= 0) 
        return false;
    
    if (pos == 1){ // 如果要插入到第 1 个位置
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = NULL;
        newNode->next = L;
        L = newNode; // 更新头指针（即链表的入口）
    }
    else{
        posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
        if (posPrev == NULL)
            return false;
        posNode = posPrev->next; // 记录第 pos 个结点
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = posPrev; // 新结点的前驱指针域指向第 pos-1 个结点
        newNode->next = posNode; // 新结点的后继指针域指向第 pos 个结点
        posPrev->next = newNode; // 第 pos-1 个结点的后继指针域指向新结点
        posNode->prev = newNode; // 第 pos 个结点的前驱指针域指向新结点
    }
    
    return true;
}

新结点插入到第 pos 个位置上（找到该结点即第 pos 个结点，进行前插操作）：

bool InsertNode (LinkList &L, int pos, const int x){
    LinkNode *newNode; // 新结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posPrev; // 记录第 pos+1 个结点
    
    if (pos <= 0) 
        return false;
    
    if (pos == 1){ // 如果要插入到第 1 个位置
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = NULL;
        newNode->next = L;
        L = newNode; // 更新头指针（即链表的入口）
    }
    else{
        posNode = GetNumNode(L, pos); // 先找到第 pos 个结点
        if (posPrev == NULL)
            return false;
        posPrev = posNode->prev; // 记录第 pos-1 个结点
        newNode = (LinkNode *) malloc(sizeof(LinkNode));
        newNode->data = x;
        newNode->prev = posPrev; // 新结点的前驱指针域指向第 pos-1 个结点
        newNode->next = posNode; // 新结点的后继指针域指向第 pos 个结点
        posPrev->next = newNode; // 第 pos-1 个结点的后继指针域指向新结点
        posNode->prev = newNode; // 第 pos 个结点的前驱指针域指向新结点
    }
    
    return true;
}

2.2.6 删除操作

删除第 pos 个结点（找到其前驱结点即第 pos-1 个结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posPrev; // 记录第 pos-1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posNext; // 记录第 pos+1 个结点
    
    if (pos <= 0) 
        return false;
    
    if (pos == 1){ // 如果要删除第 1 个结点
        posNext = L->next; // 记录第 2 个结点
        free(L);
        L = posNext; // 更新头指针（即链表的入口）
    }
    else{
        posPrev = GetNumNode(L, pos-1); // 先找到第 pos-1 个结点
        if (posPrev == NULL)
            return false;
        posNode = posPrev->next; // 记录第 pos 个结点
        posNext = posNode->next; // 记录第 pos+1 个结点
        posPrev->next = posNext; // 第 pos-1 个结点的后继指针域指向原先第 pos 个结点的后继结点（即原先第 pos+1 个结点）
        posNext->prev = posPrev; // 第 pos+1 个结点的前驱指针域指向原先第 pos 个结点的前驱结点（即原先第 pos-1 个结点）
        free(posNode);
    }
    
    return true;
}

删除第 pos 个结点（找到该结点即第 pos 个结点）：

bool DeleteNode (LinkList &L, int pos){
    LinkNode *posNext; // 记录第 pos+1 个结点
    LinkNode *posNode; // 记录第 pos 个结点
    LinkNode *posPrev; // 记录第 pos-1 个结点
    
    if (pos <= 0) 
        return false;
    
    if (pos == 1){ // 如果要删除第 1 个结点
        posNext = L->next; // 记录第 2 个结点
        free(L);
        L = posNext; // 更新头指针（即链表的入口）
    }
    else{
        posNode = GetNumNode(L, pos); // 先找到第 pos 个结点
        if (posNode == NULL)
            return false;
        posNext = posNode->next; // 记录第 pos+1 个结点
        posPrev = posNode->prev; // 记录第 pos-1 个结点
        
        if (posNext != NULL){ // 如果第 pos 个结点不是最后一个结点
            posPrev->next = posNext;
            posNext->prev = posPrev;
            free(posNode);
        }
        else{ // 如果第 pos 个结点是最后一个结点
            posPrev->next = NULL;
            free(posNode);
        }
    }
    
    return true;
}

原文地址：http://www.cnblogs.com/Mount256/p/16831113.html

1. 本站所有资源来源于用户上传和网络，如有侵权请邮件联系站长！ 2. 分享目的仅供大家学习和交流，请务用于商业用途! 3. 如果你也有好源码或者教程，可以到用户中心发布，分享有积分奖励和额外收入！ 4. 本站提供的源码、模板、插件等等其他资源，都不包含技术服务请大家谅解！ 5. 如有链接无法下载、失效或广告，请联系管理员处理！ 6. 本站资源售价只是赞助，收取费用仅维持本站的日常运营所需！ 7. 如遇到加密压缩包，默认解压密码为"gltf",如遇到无法解压的请联系管理员！ 8. 因为资源和程序源码均为可复制品，所以不支持任何理由的退款兑现，请斟酌后支付下载声明：如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性