链表删除相关算法题|删除值为x的节点|删除最小值节点|删除值在区间内的节点|删除重复节点|删除绝对值相等的节点(C)

删除值为x的节点

在带头结点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为×的结点不唯一

算法思想

删除单链表的节点需要三个指针
一个是遍历链表的工作指针cur，一个是指向cur的上一个节点的指针prev，一个是用于指向要删除的节点的指针del

prev指针指向头节点，cur指向第一个节点，开始遍历链表，直到cur指向空
如果没有碰到值为x的节点，将prev指向cur，cur指向cur的next，两个指针往后遍历

如果碰到值为x的节点，用del指向这个要删除的节点，cur指针指向下一个节点

prev的next指向cur，断开链表的连接

最后free掉del指向的节点

void DelX(LinkList &L, ElemType x)
{
	LNode* cur = L->next, *prev = L, *del;
	while (cur)
	{
		if (cur->data == x)
		{
			del = cur;
			cur = cur->next;
			prev->next = cur;
			free(del);
		}
		else
		{
			prev = cur;
			cur = cur->next;
		}
	}
}

思路2

采用尾插法建立单链表
用cur指针扫描L的所有节点，当其值不为x时，将其链接到L之后，否则将其释放

tail指向L头节点，cur指向第一个节点
如果cur指针遇到值不为x的节点，需要将其尾插到L后面，用tail指针的next指向cur，链接到tail后面；再把tail指针指向cur，也就是tail指针要指向新链表的最后一个节点；最后cur指向cur的next，继续向后遍历

如果cur遇到值为x的节点
用del指针指向要删除的节点，cur指向下一个节点

删除del指向的节点

最后将tail的next指向NULL

void DelX(LinkList &L, ElemType x)
{
	LNode* cur = L->next, *tail = L, *del;
	while (cur)
	{
		if (cur->data != x)
		{
			tail->next = cur;
			tail = cur;
			cur = cur->next;
		}
		else
		{
			del = cur;
			cur = cur->next;
			free(del);
		}
	}
	tail->next = NULL;
}

删除最小值节点

在带头结点的单链表L中删除一个最小值结点（假设该结点唯一）。

算法思想

需要一个工作指针cur来扫描整个链表，用前驱指针prev来保存cur的前一个节点
用mcur来保存最小值节点， mprev来保存最小值节点的前驱
首先prev指向cur，cur指向cur的next，正常往后遍历
如果cur指向节点的值小于mcur的值，将mcur指向cur，mprev指向prev
全部遍历完后，mprev的next指向mcur的next，断开mcur的链接，删除mcur指向的节点

void DelMin(LinkList &L)
{
	LNode* cur = L->next, *prev = L;
	LNode* mprev = prev, *mcur = cur;
	while (cur)
	{
		if (cur->data < mcur->data)
		{
			mcur = cur;
			mprev = prev;
		}
		prev = cur;
		cur = cur->next;
	}
	mprev->next = mcur->next;
	free(mcur);
}

删除值在区间内的节点

设在一个带表头结点的单链表中，所有结点的元素值无序，删除表中所有介于给定的两个值（作为函数参数给出）之间的元素（若存在）

算法思想

因为链表是无序的，只能逐个节点检查
需要一个工作指针cur指向第一个节点，一个前驱指针prev，指向头节点
cur一直往后遍历，直到cur指向NULL
prev指向cur，cur指向cur的next，往后遍历
如果cur的data在min和max之间，prev的next指向cur的next，删除cur指向的节点，cur指向prev的next

void RangeDel(LinkList &L, int min, int max)
{
	LNode* cur = L->next, *prev = L;
	while (cur)
	{
		if (cur->data > min && cur->data < max)
		{
			prev->next = cur->next;
			free(cur);
			cur = prev->next;
		}
		else
		{
			prev = cur;
			cur = cur->next;
		}
	}
}

删除重复节点

在一个递增有序的单链表中，存在重复的元素。删除重复的元素

算法思想

由于是有序链表，所有相同的值的节点都是相邻的，用cur扫描递增单链表L
用next指针指向cur的下一个节点，如果next节点的值等于cur节点的值，删除next节点，否则cur继续往后遍历

void DelSame(LinkList &L)
{
	LNode* cur = L->next, *next;
	if (cur == NULL)
		return;
	while (cur->next)
	{
		next = cur->next;
		if (next->data == cur->data)
		{
			cur->next = next->next;
			free(next);
		}
		else
			cur = cur->next;
	}
}

删除绝对值相等的节点

【2015统考真题】用单链表保存m个整数，，且$|data|\le n$（n为正整数）
对于链表中data的绝对值相等的结点，仅保留第一次出现的结点而删除其余绝对值相等的结点。

算法思想

使用辅助数组记录链表中已经出现的数值，从而只需要对链表进行一次扫描
应为data的绝对值小于等于n，所以辅助数组的大小为n+1，各元素的初值均为0。依次扫描链表中的各个节点，同时检查数组中的值，若为0，就保留该节点，并令数组中该值绝对值的位置等于1，否则将该节点从链表中删除

void func(LinkList &L, int n)
{
	LNode* cur = L->next, del;
	int *a, m;
	a = (int*)malloc(sizeof(int)*(n+1));
	for(int i = 0; i < n + 1; i++)
	{
		*(a+i) = 0;
	}
	while (cur->next)
	{
		m = cur->next->data > 0 ? cur->next->data : -cur->next->data;
		if (*(a + m) == 0)
		{
			*(a + m) = 1;
			cur = cur->next;
		}
		else
		{
			del = cur->next;
			cur->next = del->next;
			free(del);
		}
	}
	free(a);
}

需要一个工作指针cur来遍历链表，一个指针del用来指向要删除的节点
malloc一个数组，大小是n+1，并将数组中的值都置为0
开始遍历数组，直到cur->next指向NULL
用m来存放cur的下一个节点的data的绝对值
判断数组中m位置的值，如果是0，将其置为1，继续往后遍历
如果不是0
用del指向cur的下一个节点，将cur的next指向del的next，断开del的链接
删除del
最后删除数组a