单链表常见操作

单链表的翻转，找倒数第K个节点

typedef struct ListNode_t
{
    int value;
    struct ListNode_t *next;
}ListNode;


/*找到链表倒数第K个节点*/
ListNode* find_kth_to_tail(ListNode* pListHead, unsigned int k)
{
    if((NULL == pListHead) || (0 == k))
    {
        return NULL;
    }
    ListNode* p_fast = pListHead;
    ListNode* p_slow = pListHead;

    for(unsigned int i = 0; i < k-1; i++)
    {
        if(p_fast->next != NULL)
        {
            p_fast = p_fast->next;
        }
        else
        {
            return NULL;        
        }       
    }

    while(p_fast->next != NULL)
    {
        p_fast = p_fast->next;
        p_slow = p_slow->next;
    }
    return p_slow;
}

/*翻转链表*/
ListNode* reverse_list(ListNode* pListHead)
{
    if(NULL == pListHead)
    {
        return NULL;
    }
    ListNode *reversed_list_head = NULL;
    ListNode *prev_node = NULL;
    ListNode *cur_node = pListHead;
    ListNode *next_node = pListHead->next;

    while(NULL != cur_node)
    {
        next_node = cur_node->next;
        
        if(next_node == NULL)
        {
            reversed_list_head = cur_node;
        }

        cur_node->next = prev_node;
        prev_node = cur_node;
        cur_node = next_node;
    }

    return reversed_list_head;
}

/*合并排序链表：递归*/
ListNode* merge_list(ListNode* pListHead1, ListNode* pListHead2)
{
    ListNode* p_merged_list_head = NULL;
    if(pListHead1 == NULL)
    {
        return pListHead2;
    }
    else if(pListHead2 == NULL)
    {
        return pListHead1;
    }

    if(pListHead1->value < pListHead2->value)
    {
        p_merged_list_head->value = pListHead1->value;
        p_merged_list_head->next = merge_list(pListHead1->next, pListHead2);
    }
    else if(pListHead1->value > pListHead2->value)
    {
        p_merged_list_head->value = pListHead2->value;
        p_merged_list_head->next = merge_list(pListHead1, pListHead2->next);
    }

    return p_merged_list_head;
}

/*合并排序链表：非递归*/
ListNode* merge_list(ListNode* pListHead1, ListNode* pListHead2)
{
    if(pListHead1 == NULL)
    {
        return pListHead2;
    }
    else if(pListHead2 == NULL)
    {
        return pListHead1;
    }

    /*先创建一个合并后的链表头结点*/
    ListNode* p_merged_list_head = (ListNode*)malloc(sizeof(ListNode));
    memset(p_merged_list_head, 0, sizeof(ListNode));

    ListNode *tmp = p_merged_list_head;
    ListNode* tmp_node1 = pListHead1;
    ListNode* tmp_node2 = pListHead2;

    while ((NULL != tmp_node1) && (NULL != tmp_node2)))
    {
        if(tmp_node1->value > tmp_node2->value)
        {
            tmp->next = tmp_node2;
            tmp_node2 = tmp_node2->next;
        }
        else if(tmp_node1->value < tmp_node2->value)
        {
            tmp->next = tmp_node1;
            tmp_node1 = tmp_node1->next;
        }
        tmp = tmp->next;
    }
    
    /*有一个链表已经走到了尾部*/
    if(tmp_node1 == NULL)
    {
        tmp->next = tmp_node2;
    }

    if(tmp_node2 == NULL)
    {
        tmp->next = tmp_node1;
    }

    ListNode* result = p_merged_list_head->next;

    /*将申请的链表节点释放*/
    free(p_merged_list_head);
    p_merged_list_head = NULL;

    return result;
}


/*O(1)时间内删除链表中指定的某一个节点*/
void delete_list_node(ListNode **pListHead, ListNode* dlt_node)
{
    if((NULL == pListHead) || (NULL == dlt_node))
    {
        return;
    }

    /*要删除的节点不是尾节点*/
    if(dlt_node->next != NULL)
    {
        ListNode* next_node = dlt_node->next;
        dlt_node->value = next_node->value;
        dlt_node->next = next_node->next;

        free(dlt_node);
        dlt_node = NULL;
    }

    /*链表中只有一个节点*/
    else if(*pListHead == dlt_node)
    {
        free(dlt_node);
        dlt_node = NULL;

        *pListHead = NULL;
    }
    /*链表中有多个节点，删除尾节点*/
    else
    {
        ListNode* tmp =*pListHead;
        while(tmp->next != NULL)
        {
            tmp = tmp->next;
        }

        tmp->next = NULL;
        free(dlt_node);
        dlt_node = NULL;
    }
    return;
}