单链表相关的面试题

#pragma once
#include"List.h"

//1.逆序打印单链表
template<class T>
void List<T>::PrintTailToHead(Node * pHead)
{
    if (pHead == NULL)
        return;
    PrintTailToHead(pHead->_next);
    cout << pHead->_value << " -> ";
}

//2.删除无头节点的单链表的非尾节点
template<class T>
void List<T>::DelNonTailNode(Node * pos)
{
    assert(pos && pos->_next);
    Node* tmp = pos->_next;
    pos->_value = tmp->_value;
    pos->_next = tmp->_next;
    delete tmp;
}

//3.无头单链表某一节点前插入一个节点
template<class T>
void List<T>::InsertFrontNode(Node* pos, T x)
{
    assert(pos);
    Node* tmp = new Node(x);
    tmp->_next = pos->_next;
    pos->_next = tmp;
    swap(pos->_value, tmp->_value);
}


//4.逆置单链表
template<class T>
void List<T>::ReverseList()
{
    Node* cur = _head, *new_head = NULL, *tmp;
    while (cur)
    {
        tmp = cur;
        cur = cur->_next;
        tmp->_next = new_head;
        new_head = tmp;
    }
    _head = new_head;
}

//5.单链表的冒泡排序
template<class T>
void List<T>::BubbleSortOfList()
{
    if (_head == NULL || _head->_next == NULL)
        return;
    Node* tail = NULL,*cur;
    bool sign = true;
    while (tail != _head && sign)
    {
        Node* tmp = NULL;
        cur = _head;
        while (cur->_next != tail)
        {
            if (cur->_value > cur->_next->_value)
            {
                swap(cur->_value, cur->_next->_value);
                tmp = cur;
            }
            cur = cur->_next;
        }
        tmp == NULL ? sign = false : tail = cur;;
    }
}

//6.中间节点
template<class T>
ListNode<T>* List<T>::MiddleOfList()
{
    if (_head == NULL || _head->_next == NULL)
        return NULL;
    Node* fast = _head, *slow = _head;
    while (fast && fast->_next)
    {
        slow = slow->_next;
        fast = fast->_next->_next;
    }
    return slow;
}

//7.单链表中的倒数第 k 个节点
template<class T>
ListNode<T>* List<T>::ReciprocalK(int k)
{
    if (_head == NULL)
        return NULL;
    Node* tmp = _head, *result = _head;
    while (k--)
    {
        tmp = tmp->_next;
        if (tmp == NULL)
            return (k == 0 ? _head : NULL);
    }
    while (tmp)
    {
        result = result->_next;
        tmp = tmp->_next;
    }
    return result;
}

//8.判断一个链表是否带环，如果带环求出环的长度以及入口点
template<class T>
ListNode<T>* List<T>::IsRingList()
{
    if (_head == NULL)
        return false;
    Node* fast = _head,* slow = _head,* Input;
    while (fast && fast->_next)
    {
        if (fast == slow)     //链表带环 输出环的长度和入口点
        {
            int count = 1;
            do
            {
                slow = slow->_next;
                fast = fast->_next->_next;
                ++count;
            } while (fast == slow);
            cout << "环的节点的个数为：" << count << endl;

            while (Input == slow)
            {
                Input = Input->_next;
                slow = slow->_next;
            }
            return Input;
        }
    }
    return NULL;
}

//9.判断两个链表是否相交，如果相交求出交点(不带环)
template<class T>
ListNode<T>* List<T>::IsCross(const List<T>& List1, const List<T>& List2)
{
    Node* Tmp1 = List1._head, Tmp2 = List2._head;
    int Length1 = 0, Length2 = 0;
    while (Tmp1)
    {
        Length1++;
        Tmp1 = Tmp1->_next;
    }
    while (Tmp2)
    {
        Length2++;
        Tmp2 = Tmp2->_next;
    }

    Tmp1 = List1._head, Tmp2 = List2._head;   /*重新指向链表的头*/
    int n = abs(Length1 - Length2);
    if (Length1 > Length2)        /*如果链表一 长于 链表二*/
    {
        while (n--)
        {
            Tmp1 = Tmp1->_next;
        }
    }
    else                          /*如果链表二 长于 链表一*/
    {
        while (n--)
        {
            Tmp2 = Tmp2->_next;
        }
    }

    while (Tmp1)
    {
        if (Tmp1 == Tmp2)
            return Tmp1;        /*找到了交点，返回*/
        else
        {
            Tmp1 = Tmp1->_next;
            Tmp2 = Tmp2->_next;
        }
    }
    return NULL;                /*没找到，NULL 返回*/
}


//10.判断两个链表是否相交，如果相交求出交点(不确定带不带环)
template<class T>
ListNode<T>* List<T>::IsCrossStrengthen(const List<T>& List1, const List<T>& List2)
{
    Node* Cross1 = List1.IsRingList(), *Cross2 = List2.IsRingList();
    if (Cross1 == NULL && Cross2 == NULL)   /*两个链表均不带环*/
        return List1.IsCross(List1, List2);
    else if (Cross1 && Cross2)   /*两个均代环*/
    {
        if (Cross1 == Cross2)
            return Cross1;
        Node* tmp = Cross1->_next;
        while (tmp != Cross1)
        {
            if (Cross1 == Cross2)
                return Cross1;
            tmp = tmp->_next;
        }
    }
    return false;    /*一个链表带环，一个不带环*/
}