leecode 解题总结：83. Remove Duplicates from Sorted List

#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
/*
问题:
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.

分析:删除链表中的冗余元素，多个元素只保留一个。
我们保留多个重复元素中最后一个节点。
同时设定当前节点和下一个节点。如果当前节点和下一个节点相同，说明
当前元素是重复的，记录当前元素之前的节点previoudNode，然后一直寻找到和当前元素不同的节点，记为nextNode,则nextNode前面一个节点
就是需要保留的节点node，然后设定previouNode指向node即可

输入:
3(结点个数)
1 1 2
4 
1 1 2 2
2 
1 1
5
1 1 2 3 3
输出:
1 2
1 2
1
1 2 3

关键:
1】 1,1,2,2报错了
//删除完之后，进行连接
if(previous)
{
	previous->next = node;
}
//删除头部节点，则重新设置链表头部
else
{
	head = node;
}
//这里需要更新previous为当前node(保留的重复元素的最后一个节点)，否则会出现错误，
记住previous记录的就是与下一个元素不重复的节点
previous = node;
*/

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

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head)
		{
			return head;
		}
		//只有一个元素直接返回
		if(!(head->next))
		{
			return head;
		}
		ListNode* previous = NULL;
		ListNode* node = head;
		ListNode* next = head->next;
		ListNode* tempNode;
		ListNode* deleteNode;
		int repeatValue;
		int countRepeat = 0;
		while(next)
		{
			//判断当前元素和下一个元素是否重复
			if(node->val == next->val)
			{
				//寻找第一个不重复的元素
				repeatValue = node->val;
				countRepeat = 0;
				while(next && next->val == repeatValue )
				{
					node = next;
					next = next->next;
					countRepeat++;
				}
				//此时node是最后一个重复的元素，删除重复元素
				if(previous)
				{
					deleteNode = previous->next;
				}
				//说明链表头部就重复了
				else
				{
					deleteNode = head;
				}
				while(deleteNode && countRepeat)
				{
					tempNode = deleteNode->next;
					delete deleteNode;
					deleteNode = tempNode;
					countRepeat--;
				}
				//删除完之后，进行连接
				if(previous)
				{
					previous->next = node;
				}
				//删除头部节点，则重新设置链表头部
				else
				{
					head = node;
				}
				//这里需要更新previous为当前node(保留的重复元素的最后一个节点)，否则会出现错误
				previous = node;
			}
			else
			{
				previous = node;
			}
			node = next;
			if(next)
			{
				next = next->next;
			}
		}
		return head;
    }
};

void print(ListNode* head)
{
	if(!head)
	{
		cout << "no result" << endl;
	}
	ListNode* tempHead = head;
	while(head)
	{
		cout << head->val << " ";
		head = head->next;
	}
	cout << endl;
	head = tempHead;
}

ListNode* buildList(vector<int>& nums)
{
	if(nums.empty())
	{
		return NULL;
	}
	int size = nums.size();
	ListNode* head ;
	ListNode *tail;
	ListNode* node;
	for(int i = 0 ; i < size ; i++)
	{
		if(i)
		{
			node = new ListNode(nums.at(i));
			tail->next = node;
			tail = node;
		}
		else
		{
			head = new ListNode(nums.at(i));
			tail = head;
		}
	}
	return head;
}

void deleteList(ListNode* head)
{
	ListNode* node;
	while(head)
	{
		node = head->next;
		delete head;
		head = node;
	}
}

void process()
{
	 vector<int> nums;
	 int value;
	 int num;
	 Solution solution;
	 vector<int> result;
	 while(cin >> num )
	 {
		 nums.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 nums.push_back(value);
		 }
		 ListNode* head = buildList(nums);
		 ListNode* newHead = solution.deleteDuplicates(head);
		 print(newHead);
		 deleteList(newHead);//删除节点了
	 }
}
int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}