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(), node1(), node2(),node3();            //对每一个节点赋值
     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 ;
 }

　　代码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 = ;
     //head1 = (Listnode *)malloc(2);

     node1 = new Listnode();
     node2 = new Listnode();
     node3 = new Listnode();
     node4 = new Listnode();

     //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 ;
 }
 /*
 //方法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的定义。

　　　　还有出现如下：

　　　　aaarticlea/png;base64,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" alt="" width="321" height="200" />

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

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