单链表（带表头）

链表的创建插入删除遍历逆序等操作

//链表节点创建
typedef struct Node
{
    int data;         //数据域
    struct Node *Next;//指针域
}NODE, *LinkList;

//链表节点初始化data为-1
NODE *ListInit()
{
    NODE *pNode;
    pNode = (NODE*)malloc(sizeof(NODE));
    if (pNode == NULL){}
    pNode->Next = NULL;
    pNode->data = -1;
    return pNode;
}

//链表元素的尾插
NODE* InsertEnd(NODE *pHead,int value)
{
    NODE *node = (NODE*)malloc(sizeof(NODE));
    if (node!=NULL)
    {
        NODE *current = pHead;
        while (current->Next!=NULL)
        {
            current = current->Next;
        }
        node->data = value;
        node->Next = current->Next;
        current->Next = node;
        return pHead;
    }
}

//链表元素的头插
NODE* InsertFront(NODE *pHead, int value)
{
    NODE *node = (NODE*)malloc(sizeof(NODE));
    if (node != NULL)
    {
        NODE *current = pHead;
        node->Next = current->Next;
        node->data = value;
        current->Next = node;
        return pHead;
    }
}

//删除链表中为value的节点，所有的value
NODE* RemoveNode(NODE* pHead,int value)
{
    if (!pHead)
    {
        return pHead;
    }
    NODE *current = pHead->Next;
    NODE *pre = pHead;
    while (current!=NULL)
    {
        if (current->data == value)
        {
            NODE* node = current;
            current = current->Next;
            pre->Next = current;
            free(node);
            node = NULL;
        }
        else
        {
            current = current->Next;
            pre = pre->Next;
        }
    }
    return pHead;
}

//遍历链表
void PrintList(NODE * pHead)
{
    if (!pHead)
    {
        printf("list is NULL\n");
        return;
    }
    NODE* current = pHead->Next;//头结点的下一个节点
    //NODE* current = pHead;
    while (current!=NULL)
    {
        printf(" %d, ", current->data);
        current = current->Next;
    }
    printf("\n");
}

//递归逆序打印
void ReversePrintList(NODE * pHead)
{
    if (pHead != NULL)
    {
        if (pHead->Next!=NULL)
            ReversePrintList(pHead->Next);
        printf(" %d, ", pHead->data);
    }
}

void traverse(Node* head)
{
    if(head==NULL)
        return;
    traverse(head->next);
    print(head->data);
}

//获取链表的长度
int GetListLength(NODE *phead)
{
    if (!phead)
    {
        return 0;
    }
    NODE *current = phead->Next;//不算头节点
    int length = 0;
    while (current != NULL)
    {
        length++;
        current = current->Next;
    }
    return length;
}

//链表的逆序
//创建一个尾节点，从头节点的下一个节点开始一个一个指向尾节点，最终将头节点指向原来的尾节点
NODE *ReverseList(NODE *pHead)      
{
    if (!pHead||!pHead->Next)
    {
        return pHead;
    }
    NODE *prev= NULL;               //左节点
    NODE *current = pHead->Next;    //中间节点
    NODE *ptmp = NULL;              //右节点
    while (current!=NULL)
    {
        ptmp = current->Next;
        if (ptmp==NULL)             //原链表的尾节点
        {
            pHead->Next = current;
        }
        current->Next = prev;
        prev = current;
        current = ptmp;
    }
    return pHead;
}

//逆序,
Node* reverseList(Node* head)
{
    Node* prev=NULL;
    while(head!=NULL)
    {
        Node* curr = head;
        curr->next=prev;
        prev=curr;
        head = head->next;
    }
    return prev;
}
//递归
Node* reverseList(Node* head)
{
    if(head == NULL) return head;
    if(head->next=NULL) return head;
    Node* newHead=reverseList(head->next);
    head->next->next=head;
    head->next=NULL;
    return newHead;
}

//find middle node
Node* findMiddle(Node* head)
{
    if(NULL == head || NULL == head->next)
        return head;
    Node* slow = head;
    Node* fast = head;
    while(NULL != fast && NULL != fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

//链表释放
void ReleaseList(NODE **pHead)
{
    NODE *tmp = *pHead;
    if (*pHead==NULL)
    {
        printf("list is empty\n");
        return;
    }
    while (*pHead!=NULL)
    {
        tmp = *pHead;
        *pHead = (*pHead)->Next;
        free(tmp);
    }
}
//调用方法
ReleaseList(&List1);

//vs2013测试程序
int _tmain(int argc, _TCHAR* argv[])
{

    NODE* List = ListInit();
    for (int i = 0; i < 10; i++)
    {
        List = InsertEnd(List, i);
        List = InsertEnd(List, i);
        //List = InsertFront(List, i);

    PrintList(List);
    printf("list length =  %d, ", GetListLength(List));
    printf("\n");

    List = RemoveNode(List, 9);
    PrintList(List);

    printf("list length =  %d, ", GetListLength(List));
    printf("\n");

    printf("逆序\n");
    List = ReverseList(List);
    PrintList(List);
    //ReversePrintList(List);
    printf("\n");

    system("pause");
    return 0;
}

//运行结果
0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,
list length = 20
0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,
list length = 18
逆序
8，8,7,7,6,6,5,5,4,4,3,3,2,2,1,1,0,0，

//两个链表合并
NODE *MergeList(NODE *pHead1, NODE *pHead2)
{
    if (pHead1 == NULL)
        return pHead2;
    else if (pHead2 == NULL)
        return pHead1;

    NODE *pMergedHead = NULL;
    if (pHead1->data < pHead2->data)
    {
        pMergedHead = pHead1;
        pMergedHead->Next = MergeList(pHead1->Next, pHead2);
    }
    else
    {
        pMergedHead = pHead2;
        pMergedHead->Next = MergeList(pHead1, pHead2->Next);
    }
    return pMergedHead;
}

void merge(Node* left,Node* right)
{
    Node* dummy = new Node(0);
    while(NULL!=left && NULL != right)
    {
        dummy->next = left;
        left = left->next;
        dummy = dummy->next;
        dummy->next = right;
        right = right->next;
        dummy = dummy->next;
    }
    dummy-next = (NULL!=left)?left:right;
}

int main()
{
    NODE* List1 = ListInit();
    NODE* List2 = ListInit();
    NODE* List3 = NULL;
    for (int i = 1; i < 10; i++)
    {
        List1 = InsertEnd(List1,i);
    }
    for (int i = 2; i < 10; i++)
    {
        List2 = InsertEnd(List2,i);
    }
    PrintList(List1);
    PrintList(List2);
    List3 = MergeList(List1, List2);
    PrintList(List3);

    system("pause");
    return 0;
}