从单向链表中删除指定值的节点

输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。

链表结点定义如下：

struct ListNode

{

      int       m_nKey;

      ListNode* m_pNext;

};

详细描述：

本题为考察链表的插入和删除知识。

链表的值不能重复

构造过程，例如

1 -> 2

3 -> 2

5 -> 1

4 -> 5

7 -> 2

最后的链表的顺序为 2 7 3 1 5 4 

删除 结点 2 

则结果为 7 3 1 5 4 

输入：

1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值

输出删除结点后的序列

样例输入：

5
2
3 2
4 3
5 2
1 4
3

样例输出：

2 5 4 1

#include
#include 
using namespace std;

typedef struct ListNode
{
      int       m_nKey;
      ListNode* m_pNext;
}ListNode;

///创建链表，返回头结点
ListNode* CreatList()
{
    unsigned int n;
    cin>>n;
    ListNode *head=NULL;
    ListNode *p=NULL;
    int data;///待插入的数
    int num;///插入此数的后面
    cin>>data;

    p = new ListNode;///插入根节点
    p->m_nKey=data;
    p->m_pNext = NULL;
    head = p;
    n--;

    for(unsigned int i=0;i>data>>num;
        ListNode *p_find=head;
        ListNode *p_find_next=NULL;
        while(p_find!=NULL)
        {
            if(p_find->m_nKey == num)
            {
                p_find_next = p_find->m_pNext;
                p = new ListNode;
                p->m_nKey = data;
                p->m_pNext=p_find_next;
                p_find->m_pNext = p;
                break;
            }
            p_find = p_find->m_pNext;
        }
    }
    return head;
}

ListNode* DeleteNode(ListNode* head,int value)
{

    ListNode *p=head;
    ListNode *q=NULL;
    if(p->m_nKey == value)
    {
        head=p->m_pNext;
        return head;
    }

    while(p!=NULL)
    {
        if(p->m_pNext->m_nKey == value)
        {
            q=p->m_pNext->m_pNext;
            p->m_pNext=q;
            return head;
        }
        p = p->m_pNext;
    }
    return NULL;
}

int main()
{
    ListNode* p=NULL;
    int value;
    p = CreatList();
    cin>>value;
    p = DeleteNode(p,value);
    while(p!=NULL)
    {
        cout<m_nKey<<" ";
        p=p->m_pNext;
    }
    return 0;
}