线性表总结

1. 代码段1简介：合并两个有序链表

1.1. 代码1

struct ListNode                                                                                        \1
{                                                                                                      \2
    int m_nValue;                                                                                      \3
    ListNode *m_pNext;                                                                                 \4
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)                                                \5
{                                                                                                      \6
    if(pHead1 == NULL)                                                                                 \7
        return pHead2;                                                                                 \8
    else if(pHead2 == NULL)                                                                            \9
        return pHead1;                                                                                 \10
                                                                                                       \11
    ListNode* pMergedHead = NULL;                                                                      \12
                                                                                                       \13
    if(pHead1->m_nValue < pHead2->m_nValue)                                                            \14
    {                                                                                                  \15
        pMergedHead = pHead1;                                                                          \16
        pMergedHead->m_pNext = Merge(pHead1->m_pNext, pHead2);                                         \17 
    }                                                                                                  \18
    else                                                                                               \19            
    {                                                                                                  \20
        pMergedHead = pHead2;                                                                          \21
        pMergedHead->m_pNext = Merge(pHead1, pHead2->m_pNext);                                         \22 
    }                                                                                                  \23
                                                                                                       \24
    return pMergedHead;                                                                                \25
};                                                                                                     \26

2. 不懂的地方

14行到23行，为什么这个功能的实现需要写一个递归函数？
遍历整个链表，将数据一个个插入到总链表里的方法是否可行，两种方法孰优孰劣呢？

第7行到第10行设置的两个判断条件，能够有效防止因空链表导致程序的奔溃，这很值得我们学习！

2. 代码段1简介：查找倒数第k个结点

2.1 代码1

int findNode(LinkList l,int k)     \1
{                                  \2
    Node *s1,*s2;                  \3
    s1=s2=l;                       \4
    int counter=0;                 \5
    while(s1->next)                \6
    {                              \7                
        if(counter<k-1)            \8
        {                          \9
            s1=s1->next;           \10
            counter++;             \11
        }                          \12
        else                       \13
        {                          \14
            s1=s1->next;           \15
            s2=s2->next;           \16
        }                          \17
    }                              \18
    return s2->data;               \19
}                                  \20

typedef struct Node                \21
{                                  \22
    int data;                      \23
    Node *next;                    \24
}*LinkList;                        \25

2.2 自己不懂的地方

20-24行是结构体定义哦
我不明白13-17行的代码是如何实现找到倒数第k个结点的值的功能的？

第六行，while循环里的条件是判断s1的下一个结点是否为空，为空则不执行循环。
第8-12行的代码，是判断程序是否遍历到了倒数第k个结点，s1=s1->next这句代码的
功能是移到下一个结点去。