单链表常见笔试面试题总结

1.单链表逆置

#include <iostream>
using namespace std;

typedef int KeyType;
typedef struct Node
{
    KeyType value;
    Node *next;
}Node, *List;

void Reserver(List plist)
{
    // 链表为NULL/只有一个头节点/链表只有一个头节点和数据节点 --->不用交换
    if(plist==NULL|| plist->next==NULL|| plist->next->next==NULL)
    {
        return;
    }

    //链表至少有两个节点
    Node *p = plist->next;
    Node *q = p->next;
    Node *s;

    plist->next = NULL;//头节点要指向尾节点，先将其指针域赋为NULL
    while(q != NULL)
    {
        s = q->next;
        q->next = p;
        p = q;
        q = s;
    }
    plist->next = p;
    return;
}

2.逆序打印单链表

//1.如果要破坏单链表的结构，则像1题一样，使用断链-接链，然后遍历单链表
//2.如果不能破坏单链表的结构，可以使用stack，遍历后压栈，最后统一出栈
#include <iostream>
#include <stack>
using namespace std;

void PrintReserve(List plist)
{
    if(plist == NULL)
        return;

    stack<KeyType> st;

    Node *p = plist->next;
    while(p != NULL)
    {
        st.push(p->value);
        p = p->next;
    }

    while(!st.empty())
    {
        cout<<st.top()<<endl;
        st.pop();
    }
    return;
}

3.给定单链表，检测是否有环

思想：使用快慢指针，快指针每次走两格，慢指针每次走一格。如果有环，快慢指针总会相遇。如果快慢指针相遇，说明有环。如果快指针为NULL，则说明无环。

bool IsExitLoop(List plist)
{
    if(plist==NULL || plist->next==NULL)
    {
        return false;
    }

    Node *fast = plist;
    Node *slow = plist;

    while(fast!=NULL || slow!=NULL)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
        {
            break;
        }
    }
    //退出循环，slow==false，有环  或者fast==NULL，没有环
    return fast==NULL ? false : true;
}

4.求环的长度
思想：从相遇节点开始，下次再走到该相遇点时经过的节点数为环的长度。

int LoopLength(List plist)
{
    if(plist==NULL || plist->next==NULL)
        return 0;

    Node *fast = plist;
    Node *slow = plist;
    while(fast!=NULL || slow!=NULL)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
        {
            break;
        }
    }

    if(fast == NULL)//没有环
    {
        return 0;
    }

    Node *tmp = slow;
    slow = slow->next;
    int count = 1;
    while(slow != tmp)
    {
        slow = slow->next;
        ++count;
    }
    count += 1;
    return count;
}

5.给定单链表(head)，如果有环的话返回从头结点进入环的第一个节点
思想：有定理证明，碰撞点到尾节点的距离=头节点到入口点的距离。慢指针从头节点开始走，快从相遇点开始走。当快指针为NULL时，慢指针所指的节点为环的第一个节点。

Node *FindEntryNode(List plist)
{
    if(plist==NULL || plist->next==NULL)
        return NULL;

    Node *fast = plist;
    Node *slow = plist;
    while(fast!=NULL || slow!=NULL)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
        {
            break;
        }
    }

    if(fast ==NULL)
    {
        return NULL;
    }

    slow = plist;

    while(fast != slow)
    {
        fast = fast->next;
        slow = slow->next;
    }

    return slow==fast ? slow  : NULL;
}

6.给定两个单链表(plist1, plist2)，检测两个链表是否有交点，如果有返回第一个交点

思想：如果plist1==plist2,链表相交点就是plist1。否则，先求出链表的长度，让快指针先走len1-len2步，然后快慢指针开始走，每次走一步。当快指针走到尾节点时，慢指针指向的节点为链表的相交点。

Node *FindNode(List plist1, List plist2)
{
    if(plist1==NULL || plist2==NULL)//指针不为NULL
    {
        return NULL;
    }

    if(plist1 == plist2)//指针指向同一个链表
    {
        return plist1;
    }

    Node *p = plist1;
    Node *q = plist2;

    int len1 = 0;
    int len2 = 0;

    for(; p!=NULL; p=p->next)
        ++len1;

    for(; q!=NULL; q=q->next)
        ++len2;

    int num = len1>len2 ? len1-len2 : len2-len1;

    int i =0;
    p = plist1;
    while(i<num && p->next!=NULL)
    {
        p = p->next;
        ++i;
    }
    q = plist2->next;

    while(p != q)
    {
        p = p->next;
        q = q->next;
    }

    return q;
}

7.只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点

思想：用后值覆盖前值，删除最后一个节点。切记：将倒数第二个节点的next域置为NULL。

bool DeleteNode(Node *p)
{
    if(p == NULL)
        return false;

    Node *tmp;
    while(p->next != NULL)
    {
        p->value = p->next->value;
        if(p->next->next == NULL)
        {
            tmp = p;
        }
        p = p->next;
    }

    tmp->next = NULL;
    delete p;

    return true;
}

8.给定单链表头结点，删除链表中倒数第k个结点

思想：快指针先走K步，然后快慢指针一块走，每次走1步，当快指针到达结尾的下一个节点(NULL)时，慢指针到达倒数第K个节点

bool DeleteKNode(List plist, int num)
{
    if(plist==NULL || plist->next==NULL || num<1)
        return false;

    Node *front = plist;
    for(int i=0; i<num; ++i)
    {
        if(front ==NULL)
            return false;
        front = front->next;
    }

    Node *back = plist;
    Node *tmp = plist;
    while(front != NULL)
    {
        front = front->next;
        back = back->next;
    }

    //back所指向的节点为倒数第K个节点
    DeleteNode(back);
    return true;
}

9.只给定单链表中某个结点p(非空结点)，在p前面插入一个结点val

思想：在p后面添加一个节点s，s->value=p->value; p->value=val

bool InsertNode(Node *p, KeyType val)
{
    Node *s = (Node *)malloc(sizeof(Node));
    s->next = p->next;
    p->next = s;

    s->value = p->value; 
    p->value = val;
    return true;
}