删除单链表中的重复节点（删除多余项）

题目：如何删除单链表中的重复节点（即保证每个元素只出现一次，删除多余的，且后来出现的元素）。

一个没有排序的单链表，如 list = {a, 1, x, b, e, f, f, e, a, g, h, b, m}，请去掉重复项，并保留原顺序，以上链表去掉重复项后为 newList = {a, 1, x, b, e, f, g, h, m}，请写出一个高效的算法。

思路分析：

第一种方法：因为要求算法高效，且考虑到时间比空间更重要，因此使用hash法。

步骤：

（1）建立一个hash表，key为链表中已经遍历的节点内容，初始时为空。

（2）从头开始遍历单链表中的节点。

<1> 如果节点内容已经在hash表中存在，则删除此节点，继续向后遍历。

<2> 如果节点内容不在hash表中，则保留此节点，将节点内容添加到hash表中，继续向后遍历。

（3）注意点：

<1> 删除时需要知道前一节点。

<2> 此处链表中存储的是char型变量，所以哈希表为含有256个元素的数组。

<3> 如果存储的是其他数据类型，则可以使用STL中的hash_set容器。

第二种方法：如果不能使用额外的存储空间，直接在原始链表上进行操作。（非递归）

步骤：

（1）建立指针p，用于遍历链表；

（2）建立指针q，q遍历p后面的结点，并与p数值比较；

（3）建立指针r，r保存需要删掉的结点，再把需要删掉的结点的前后结点相接。由此去掉重复值。

第三种方法：递归实现。

具体实现如下：

#include <iostream>

// 单链表节点结构如下
typedef struct node
{
char data;
struct node *next;
} NODE;

// 尾插法创建单链表(带头节点)
NODE *createEnd(char arr[], int len)
{
NODE *head = (NODE *)malloc(sizeof(NODE)); // 生成头节点
head->next = NULL;
NODE *end = head;  // 尾指针初始化

for (int i = 0; i < len; i++) {

NODE *p = (NODE *)malloc(sizeof(NODE)); // 为每个数组元素建立一个节点
p->data = arr[i];
end->next = p;  // 将节点p插入到终端节点之后
end = p;
}

end->next = NULL;  // 单链表建立完毕，将终端节点的指针域置空

return head;
}

// 单链表打印
void print(NODE *head)
{
if (head == NULL) return;

NODE *p = head->next;
while (p != NULL) {
printf("%c  ", p->data);
p = p->next;
}
}

// 第三种方法：递归方法
NODE *delSame_3(NODE *head)
{
NODE *p, *temp = head; // 递归过程中head是在不断变化的，但初始时temp都指向新的head。
if (head->next == NULL)
return head;

head->next = delSame_3(head->next); // 递归到head->next指向链表的尾节点；此时head指向链表倒数第二个节点。
p = head->next; // 让p指向head的下一个节点，注意此时temp＝head；

while (p != NULL)
{
if (head->data == p->data) // 单次递归中，head是不变的，每次都把head的数据和head之后所有节点的数据比较，若相同，则删除该节点。
{
temp->next = p->next;
free(p);
p = temp->next;
}
else
{
p = p->next;
temp = temp->next; // temp初始时是指向新的head的，之后作为临时变量，随着p一起后移，始终作为p的前驱节点，是为了当p节点的数据和head数据一样时，在删除p节点时，用temp->next来保存p的后继节点。
}
}

return head;
}

// 第二种方法：非递归实现去重
NODE *delSame_2(NODE *head)
{
NODE *p,*q,*r;
p = head->next; // 适用于有头节点的单链表；对于不带头节点的单链表，此处改为 p＝head 即可。
while(p != NULL)    // p用于遍历链表
{
q = p;
while(q->next != NULL) // q遍历p后面的结点，并与p数值比较
{
if(q->next->data == p->data)
{
r = q->next; // r保存需要删掉的结点
q->next = r->next;   // 需要删掉的结点的前后结点相接
free(r);
}
else
q = q->next;
}

p = p->next;
}

return head;
}

// 第一种方法：hash表去重
NODE *delSame(NODE *head)
{
if (head == NULL || head->next == NULL)
return head;

const int size = 256;
unsigned int count[size]; // 可用 unsigned int count[size] = {0}; 将数组中每一个元素都初始化为0。
for (int i = 0; i < size; i++) // 可能上述方法，不一定对所有编译器都适用，所以采用循环的方式更稳妥。
count[i] = 0;

// count[(unsigned char)(head->data)] = 1; // 当使用没有头节点的单链表时，打开此行代码即可。

NODE *p = head; // head是单链表的头节点，注意，头节点没有数据，它的存在仅仅是为了方便计算。
NODE *q = p->next;
NODE *r;
while (q != NULL)
{
if (count[(unsigned char)(q->data)] == 0)
{
count[(unsigned char)(q->data)] = 1;
p = q;
q = q->next; // 始终让p作为q的前驱节点
}
else
{
r = q; // r存储要删除的节点
p->next = q->next;
q = p->next; // 始终让p作为q的前驱节点
free(r);
}
}

return head;

}

int main(int argc, const char * argv[]) {

char arr[] = "a1xbeffeaghbm";
int len = (int)strlen(arr);

NODE *head = createEnd(arr, len);

// 去重之前
print(head);
printf("\n");

delSame(head);

// 去重之后
print(head);
printf("\n");

return 0;
}