删除元素的操作

删除链表中多余的重复结点I

首先对于一个有序的结点递增的链表，删除重复的结点，只保留一份重复的结点。

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

　　只需要一个结点指针就能够完成操作。

ListNode* deleteDuplicates(ListNode* head) 
{
	if(head == NULL)
	{
		return NULL;
	}
	ListNode *r = head;
	
	while(r->next != NULL)
	{
		if(r->val == r->next->val)
		{
			ListNode *tmp = r->next;
			r->next = tmp->next;
			delete tmp;
			tmp = NULL;
		}
		else
		{
			r = r->next;
		}
	}//while
	
	return head;
}

删除链表中重复的全部结点II

Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.

　　注意这里有可能把头指针指向的结点删除了，所以要利用一个头结点，这样的话就可以不用单独的处理删除头指针指向的结点了。

ListNode* deleteDuplicates(ListNode* head) 
{
	ListNode *start = new ListNode(-1);
	start->next = head;
	if(head == NULL || head->next == NULL)
	{
		return head;
	}
	
	ListNode *pre = start;
	while(pre->next != NULL)
	{
		ListNode *cur = pre->next;
		while(cur->next != NULL && cur->next->val == cur->val)
		{
			cur = cur->next;
		}//while
		
		if(cur == pre->next)
		{
			pre = pre->next;
		}
		else
		{
			ListNode *tmp = pre->next;
			pre->next = cur->next;
			DeleteListNode(tmp, cur);
		}//else
	}//while
	
	return start->next;
}

void DeleteListNode(ListNode *start, ListNode *end)
{
	ListNode *tmp = NULL;
	while(start != end)
	{
		tmp = start;
		start = start->next;
		delete tmp;
	}
	delete start;
}

有序数组去重，删除重复出现的数字　　

从最后的结果看来，无非就是最后数组的前面剩下几个数字，然后返回数组的元素的个数。

Given input array nums = [1,1,2]，return [1,2,...],length = 2

　　想到这里，可以利用划分中small标识的方法：

int removeDuplicates(vector<int>& nums) 
{
	if(nums.size() == 0)
	{
		return 0;
	}
	
	int size = nums.size();
	int small = 0;
	for(int i = 1; i < size; ++i)
	{
		if(nums[i] > nums[small])
		{
			++small;
			if(small != i)
			{
				swap(nums[i], nums[small]);
			}
		}//if
	}//for
	
	return small + 1;
}

void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}