链表常见题总结一

     链表可以说是笔试面试的重点，因为写一个链表相关的题可以在短时间写出来，并且考验测试人的水平。特别将平时经常做的链表的题拿上来，做个小结。

   1. 求单链表中结点的个数

   2. 将单链表反转

   3. 查找单链表中的倒数第K个结点（k > 0）

   4. 查找单链表的中间结点

   5. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序

   6. 判断一个单链表中是否有环

   7. 判断两个单链表是否相交

  8. 求两个单链表相交的第一个节点

  9. 已知一个单链表中存在环，求进入环中的第一个节点

  10. 给出一单链表头指针pHead和一节点指针pToBeDeleted，O(1)时间复杂度删除节点pToBeDeleted

  1.求单链表节点的个数

//求单链表中结点的个数
int Length(ListNode *phead)
{
int len = 0;
while (phead != NULL)
{
len++;
phead = phead->pnext;
}
return len;
}

   2.单链表反转

     我是按照递归和非递归做的
     

//单链表反转
ListNode* Reverse(ListNode *phead)
{
if (phead == NULL||phead->pnext==NULL)
return phead;
ListNode *pre = new ListNode(0);
ListNode *temp = pre;
pre->pnext = phead;
ListNode* cur = phead;
ListNode* next = phead->pnext;
while (next != NULL)
{
cur->pnext = pre;
pre = cur;
cur = next;
next = next->pnext;
}
cur->pnext = pre;
phead->pnext = NULL;
delete temp;
return cur;
}

//单链表反转，递归
ListNode* ReverseRecursion(ListNode* phead)
{
if (phead == NULL || phead->pnext == NULL)
return phead;
ListNode *temp = phead->pnext;
ListNode *newhead=ReverseRecursion(temp);   //先反转链表结点的后一个结点
temp->pnext = phead;            //将该结点放在其原来后面结点的后一个结点
phead->pnext = NULL;
return newhead;
}

    3.倒数第K个节点

//查找单链表中的倒数第K个结点（K>0）,采用双指针法
ListNode* TheKthListNode(ListNode* phead,int k)
{
ListNode *fast = phead;
int i = 0;
while (i < k-1 && fast != NULL)
{
fast = fast->pnext;
i++;
}
if (fast == NULL)
return NULL;
ListNode *slow = phead;
while (fast->pnext != NULL)
{
slow = slow->pnext;
fast = fast->pnext;
}
slow->pnext = NULL;
return slow;
}

    4.查找单链表的中间节点

//找出单链表的中间结点,采用快慢指针
ListNode* MiddleNode(ListNode* phead)
{
ListNode *slow = phead;
ListNode *fast = phead;
if (phead == NULL)
return phead;
while (fast->pnext != NULL)
{
fast = fast->pnext;
slow = slow->pnext;
if (fast->pnext != NULL)
fast = fast->pnext;
}
return slow;
}

     5.合并两个有序的链表，使得结果仍然有序

//两链表各自有序，合并成一个链表依然有序
ListNode* Merge(ListNode *phead1, ListNode *phead2)
{
if (phead1 == NULL)
return phead1;
if (phead2 == NULL)
return phead2;
ListNode *pre=new ListNode(0);
ListNode *cur = pre;
ListNode *temp = NULL;
while (phead1 && phead2)
{
temp = phead1->val < phead2->val ? phead1 : phead2;
cur->pnext = temp;
cur = temp;
if (temp == phead1)
phead1 = phead1->pnext;
else
phead2 = phead2->pnext;
}
while (phead1)
{
cur->pnext = phead1;
cur = cur->pnext;
phead1 = phead1->pnext;
}
while (phead2)
{
cur->pnext = phead2;
cur = cur->pnext;
phead2 = phead2->pnext;
}
cur->pnext = NULL;
temp = pre->pnext;
delete pre;
return temp;
}

     6.判断单链表是否有环

//判断一个单链表是否有环,同样采用快慢指针，要是他们重合就有环
bool IsCircle(ListNode *phead)
{

ListNode *fast = phead;
ListNode *slow = phead;
while (fast!=NULL && fast->pnext!=NULL)
{
fast = fast->pnext->pnext;
slow = slow->pnext;
if (fast == slow)
return true;
}
return false;
}

     7.判断两个单链表是否相交

//判断两个单链表是否相交,若相交，则两个链表的最后一个节点必定相同，否则不相交
bool IsConnect(ListNode *phead1, ListNode *phead2)
{
if (phead1 == NULL || phead2 == NULL)
{
return false;
}
while (phead1->pnext != NULL)
{
phead1 = phead1->pnext;
}
while (phead2->pnext != NULL)
{
phead2 = phead2->pnext;
}
if (phead1 == phead2)
return true;
else
return false;
}

     8.求两个链表相交的第一个节点

//求两个单链表相交的第一个节点,先分别计算两个链表的长度，再让长的链表先走超出的那部分，然后两个链表步调相同
ListNode* TheFirstConnectNode(ListNode *phead1, ListNode *phead2)
{
if (phead1 == NULL || phead2 == NULL)
{
return NULL;
}
ListNode *temp1 = phead1;
ListNode *temp2 = phead2;
int len1 = 0, len2 = 0;
while (temp1->pnext != NULL)
{
len1++;
temp1 = temp1->pnext;
}
while (temp2->pnext != NULL)
{
len2++;
temp2 = temp2->pnext;
}
if (temp1 != temp2)
return NULL;
else
{
if (len1 > len2)
{
temp1 = phead1;
for (int i = 0; i < len1 - len2;i++)
{
temp1 = temp1->pnext;
}
temp2 = phead2;
}
else
{
temp2 = phead2;
for (int i = 0; i < len2 - len1; i++)
{
temp2 = temp2->pnext;
}
temp1 = phead1;
}
while (temp1 != temp2)
{
temp1 = temp1->pnext;
temp2 = temp2->pnext;
}
return temp1;
}
}

     9.已知单链表有环，求进入环中的第一个节点

//已知单链表有环，求进入环中的第一个节点
ListNode *TheFirstCircleNode(ListNode *phead)
{
//先找一个在环中的节点，采用快慢指针
ListNode *fast = phead->pnext->pnext;
ListNode *slow = phead->pnext;
while (fast != slow)
{
slow = slow->pnext;
fast = fast->pnext->pnext;
}
//计算环的长度
int len = 1;
fast = fast->pnext;
while (fast!=slow)
{
len++;
fast = fast->pnext;
}
//让一个快指针先走len，然后慢指针开始走，当两个第一次相遇点就是环的第一个节点
fast = phead;
slow = phead;
for (int i = 0; i < len; i++)
{
fast = fast->pnext;
}
while (fast != slow)
{
fast = fast->pnext;
slow = slow->pnext;
}
slow->pnext = NULL; //此处只是为了提炼一个节点出来，免得打印的时候因为是循环，打印循环输出一满屏
return slow;
}

    10.删除一个指定节点，时间复杂度为O(1)

//给出一单链表头指针和一节点指针toBeDel，O(1)时间复杂度删除节点toBeDel
void DelOneNode(ListNode *phead, ListNode *toBeDel)
{
if (toBeDel->pnext == NULL)
{
toBeDel = NULL;
}
toBeDel->val = toBeDel->pnext->val;      //O(1)时间复杂度的话只能将后面节点的值赋给该结点，在将
toBeDel->pnext = toBeDel->pnext->pnext;  //要删除的节点的后一个节点删除；
}

文中均为自己写的代码，均通过自己写的简单的测试，但是肯定还有些测试不能通过，希望有人找出错误给我纠正一下，不胜感谢。待更新ing..