链表笔试面试题

// 链表节点
struct ListNode
{
    int value;
    ListNode* next;
};

// 求单链表中结点的个数 注意链表判断是否为空 时间复杂度O(n)
size_t GetListLength(ListNode* head)
{
    if(!head)
    {
        return 0;
    }

    size_t length = 0;
    ListNode* current = head;

    while (current != NULL)
    {
        ++length;
        current = current->next;
    }

    return length;
}

// 反转单链表 时间复杂度O(n)
ListNode* ReverseList(ListNode* head)
{
    // 如果链表为空或只有一个结点，无需反转，直接返回原链表头指针
    if(head == NULL && head->next == NULL)
    {
        return NULL;
    }

    ListNode* new_head = NULL; // 链表反转后新链表的头结点
    ListNode* current = head;

    while (current != NULL)
    {
        ListNode* tmp = current; // 保存当前结点
        current = current->next;
        tmp->next = new_head; // 插入到新的头结点之前
        new_head = tmp;
    }

    return new_head;
}

// 查找单链表中倒数第K个数(k>0)
/*主要思路就是使用两个指针，先让前面的指针走到正向第k个结点，这样前后两个指针的距离差是k-1，
之后前后两个指针一起向前走，前面的指针走到最后一个结点时，后面指针所指结点就是倒数第k个结点。*/
ListNode* GetReverseKthNode(ListNode* head, size_t k)
{
    if(k == 0 || head == NULL)
    {
        return NULL;
    }

    ListNode* ahead = head;
    ListNode* back = head;


    while (k > 1 && ahead != NULL) // 前面的指针先走到正向第k个结点
    {
        ahead = ahead->next;
        --k;
    }

    if(k > 1 || ahead == NULL) //结点数目小于k 返回NULL
    {
        return NULL;
    }

    while(ahead->next != NULL) // 前后两个指针一起向前走，直到前面的指针指向最后一个结点
    {
        back = back->next;
        ahead = ahead->next;
    }

    return back; // 后面的指针所指结点就是倒数第k个结点
}

//查找单链表的中间结点 若链表长度为n(n>0)，则返回第n/2+1个结点
//设置两个指针，只不过这里是，两个指针同时向前走，前面的指针每次走两步，
//后面的指针每次走一步，前面的指针走到最后一个结点时，后面的指针所指结点就是中间结点，即第（n/2+1）个结点。
//注意链表为空，链表结点个数为1和2的情况。时间复杂度O（n）。
ListNode* GetMiddleNode(ListNode* head)
{
    if(head == NULL || head->next == NULL) // 链表为空或只有一个结点，返回头指针
    {
        return NULL;
    }

    ListNode* ahead = NULL;
    ListNode* back = NULL;

    while(ahead->next != NULL) // 前面指针每次走两步，直到指向最后一个结点，后面指针每次走一步
    {
        ahead = ahead->next;
        back = back->next;
        if(ahead->next != NULL)
        {
            ahead = ahead->next;
        }
    }

    return back;
}

// 从尾到头打印单链表
// 对于这种颠倒顺序的问题，我们应该就会想到栈，后进先出。
void ReversePrintList(ListNode* head)
{
    std::stack<ListNode*> stack;
    ListNode* node = head;

    while(node != NULL)
    {
        stack.push(node);
        node = node->next;
    }

    while(!stack.empty())
    {
        node = stack.top();
        cout << node->value;
        stack.pop();
    }
}

// 从尾到头打印单链表递归版本
void ReversePrintList_recursion(ListNode* node)
{
    if(node == NULL)
    {
        return;
    }
    else
    {
        ReversePrintList_recursion(node->next);
        cout << node->value;
    }
}

// 两个单链表Head1和Head2 各自有序，把它们合并成一个链表依然有序
// 注意两个链表都为空，和其中一个为空时的情况
ListNode* MergeSortedList(ListNode* head_1, ListNode* head_2)
{
    if(head_1 == NULL)
    {
        return head_2;
    }
    if(head_2 == NULL)
    {
        return head_1;
    }

    ListNode* new_head = NULL; // 合并后新链表的头结点

    /* 先让new_head指向head1和head2值小的那个 */
    if(head_1->value <= head_2->value)
    {
        new_head = head_1;
        head_1 = head_1->next;
        new_head->next = NULL;
    }
    else
    {
        new_head = head_2;
        head_2 = head_2->next;
        new_head->next = NULL;
    }

    /* 依次比较head1中head2中的值，哪个小就插入到新链表中 */
    ListNode* tmp = new_head;
    while(head_1 != NULL && head_2 != NULL)
    {
        if(head_1->value <= head_2->value)
        {
            tmp->next = head_1;
            head_1 = head_1->next;
            tmp = tmp->next;
            tmp->next = NULL;
        }
        else
        {
            tmp->next = head_2;
            head_2 = head_2->next;
            tmp = tmp->next;
            tmp->next = NULL;
        }
    }

    /* head1与head2中长的链表剩余的部分插入到新链表中 */
    if(head_1 != NULL)
    {
        tmp->next = head_1;
    }
    else if(head_2 != NULL)
    {
        tmp->next = head_2;
    }

    return new_head;
}

// 判断链表是否有环
// 如果一个链表中有环，也就是说用一个指针去遍历，是永远走不到头的。
// 因此，我们可以用两个指针去遍历，一个指针一次走两步，一个指针一次走一步，如果有环，两个指针肯定会在环中相遇。
// 时间复杂度为O(n)
bool hasCircle(ListNode* head)
{
    ListNode* fast = head;
    ListNode* slow = head;

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

        if(fast == slow)
        {
            return true;
        }
    }

    return false;
}