C语言：删除链表中的重复节点（一）

假设要将重复的节点删除至只剩一个。
思路：
设置两个指针，一个先指向头节点(假设为pointer指针)，一个指向头节点的next(假设为s指针)。
比较pointer和s的val：

1. pointer->val 等于 s->val：
   判断s的next是否为空：
   a. s的next不为空
   用s->next的val覆盖s的val，然后删除s->next
   b. s的next为空（即s是尾节点）
   新建节点node，遍历链表，使node指向s的前节点，然后删除s节点。
   注意：如果不设置node节点，直接用free(s)则无法彻底删除s节点。
2. pointer->val 不等于 s->val：
   s指针右移
   当循环至s为NULL，令pointer右移，重复上述过程直至pointer为NULL。

代码：

#include<stdio.h>
#include<stdlib.h>

typedef struct Linknode
{
	int val;
	struct Linknode* next;
}Linknode;

//创建节点
Linknode* create_link(int val)
{
	Linknode* head = (Linknode*)malloc(sizeof(Linknode));
	head->val = val;
	head->next = NULL;

	return head;
}

//连接节点
void connection_linknode(Linknode* node1, Linknode* node2)
{
	node1->next = node2;
}

//输出单链表
void print_link(Linknode* head)
{
	while (head)
	{
		printf("%d ", head->val);
		head = head->next;
	}
	printf("\n");
}

void DeleteDuplication(Linknode* head)
{
	if (head == NULL ||(head->next == NULL))
		return;
	
	Linknode* pointer = head;

	while (pointer->next != NULL)
	{
		Linknode* s = pointer->next;

		while (s != NULL)
		{
			if (pointer->val == s->val)
			{
				if (s->next != NULL)
				{
					s->val = s->next->val;
					s->next = s->next->next;
					free(s->next);
				}
				else
				{
					Linknode* node = pointer->next;
					while (node->next != s)
						node = node->next;
					node->next = NULL;
					free(s);
					s = NULL;
					//free(s);
				}
			}
			else 
				s = s->next;
		}
		pointer = pointer->next;
	}
	
}

int main(void)
{
	Linknode* head1 = create_link(1);
	Linknode* head2 = create_link(3);
	Linknode* head3 = create_link(5);
	Linknode* head4 = create_link(7);
	Linknode* head5 = create_link(3);
	Linknode* head6 = create_link(5);

	connection_linknode(head1, head2);
	connection_linknode(head2, head3);
	connection_linknode(head3, head4);
	connection_linknode(head4, head5);
	connection_linknode(head5, head6);

	printf("建立单链表：\n");
	print_link(head1);

	DeleteDuplication(head1);

	printf("删除重复元素：\n");
	print_link(head1);
}

运行结果：

其实这道题目与在O(1)时间内删除链表节点非常相似，只是待删除节点不是直接给出，而是要通过指针在链表内寻找，且待删除元素可能不止一个。