链表相关的热点面试题（一）

先把相关的题目给出来
1. 从尾到头打印单链表
2. 删除一个无头单链表的非尾节点
3. 在无头单链表的一个非头节点前插入一个节点
4. 逆置/反转单链表
5. 单链表排序
6. 合并两个有序链表,合并后依然有序
7. 查找单链表的中间节点， 要求只能遍历一次链表
先把单链表结构给出来

template<typename T>
struct Node
{
    Node<T>* _next;
    T _value;
    Node(const T& value = T())
        :_value(value)
        , _next(NULL)
    {}
};

• 从尾到头打印单链表
  这就是最简袋的递归思想。

void ReversePrint(const Node<int>* node)
{
    if (node == NULL)
        return;
    ReversePrint(node->_next);
    cout << node->_value << " ";
}

• 删除一个无头单链表的非尾节点（链表的O(1)删除）
  乍一看是不是有点没头绪，甚至都不知道题目是什么意思。
  一般的我们要删除一个单链表节点pos，都是找到它的前一个节点prev，然后让prev->next指向pos->next,但是这里说要删除一个无头节点，也就是我们没办法通过遍历找到pos的前一个节点，那怎么办呢？
  其实思路也是很简单的，我们可以通过赋值的方式，只对节点数据就行改变，可以把要删除节点pos->next的数据，也就是del->value赋值给pos，然后再删除del这个节点就好了。
  

void EraseNotTail(Node<int>* node)
{
    assert(node&&node->_next);//去除空节点和尾节点的情况
    Node<int>* del = node->_next;
    node->_value = del->_value;
    node->_next = del->_next;
    delete del;
}

这道题也叫做 链表的O(1)删除。

• 在无头单链表的一个非头节点前插入一个节点
  刚做完上面那道删除，这又来插入是不是感觉很简单。
  思路是一样的:
  我们先申请一个节点newnode,然后将newnode插入到pos后面，然后交换newnode和pos的数据。
  

void InsertFrontNode(Node<int>* node)
{
    assert(node);//去除节点为空情况
    Node<int>* newnode = new Node<int>(5);
    newnode->_next = node->_next;
    node->_next = newnode;
    swap(node->_value, newnode->_value);
}

• 逆置/反转单链表
  

void Reverse(Node<int>*& head)
{
    assert(head!=NULL);
    Node<int>* newhead = head;
    Node<int>* cur = head->_next;
    head->_next = NULL;
    while (cur)
    {
        Node<int>* tmp = cur->_next;
        cur->_next = newhead;
        newhead = cur;
        cur = tmp;
    }
}

• 单链表排序（ 冒泡排序）
  其实就和普通的冒泡排序一样

void BubbleSort(Node<int>* head)
{
    assert(head);   
    if (head->_next== NULL)
        return;
    Node<int>* cur = head;
    Node<int>* tail = NULL;
    while (cur != tail)     //当尾指针不等于头指针时进行冒泡
    {
        while (cur->_next != tail)   //控制cur指针最后到的位置是倒数第二个节点
        {

            if (cur->_value > cur->_next->_value)
            {
                swap(cur->_value, cur->_next->_value);
            }
            cur = cur->_next;
        }
        tail = cur;
        cur = head;
    }
}

• 合并两个有序链表,合并后依然有序
  这里是用递归的思想，每次进来都找数据小的那个节点，让小的节点最为新的头节点，知道有一个链表走到NULL位置。

Node<int>* MergeTwoList(Node<int>*& head1, Node<int>*& head2)
{
    if (head1 == NULL)
        return head2;
    if (head2 == NULL)
        return head1;
    Node<int>* newhead = head1->_value < head2->_value ? head1 : head2;
    if (newhead == head1)
        newhead->_next = MergeTwoList(head1->_next, head2);
    if (newhead == head2)
        newhead->_next = MergeTwoList(head1, head2->_next);
    return newhead;
}

• 查找单链表的中间节点， 要求只能遍历一次链表
  这个就是快慢指针，快指针一次走两步，慢指针一次走一步。
  最后快指针fast走到尾节点的时候，慢指针刚好到中间节点。
  

Node<int>* FindMidNode( Node<int>* head)
{
    assert(head);
    Node<int>* slow= head;
    Node<int>* fast = head;
    while (fast != NULL)
    {
        if(fast->next==NULL)
            break;
        fast=fast->_next->_next;
        slow = slow->_next;
    }
    return slow;
}