Talk is cheap, show me the code.

一、問題描述

輸入一個單向連結串列和一個節點的值，從單向連結串列中刪除等於該值的節點，刪除後如果連結串列中無節點則返回空指標。
連結串列結點定義如下：

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

二、問題分析

主要是對指標的應用，注意宣告一個指標，比如int *p，並沒有給它所指向的int分配記憶體空間，只有當p = new int()之後才會給p指向的int分配記憶體空間，delete p; p = 0;是釋放p所指向的記憶體空間，但是指標p依然指向已被釋放的原來指向的記憶體空間，需要將p置位0，避免指標出錯。

解題方式1：

這個是正確解。

#include<iostream>
using namespace std;
struct ListNode
{
      int  val;
      ListNode* next;
};
int main(){
    int n,head_value;
    while(cin>>n>>head_value){
        ListNode *p,*q,*head=new ListNode;
        head->val=head_value;
        head->next=NULL;
        q=head;
        for(int i=0;i<n-1;i++){
            int x,y;
            cin>>x>>y;
            p=new ListNode;
            p->val=x;
            p->next=NULL;
            while(q){
                if(q->val==y){
                      p->next=q->next;
                    q->next=p;
                    break;
                }else
                    q=q->next;
            }
            q=head;
        }
        int denum;
        cin>>denum;
        q=head;
        while(q){
            if(q->val==denum){
                if(q==head){
                    head=q->next;
                    delete q;
                }else{
                    p->next=q->next;
                    delete q;
                }
                break;
            }else{
                 p=q;
                 q=q->next;
            }  
        }
        q=head;
        while(q){
            cout<<q->val<<' ';
            q=q->next;
        }
        cout<<endl;
    }
    return 0;
}
 

解題方式2：

這是我自己寫的方法，不明白為什麼同一個測試用例，在牛客網OJ上執行出錯，我在子集的電腦上執行卻沒有錯誤。

#include <iostream>
using namespace std;

struct ListNode
{
    int m_key;
    ListNode *m_next;
};

int main()
{
    int n;
    while (cin >> n)
    {
        ListNode *list = new ListNode();
        int head;
        cin >> head;
        list->m_key = head;
        list->m_next = NULL;
        n--;
        int back, pre;
        ListNode *p = 0;
        while (n--)
        {
            cin >> back >> pre;
            p = list;
            while (p != NULL)
            {
                if (p->m_key == pre)
                {
                    ListNode *temp = new ListNode();
                    temp->m_key = back;
                    temp->m_next = p->m_next;
                    p->m_next = temp;
                    break;
                }
                p = p->m_next;
            }
        }
        int del;
        cin >> del;
        p = list;
        ListNode *q = 0;
        if (p->m_next == NULL)
        {
            continue;
        } else {
            if (p->m_key == del)
            {
                q = p;
                p = p->m_next;  
                delete q;
                q = 0;
            }
        }
        while (p->m_next != NULL)
        {
            q = p->m_next;
            if (q->m_key == del)
            {
                p->m_next = q->m_next;
                delete q;
                q = 0;
                break;
            }
            p = q;
            q = q->m_next;
        }
        p = list;
        cout << p->m_key;
        p = p->m_next;
        while (p != NULL)
        {
            cout << " " << p->m_key;
            p = p->m_next;
        }
    }

    return 0;
}