线性表总结

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这句代码的
功能是移到下一个结点去。