华为OJ：从单向链表中删除指定值的节点

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

链表结点定义如下：

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 1 5 4

PS：本人郑重怀疑，华为的上述用例！按照上述的规则，输出用例应该是2 5 4 1

在华为的OJ上面一直结果错误，难道是我理解错啦？

附上代码：

#include <iostream>
using namespace std;
typedef struct node
{
int number;
struct node *next;
}Node;
void ListNew(Node *head, int mynumber)
{
Node *nextnode =  (Node *)malloc(sizeof(Node));
nextnode->next = NULL;//考虑容错
nextnode->number = mynumber;
if(head->next != NULL)
{
nextnode->next = head->next;
head->next=nextnode;
}
else//头节点的后继指针NULL，直接添加即可
{
head->next=nextnode;
}
}
Node *Delete(Node *head,int key)
{
Node *node1=head;
Node *node2=NULL;
if (head==NULL)
{
return NULL;
}
else
{
if (node1->number==key)
{
head=head->next;
free(node1);
return head;
}
else
{
while (node1!=NULL)
{
node2=node1;
node2=node2->next;
if (node2->number==key)
{
node1->next=node2->next;
free(node2);
break;
}
node1=node1->next;
}
return head;
}
}
}
int main()
{
Node *head=(Node*)malloc(sizeof(Node));
Node *p,*q,*q1;
int key;
p=(Node*)malloc(sizeof(Node));
q1=q=head;
int nodenum;
cin>>nodenum;//待输入的节点数量
getchar();
cin>>head->number;//头节点的值
head->next = NULL;
int h,t;
for (int i=1;i<nodenum; i++)
{  cin>>t>>h;
//先进行查找，输入格式中的头节点的位置
while (q!=NULL)
{
if (q->number!=h)
{
q=q->next;
}
else if(q->number==h )//直接在首位
{
ListNew(q,t);
q = head;
break;
}
}//还需要增加容错
}
//cout<<"原链表数据： "<<endl;
/*while (q1!=NULL)
{
cout<<q1->number<<" ";
q1=q1->next;
}  */
//cout<<endl;
//cout<<"输入要删除的数据：";
cin>>key;
p=Delete(q,key);
/*cout<<"删除一个"<<key<<"之后的链表数据： "<<endl;  */
while (p!=NULL)
{
cout<<p->number<<" ";
p=p->next;
}
//cout<<endl;
free(p);
free(head);
return 0;
}