2016.5.57—— Remove Duplicates from Sorted List

Remove Duplicates from Sorted List

本题收获：

指针：

　　　不管什么指针在定义是就初始化：ListNode *head = NULL;

　　　如果给head指针赋值为第一个node节点数，则不需要开辟空间(的语句)，直接：head = node;　如果另外赋值，需要开辟内存.　　

　　　总之就是指针既要开辟内存(定义)又要赋值，只定义没有赋值的指针时野指针，危害很大。

 　　  指针在删除不用时，删除后，需要让指针指向NULL。    delete p_t;
               　　　　　　　　　　　　　　　　　　　　　　  p_t = NULL;      

　　题目：　

　　Given a sorted linked list, delete all duplicates such that each element appear only once.

　　For example,
　　Given 1->1->2, return 1->2.
　　Given 1->1->2->3->3, return 1->2->3.

　　思路：

　　我的思路：遍历，看是否相同。

　　leetcode/dicuss的思路：注意题目说了是已排序的，那么就看现在的节点和下一个节点是否相同，相同的话删除(指向NULL)，让下一个指向下下一个，cur->next = cur ->next ->next;

　　代码：

ListNode* deleteDuplicates_SimpleOneByOne_16ms(ListNode* head) 
{
    ListNode* node  = head;
    while(node && node->next)
    {
        if(node->val == node->next->val)
        {
            delete node->next;
            node->next = node->next->next;
        }
        else
            node = node->next;
    }

    return head;
}

　　代码2：测试的main函数在链表的输入输出中有　

public class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return head;

        ListNode cur = head;
        while(cur.next != null) {
            if (cur.val == cur.next.val) {
                cur.next = cur.next.next;
            }
            else cur = cur.next;
        }
        return head;
    }
}

　　2的main函数

int main()
{
    ListNode head(0), node1(1), node2(3),node3(3);            //对每一个节点赋值
    head.next = &node1;        //head.next是指向的地址， node是值
    node1.next = &node2;
    node2.next = &node3;
    node3.next = NULL;
    while (head.next != NULL)
    {
        //cout << head.val << endl;
        //if (head.next == NULL)
        //{
        //    cout << "aa" << endl;        //测试是否为空指针
        //    break;
        //}
        cout << head.val <<' ';
        head = *(head.next);            //这里要注意
    }
    cout << endl;
    system("pause");
    return 0;
}

 

 

　　代码1的测试mian函数：

#include "stdafx.h"
#include "iostream"
#include "vector"
#include "malloc.h"
using namespace std;

struct Listnode
{
    int val;
    Listnode *next;
    Listnode(int x) :val(x), next(NULL){};
};

class MyClass
{
public:
    Listnode *removeDuplicate(Listnode *head)
    {
        //cout << head->val << endl;
        if (head == NULL) return head;
            //cout << head->val<< endl;
        Listnode *cur;
        cur = head->next;
        if (cur->next->next == NULL)
            cout << 'b' << endl;
        while (cur->next != NULL)
        {
            //cout << 'c'<< endl;

            if (cur->val == cur->next->val)
            {
                Listnode *p_t = cur->next;        //释放删除元素的内存，用了new如果要删除的话，最好释放内存
                cur->next = cur->next->next;
                delete p_t;
                p_t = NULL;                        //不加的话很容易为垂直指针，容易内存泄漏
                //cout << cur->val << endl;
            }
            else
                cur = cur->next;    
            //cout << cur->val << endl;
        }
        //cout << head->val << endl;    
        return head;
        //cout << head->val << endl;
    }
    
};

//方法1：单个链表节点赋值，可以运行，但是给head1单独开辟空间，会显示空间值（why，怎么不显示）

int _tmain(int argc, _TCHAR* argv[])
{    
    //指针在定义时就初始化
    Listnode *head1 = NULL, *node1 = NULL, *node2 = NULL, *node3 = NULL, *node4 = NULL, *head2 = NULL;        //这里粗心，应该是分号写成逗号，提示错误1.error C2040: “node1”:“Listnode”与“Listnode *”的间接寻址级别不同 2.

    //head1 = new Listnode();                        //提示错误2：error C2440: “初始化”: 无法从“Listnode *”转换为“Listnode”    无构造函数可以接受源类型，或构造函数重载决策不明确
    head1 = (Listnode *)malloc(sizeof(Listnode));    //分配内存的方法
    head1 = 0;
    //head1 = (Listnode *)malloc(2);

    node1 = new Listnode(1);
    node2 = new Listnode(2);
    node3 = new Listnode(2);
    node4 = new Listnode(4);

    //head1 = node1;                //这种方法给head1指针地址最好？？
    head1->next = node1;
    node1->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = NULL;


    MyClass solution;
    head2 = solution.removeDuplicate(head1);
    while(head2 != NULL)                    //输出不是for是while
    {
        cout << head2->val <<' ';
        head2 = head2->next;
    }
    cout << endl;
    system("pause");
    return 0;
}
/*
//方法2：数组赋值给链表节点，这种方法OK
int main()
{
    Listnode *head1 = NULL, *node1 = NULL, *node2 = NULL, *head2 = NULL;
    vector<int> nums = { 1, 1, 2, 4, 6, 6 };
    for (size_t i = 1; i < nums.size(); i++)
    {
        node1 = new Listnode(nums.at(i));
        if (head1 == NULL)
        {
            head1 = node1;
        }
        else node2->next = node1;            //这两句注意注意
        node2 = node1;                        //在这里node2和head1并没有联系？？？？，node2是一个指针，不是数值，注意！！！！
    }

    MyClass solution;
    head2 = solution.removeDuplicate(head1);
    while (head2 != NULL)                    //输出不是for是while
    {
        cout << head2->val << ' ';
        head2 = head2->next;
    }
    cout << endl;
    system("pause");
    return 0;

}

//方法3：数组赋值，首先给head开辟空间，不能运行（why）                                        //这种提前给head1开辟空间的为什么不可以？？？？
int main()
{
    Listnode *head1 = NULL, *node1 = NULL, *node2 = NULL, *head2 = NULL;

    vector<int> nums = { 1, 1, 2, 4, 6, 6 };
    head1 = (Listnode *)malloc(sizeof(Listnode));
    //node2 = new Listnode(nums.at(0));
    //head1 = node2;
    for (size_t i = 1; i < nums.size(); i++)
    {
        node1 = new Listnode(nums.at(i));
        node2->next = node1;                        //将node2看做一个指针cur
        node2 = node1;
    }

    MyClass solution;
    head2 = solution.removeDuplicate(head1);
    while (head2 != NULL)                    //输出不是for是while
    {
        cout << head2->val << ' ';
        head2 = head2->next;
    }
    cout << endl;
    system("pause");
    return 0;
}*/

　　在测试过程中出现错误：

　　　　1.error C2040: “node1”:“Listnode”与“Listnode *”的间接寻址级别不同

　　　　2.error C2440: “初始化”: 无法从“Listnode *”转换为“Listnode”    无构造函数可以接受源类型，或构造函数重载决策不明确

　　这两个错误的原因是L54处将分号“；”，错写成逗号“，”，系统认为定义没有定义完，将下面一行误认为是Listnode的定义。

　　　　还有出现如下：

　　　　

　　　　是因为出现空指针，这就需要检查指针的定义以及初始化，删除，删除后指向NULL，等一系列指针的操作。

　　　　　　使用指针时一定注意，指针定义，初始化，赋值。