//两链表相交,计算相交点
#include <iostream>
using namespace std;
struct LinkNode
{
LinkNode *pNext;
int nValue;
LinkNode(int value = 0)
{
nValue = value;
pNext = NULL;
}
};
class Linklist
{
public:
Linklist(){ pHead = new LinkNode(); };
~Linklist(){ delete pHead;};
void InsertValue(int nValue);
void Reverse();
void Reverse2();
LinkNode *FindLastNum(int nNum);
LinkNode *FindMidNode(bool &IsOdd);
void DeleteNode(LinkNode *pDel);
Linklist* Mergelist(const Linklist &list) const;
void SwapNode(LinkNode *p1, LinkNode *p2);
bool IsCircle();
int CircleLengh();
bool IsIntersect(const Linklist &list);
LinkNode *GetIntersectNode(const Linklist &list);
void Print();
public:
LinkNode *pHead;
};
void Linklist::InsertValue(int nValue)
{
if (pHead == NULL)
{
return;
}
LinkNode *pCur = pHead;
while (pCur->pNext != NULL)
{
pCur = pCur->pNext;
}
LinkNode *pTmp = new LinkNode(nValue);
pCur->pNext = pTmp;
}
void Linklist::Reverse()
{
if (pHead == NULL)
{
return;
}
//特殊情况:如果链表为空或者只有一个元素,直接返回
if (pHead->pNext == NULL || pHead->pNext->pNext == NULL)
{
return;
}
LinkNode *pPre = pHead;
LinkNode *pCur = pHead->pNext;
LinkNode *pNext;
while (pCur != NULL)
{
pNext = pCur->pNext;
pCur->pNext = pPre;
pPre = pCur;
pCur = pNext;
}
pHead->pNext->pNext = NULL;
pHead->pNext = pPre;
}
void Linklist::Reverse2()
{
if (pHead == NULL)
{
return;
}
//特殊情况:如果链表为空或者只有一个元素,直接返回
if (pHead->pNext == NULL || pHead->pNext->pNext == NULL)
{
return;
}
LinkNode *pCur = pHead->pNext;
LinkNode *pNext = NULL;
LinkNode *pNextNext = NULL;
while (pCur->pNext != NULL)
{
pNext = pCur->pNext;
pNextNext = pNext->pNext;
pNext->pNext = pHead->pNext;
pHead->pNext = pNext;
pCur->pNext = pNextNext;
}
}
LinkNode *Linklist::FindLastNum(int nNum)
{
if (pHead == NULL)
{
return NULL;
}
LinkNode *pFirst = pHead;
int i = 0;
while (i < nNum)
{
if (pFirst == NULL)
{
return NULL;
}
pFirst = pFirst->pNext;
i++;
}
LinkNode *pSecond = pHead;
while (pFirst != NULL)
{
pFirst = pFirst->pNext;
pSecond = pSecond->pNext;
}
return pSecond;
}
//考虑链表个数为奇数Odd、偶数Even两种情况
LinkNode* Linklist::FindMidNode(bool &IsOdd)
{
if (pHead == NULL)
{
return NULL;
}
LinkNode *pFirst = pHead;
LinkNode *pSecond = pHead;
while (pFirst != NULL && pFirst->pNext != NULL)
{
pFirst = pFirst->pNext->pNext;
pSecond = pSecond->pNext;
}
if (pFirst == NULL)
{
IsOdd = true;
}
else
{
IsOdd = false;
}
return pSecond;
}
void Linklist::DeleteNode(LinkNode *pDel)
{
if (pHead == NULL || pDel == NULL)
{
return;
}
//如果要删除的节点不是最后一个节点
if (pDel->pNext != NULL)
{
pDel->nValue = pDel->pNext->nValue;
LinkNode *pTmp = pDel->pNext;
pDel->pNext = pTmp->pNext;
delete pTmp;
}
else
{
LinkNode *pCur = pHead->pNext;
while (pCur != NULL)
{
if (pCur->pNext = pDel)
{
pCur->pNext = NULL;
delete pDel;
}
else
{
pCur = pCur->pNext;
}
}
}
}
Linklist* Linklist::Mergelist(const Linklist &list) const
{
Linklist *pList = new Linklist;
if (pList == NULL || pHead == NULL || list.pHead == NULL)
{
return NULL;
}
LinkNode *pCur1 = pHead->pNext;
LinkNode *pCur2 = list.pHead->pNext;
LinkNode *pCur3 = pList->pHead;
while (pCur1 && pCur2)
{
if (pCur1->nValue > pCur2->nValue)
{
pList->InsertValue(pCur2->nValue);
pCur2 = pCur2->pNext;
}
else
{
pList->InsertValue(pCur1->nValue);
pCur1 = pCur1->pNext;
}
}
while (pCur1)
{
pList->InsertValue(pCur1->nValue);
pCur1 = pCur1->pNext;
}
while (pCur2)
{
pList->InsertValue(pCur2->nValue);
pCur2 = pCur2->pNext;
}
return pList;
}
//需要三个额外指针变量
void Linklist::SwapNode(LinkNode *p1, LinkNode *p2)
{
if (pHead == NULL || p1 == NULL || p2 == NULL)
{
return;
}
if (p1 == p2)
{
return;
}
LinkNode *pCur = pHead->pNext;
LinkNode *pCur1 = p1;
LinkNode *pCur2 = p2;
LinkNode *pPre1 = NULL;
LinkNode *pPre2 = NULL;
int nCount = 0;
while (pCur)
{
if (pCur->pNext == pCur1)
{
pPre1 = pCur;
nCount++;
if (nCount == 2)
{
break;
}
}
if (pCur->pNext == pCur2)
{
pPre2 = pCur;
nCount++;
if (nCount == 2)
{
break;
}
}
pCur = pCur->pNext;
}
pCur = pCur1->pNext;
pPre1->pNext = pCur2;
pCur1->pNext = pCur2->pNext;
pPre2->pNext = pCur1;
pCur2->pNext = pCur;
}
bool Linklist::IsCircle()
{
if (pHead == NULL || pHead->pNext == NULL)
{
return false;
}
LinkNode *pFirst = pHead->pNext;
LinkNode *pSecond = pHead->pNext;
while (pFirst != NULL && pFirst->pNext != NULL)
{
pFirst = pFirst->pNext->pNext;
pSecond = pSecond->pNext;
if (pFirst == pSecond)
{
return true;
}
}
return false;
}
int Linklist::CircleLengh()
{
if (pHead == NULL)
{
return 0;
}
LinkNode *pCur = pHead->pNext;
int nLen = 0;
if (pCur)
{
nLen++;
pCur = pCur->pNext;
}
while (pCur != pHead->pNext)
{
nLen++;
pCur = pCur->pNext;
}
return nLen;
}
/*
//方法1:如果两链表末尾元素相同,必相交
bool Linklist::IsIntersect(const Linklist &list)
{
if (pHead == NULL || list.pHead == NULL)
{
return false;
}
LinkNode *pCur1 = pHead;
LinkNode *pCur2 = list.pHead;
while (pCur1->pNext)
{
pCur1 = pCur1->pNext;
}
while (pCur2->pNext)
{
pCur2 = pCur2->pNext;
}
return pCur1 == pCur2;
}
*/
//方法2:把一个链表 A 接在另一个链表 B 的末尾,如果有环,则必然相交。如
// 何判断有环呢?从 A 开始遍历,如果能回到 A 的表头,则肯定有环。
bool Linklist::IsIntersect(const Linklist &list)
{
if (pHead == NULL || list.pHead == NULL)
{
return false;
}
LinkNode *pCur1 = pHead;
LinkNode *pCur2 = list.pHead;
//到达链表1的末尾
while (pCur1->pNext)
{
pCur1 = pCur1->pNext;
}
pCur1->pNext = pCur2;
while (pCur2->pNext)
{
if (pCur2->pNext == list.pHead)
{
pCur1->pNext = NULL; //断开环
return true;
}
pCur2 = pCur2->pNext;
}
pCur1->pNext = NULL; //断开环
return false;
}
//获取相交的节点
LinkNode* Linklist::GetIntersectNode(const Linklist &list)
{
if (pHead == NULL || list.pHead == NULL)
{
return NULL;
}
int nLen1 = 0;
int nLen2 = 0;
LinkNode *pCur1 = pHead->pNext;
LinkNode *pCur2 = list.pHead->pNext;
while (pCur1)
{
nLen1++;
pCur1 = pCur1->pNext;
}
while (pCur2)
{
nLen2++;
pCur2 = pCur2->pNext;
}
int n;
if (nLen1 > nLen2)
{
pCur1 = pHead->pNext;
pCur2 = list.pHead->pNext;
n = nLen1 - nLen2;
while (n > 0)
{
pCur1 = pCur1->pNext;
n--;
}
}
else
{
pCur1 = pHead->pNext;
pCur2 = list.pHead->pNext;
n = nLen2 - nLen1;
while (n > 0)
{
pCur2 = pCur2->pNext;
n--;
}
}
while (pCur1 != pCur2)
{
pCur1 = pCur1->pNext;
pCur2 = pCur2->pNext;
}
return pCur1;
}
void Linklist::Print()
{
if (pHead == NULL)
{
return;
}
LinkNode *pCur = pHead->pNext;
while (pCur != NULL)
{
cout<<pCur->nValue<<" ";
pCur = pCur->pNext;
}
cout<<endl;
}
int main()
{
Linklist list1;
Linklist list2;
LinkNode p1(1);
LinkNode p2(2);
LinkNode p3(3);
LinkNode p4(4);
LinkNode p5(5);
LinkNode p6(6);
LinkNode p7(7);
p1.pNext = &p2;
p2.pNext = &p6;
p3.pNext = &p4;
p4.pNext = &p5;
p5.pNext = &p6;
p6.pNext = &p7;
list1.pHead->pNext = &p1;
list2.pHead->pNext = &p3;
if (list1.IsIntersect(list2))
{
cout<<"相交"<<endl;
LinkNode *p = list1.GetIntersectNode(list2);
if (p)
{
cout<<p->nValue<<endl;
}
}
else
{
cout<<"不相交"<<endl;
}
return 0;
}
10两链表相交,计算相交点
最新推荐文章于 2025-03-23 20:19:03 发布