【剑指】18(2).删除链表中重复的结点

最新推荐文章于 2021-03-25 14:18:48 发布
最新推荐文章于 2021-03-25 14:18:48 发布
阅读量144 收藏
点赞数
分类专栏： 剑指offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ansizhong9191/article/details/80656356
版权
题目描述
  • 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。
算法分析
  • 若当前节点与下一个节点值不等currNode->val == currNode->next->val，则为非重复节点，继续向后查找，preNode = currNode，currNode = currNode->next;
  • 若找到重复节点，则循环向后查找，直到与重复节点不相等，并将前继指向当前节点；
  • 若重复节点为pHead，则需将pHead重新设置为非重复节点；

提交代码(1)：使用标志位来判别不同情况

class Solution {
public:
	ListNode* deleteDuplication(ListNode* pHead)
	{
		if (!pHead || !(pHead->next))
			return pHead;
		ListNode* preNode = pHead;
		ListNode* currNode = pHead;
		/* 有重复节点标志位 */
		bool flag = false;
		/* 重复节点为头节点标志位 */
		bool headFlag = false;
		while (currNode && currNode->next)
		{
			/* 如果为重复节点则依次向后查找 */
			while (currNode->next && currNode->val == currNode->next->val)
			{
				if (currNode == pHead)
					headFlag = true;

				/* 防止内存泄露 */
				ListNode* temp = currNode;
				currNode = currNode->next;
				delete temp;
				flag = true;
			}

			if (headFlag)
			{
				ListNode* temp = currNode;
				currNode = currNode->next;
				pHead = currNode;
				preNode = currNode;
				headFlag = false;
				flag = false;
				delete temp;
			}
			else
			{
				if (flag)
				{
					ListNode* temp = currNode;
					currNode = currNode->next;
					preNode->next = currNode;
					flag = false;
					delete temp;
				}
				else
				{
					preNode = currNode;
					currNode = currNode->next;
				}
			}
		}

		return pHead;
	}
};

提交代码(2)：创建一个头结点，避免pHead被删除的情况

class Solution {
public:
	ListNode* deleteDuplication(ListNode* pHead)
	{
		if (!pHead || !(pHead->next))
			return pHead;

		ListNode *pNewHead = new ListNode(-1);
		pNewHead->next = pHead;

		ListNode* preNode = pNewHead;
		ListNode* currNode = pHead;

		while (currNode && currNode->next)
		{
			if (currNode->val == currNode->next->val)
			{
				while (currNode->next && currNode->val == currNode->next->val)
				{
					/* 防止内存泄露 */
					ListNode* temp = currNode;
					currNode = currNode->next;
					delete temp;
				}

				ListNode* temp = currNode;
				currNode = currNode->next;
				preNode->next = currNode;
				delete temp;
			}
			else
			{
				preNode = currNode;
				currNode = currNode->next;
			}
		}
		return pNewHead->next;
	}
};
提交代码(3)：递归方法 
class Solution {
public:
	ListNode* deleteDuplication(ListNode* pHead)
	{
		if (!pHead || !(pHead->next))
			return pHead;

		ListNode* currNode;
		if (pHead->val == pHead->next->val)
		{
			currNode = pHead->next->next;
			while (currNode && currNode->val == pHead->val)
				currNode = currNode->next;
			return deleteDuplication(currNode);
		}
		else
		{
			currNode = pHead->next;
			pHead->next = deleteDuplication(currNode);
			return pHead;
		}
	}
};

测试代码：

// ====================测试代码====================
void Test(char* testName, ListNode* pHead, int* expectedValues, int expectedLength)
{
	if (testName != nullptr)
		printf("%s begins: ", testName);
	Solution s;
	pHead = s.deleteDuplication(pHead);

	int index = 0;
	ListNode* pNode = pHead;
	while (pNode != nullptr && index < expectedLength)
	{
		if (pNode->val != expectedValues[index])
			break;

		pNode = pNode->next;
		index++;
	}

	if (pNode == nullptr && index == expectedLength)
		printf("Passed.\n");
	else
		printf("FAILED.\n");
}

// 某些结点是重复的
void Test1()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode4 = CreateListNode(3);
	ListNode* pNode5 = CreateListNode(4);
	ListNode* pNode6 = CreateListNode(4);
	ListNode* pNode7 = CreateListNode(5);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);
	ConnectListNodes(pNode4, pNode5);
	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);

	ListNode* pHead = pNode1;

	int expectedValues[] = { 1, 2, 5 };
	Test("Test1", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

	//DestroyList(pHead);
}

// 没有重复的结点
void Test2()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode4 = CreateListNode(4);
	ListNode* pNode5 = CreateListNode(5);
	ListNode* pNode6 = CreateListNode(6);
	ListNode* pNode7 = CreateListNode(7);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);
	ConnectListNodes(pNode4, pNode5);
	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);

	ListNode* pHead = pNode1;

	int expectedValues[] = { 1, 2, 3, 4, 5, 6, 7 };
	Test("Test2", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

	//DestroyList(pHead);
}

// 除了一个结点之外其他所有结点的值都相同
void Test3()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(1);
	ListNode* pNode3 = CreateListNode(1);
	ListNode* pNode4 = CreateListNode(1);
	ListNode* pNode5 = CreateListNode(1);
	ListNode* pNode6 = CreateListNode(1);
	ListNode* pNode7 = CreateListNode(2);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);
	ConnectListNodes(pNode4, pNode5);
	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);

	ListNode* pHead = pNode1;

	int expectedValues[] = { 2 };
	Test("Test3", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

	//DestroyList(pHead);
}

// 所有结点的值都相同
void Test4()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(1);
	ListNode* pNode3 = CreateListNode(1);
	ListNode* pNode4 = CreateListNode(1);
	ListNode* pNode5 = CreateListNode(1);
	ListNode* pNode6 = CreateListNode(1);
	ListNode* pNode7 = CreateListNode(1);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);
	ConnectListNodes(pNode4, pNode5);
	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);

	ListNode* pHead = pNode1;

	Test("Test4", pHead, nullptr, 0);

	//DestroyList(pHead);
}

// 所有结点都成对出现
void Test5()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(1);
	ListNode* pNode3 = CreateListNode(2);
	ListNode* pNode4 = CreateListNode(2);
	ListNode* pNode5 = CreateListNode(3);
	ListNode* pNode6 = CreateListNode(3);
	ListNode* pNode7 = CreateListNode(4);
	ListNode* pNode8 = CreateListNode(4);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);
	ConnectListNodes(pNode4, pNode5);
	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);
	ConnectListNodes(pNode7, pNode8);

	ListNode* pHead = pNode1;

	Test("Test5", pHead, nullptr, 0);

	//DestroyList(pHead);
}

// 除了两个结点之外其他结点都成对出现
void Test6()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(1);
	ListNode* pNode3 = CreateListNode(2);
	ListNode* pNode4 = CreateListNode(3);
	ListNode* pNode5 = CreateListNode(3);
	ListNode* pNode6 = CreateListNode(4);
	ListNode* pNode7 = CreateListNode(5);
	ListNode* pNode8 = CreateListNode(5);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);
	ConnectListNodes(pNode4, pNode5);
	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);
	ConnectListNodes(pNode7, pNode8);

	ListNode* pHead = pNode1;

	int expectedValues[] = { 2, 4 };
	Test("Test6", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

	//DestroyList(pHead);
}

// 链表中只有两个不重复的结点
void Test7()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);

	ConnectListNodes(pNode1, pNode2);

	ListNode* pHead = pNode1;

	int expectedValues[] = { 1, 2 };
	Test("Test7", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

	//DestroyList(pHead);
}

// 结点中只有一个结点
void Test8()
{
	ListNode* pNode1 = CreateListNode(1);

	ConnectListNodes(pNode1, nullptr);

	ListNode* pHead = pNode1;

	int expectedValues[] = { 1 };
	Test("Test8", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

	//DestroyList(pHead);
}

// 结点中只有两个重复的结点
void Test9()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(1);

	ConnectListNodes(pNode1, pNode2);

	ListNode* pHead = pNode1;

	Test("Test9", pHead, nullptr, 0);

	//DestroyList(pHead);
}

// 空链表
void Test10()
{
	ListNode* pHead = nullptr;

	Test("Test10", pHead, nullptr, 0);
}

int main(int argc, char* argv[])
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();
	Test6();
	Test7();
	Test8();
	Test9();
	Test10();

	return 0;
}


YTea
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指-面试题18-2 删除链表中重复的节点
青山遇绝壁
03-24 101
删除链表中重复的节点 题目 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 思路： （1）首先新建一个头节点，以方便碰到第一个，第二个节点就相同的情况 （2）设置 pre ，last 指针， pre指针指向当前确定不重复的...
17.剑指Offer-删除链表中重复的结点
璀璨下的一点星辰
03-22 115
题目描述 解题描述 public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } public ListNode deleteDuplication(ListNode pHead) { if (pHea...
18.2 删除链表中重复的结点
weixin_44232942的博客
07-17 84
18.2 删除链表中重复的结点 NowCoder 题目描述 解题描述 public ListNode deleteDuplication(ListNode pHead) { if (pHead == null || pHead.next == null) return pHead; ListNode next = pHead.next; if (pHead.val == next.val) { while (next != null &&
《剑指Offer》18.2 删除链表中重复的结点
Melo
02-01 93
题目链接 牛客网 题目描述 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 解题思路 由于是不保留重复的节点，所以考虑使用递归。 public class Solution { public ListNode dele...
【剑指**】18.2-删除链表中的重复节点
学习使我快乐
01-21 162
18.2 删除链表中的重复节点题目描述在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留， 返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 思路分析好久没有玩C++的指针，竟然忘了 delete。。。所以，本题就是要提醒一下自己，c++指针资源的释放，不要忘记delete。然后在给它指向 NULL。链表的题目相对比较简单，但是
18：删除链表中重复的结点（剑指offer第2版Python）
12-22
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 2、代码详解 # -*- coding:utf-8 -*- class ListNode: def...
剑指offer–链表–删除链表中重复的结点(python实现)
01-20
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点， 重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5处理后为 1->2->5 代码： class ListNode: def __init__(self, x): self....
python-剑指offer第56题删除链表中重复的结点
最新发布
08-06
python python_剑指offer第56题删除链表中重复的结点
Python《剑指offer》算法实现-删除链表中重复的结点
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
23：链表中的环的入口结点（剑指offer第2版Python）
01-21
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 2、代码详解 寻找链表中环的入口结点主要分成三个步骤： 首先是设置两个快慢指针，如果快慢指针相遇，则快慢指针必然都在环中； 然后从...
剑指offer实践 ——18.2.删除链表中重复的节点（python版)
weixin_41651734的博客
03-25 192
文章目录题目一、思路一二、思路二 题目 删除链表中重复的节点 a) 1->2->3->3->4->4->5 b)1->2->5 一、思路一 使用两个指针。如果第一个指针和第二个指针内容相同，则需要删除这两个节点。 可以将p2的下一个节点的内容复制给p1，再另p1指向p2的下一个节点，等同与删除了当前的p1和p2节点～这种处理方式在处理头节点和第二个节点内容重复时，不需要新建一个头节点～ 但是这种方式的问题在于，如果尾部的两个节点相同，则没办法回溯到上
剑指offer 面试题18-2 删除链表中重复的节点
Black Mamba的博客
02-25 179
问题：给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。 输入：链表头节点指针 思路： 由于链表是有序的，只需要通过比较邻近两个节点是否相等，就可以找到所有重复的元素，然后利用指针操作将重复的节点删除。 代码： /** * Definition for singly-linked list. * struct ListNode { * int val; ...
面试题18_2：删除链表中重复的节点
M&H的博客
06-24 171
一、题目    删除链表中重复的节点：在一个排序的链表中，如何删除重复的结点？例如，在图（a）中重复 结点被删除之后，链表如图3.4（b）所示。                                                        (a).   1-&gt;2-&gt;3-&gt;3-&gt;4-&gt;4-&gt;5                            ...
剑指offer面试题18-2：删除链表中重复的节点
Ben
08-12 157
思路：由于重复节点出现的地方可能是链表的头部、中部、尾部，则需要额外注意的是返回链表的头指针和尾指针的确定；对于重复链表的删除，检查当前节点和下一节点的值是否相同，若相同，则将当前节点及之后连续为该值的节点删除，再将剩余的部分从头至尾连接起来。 /* struct ListNode { int val; struct ListNode *next; ListNode(int...
剑指 18(2) 删除链表中的重复节点
日月既往，不可复追
11-16 130
剑指 18(2) 删除链表中的重复节点 文章目录剑指 18(2) 删除链表中的重复节点原题目考查知识点知识点记录解法 原题目 在一个排序的链表中，删除重复的节点 示例1： 原链表：1-> 2-> 3-> 3-> 4-> 4-> 5 删除后：1-> 2 -> 5 考查知识点 嵌套指针（指针的指针） 知识点记录 设计一个函数，首先要确定两点：传入参数和返回值。这是我们设计函数的最重要的两点，即我有什么样的信息，要去解决什么问题，最后才是怎样利用手里的信息去解
面试题18：删除链表的节点（二）删除链表中重复的节点
chineseqsc的博客
07-27 116
题目描述 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1-&gt;2-&gt;3-&gt;3-&gt;4-&gt;4-&gt;5 处理后为 1-&gt;2-&gt;5 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) :...
剑指offer 18 lintcode 112. 删除排序链表中的重复元素
jyh的博客
05-29 155
给定一个排序链表，删除所有重复的元素每个元素只留下一个。 样例 给出 1->1->2->null，返回 1->2->null 给出 1->1->2->3->3->null，返回 1->2->3->null 思想：通过比较前一个结点值与后一个结点值是否相等，来决定当前结点指向后一个结点or后一个结点的后一个结点 程序： * Definition of ListNode
剑指offer（面试题18）：删除有序链表中的重复结点
stsfang
07-28 250
/* * 在一个排序的链表中，删除重复的结点（意味着连续出现相同的结点，这些的结点全部删除） * 1. 注意头结点可能被删除，因此函数参数声明中应该使用二级指针指向头结点所在的指针 * 2. */ #include &lt;iostream&gt; using namespace std; struct ListNode { int value; ListNode* next; };...
[剑指Offer]删除链表中重复的节点
KEEP CODING
02-28 559
本文首发于我的个人博客Suixin’s Blog 原文: https://suixinblog.cn/2019/02/target-offer-linked-list-remove-repetition.html　　作者: Suixin 链表的基础知识+Python实现四种链表 题目描述 在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留，返回链表头指针。 例如，链...
删除双向链表中的重复结点
05-13
要删除双向链表中的重复节点，可以使用哈希表记录已经出现的节点值，然后遍历链表，如果当前节点的值已经在哈希表中出现过了，就将该节点从链表中删除。以下是代码实现： ```python class ListNode: def __init__...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值