数据结构之链表编程（C++）

本例中单链表未添加头结点。
结点定义为：

struct ListNode{    int data;    ListNode* next;    ListNode(int x) :data(x), next(nullptr) {}};

1 单链表尾部添加结点

void AddToTail(ListNode** pHead, int value){    ListNode* pNew = new ListNode(value);    if (*pHead == nullptr)        *pHead = pNew;    else    {        ListNode* pNode = *pHead;        while (pNode->next != nullptr)            pNode = pNode->next;        pNode->next = pNew;    }}

2 删除第i个结点，认为链表非空。

bool DeleteNode(ListNode** pHead, int n){    if (n == 1)    {        *pHead = (*pHead)->next;        return true;    }           ListNode* pNode = *pHead;    int j = 1;    while (pNode->next && j < n-1)    {        pNode = pNode->next;        j++;    }    if (!(pNode->next) || j != n-1)        return false;    ListNode* pDelete = pNode->next;    pNode->next = pDelete->next;    delete pDelete;    pDelete = nullptr;    return true;}

3 第i个位置前插入结点

bool InSertList(ListNode** pHead, int pos, int value){    ListNode* pNew = new ListNode(value);    if (pos == 1)    {        pNew->next = *pHead;        *pHead = pNew;        return true;    }    int j = 1;    ListNode* pNode = *pHead;    while (pNode && j<pos-1)    {        pNode = pNode->next;        j++;    }    if (!pNode || j!=pos-1)        return false;    ListNode* pNext = pNode->next;    pNode->next = pNew;    pNew->next = pNext;    return true;}

4 从尾到头打印链表，通常打印是只读操作。方法一利用栈实现，未修改链表结构。

void PrintListReverse(ListNode* pHead){    stack<int> nodes;    ListNode* pNode = pHead;    while (pNode)    {        nodes.push(pNode->data);        pNode = pNode->next;    }    while (!nodes.empty())    {        cout << nodes.top() << ' ';        nodes.pop();    }}

方法二反转链表，改变了链表结构。打印部分略去。

ListNode* ReverseList(ListNode* pHead){    ListNode* pReverseHead = nullptr;     //建立返回值，简化输入    ListNode* pPrev = nullptr;    ListNode* pNode = pHead;    while (pNode)    {               ListNode* pNext = pNode->next;        if (!pNext)            pReverseHead = pNode;        //不立即返回的原因是还要再连接pNode与pPrev        pNode->next = pPrev;        pPrev = pNode;        pNode = pNext;      }    return pReverseHead;}

5 给定单链表头指针和一个结点（待删除的）指针，o(1)时间内删除该结点
将结点后一位的值赋给前一位，再将后一位删除。要注意的情况有删除的结点是否为尾结点；
链表中是否只有一个结点；并默认待删除的结点位于链表之内。

void DeleteNode(ListNode** pHead, ListNode* pToDelete){    if (!pHead || !pToDelete)        return;    if (pToDelete->next)                  //不是尾结点    {        ListNode* pNext = pToDelete->next;        pToDelete->data = pNext->data;        pToDelete->next = pNext->next;        delete pNext;        pNext = nullptr;    }    else if (*pHead == pToDelete)         //只有一个结点    {        delete pToDelete;        pToDelete = nullptr;        *pHead = nullptr;    }    else                                  //是尾结点    {        ListNode* pNode = *pHead;        while (pNode->next != pToDelete)            pNode = pNode->next;        delete pToDelete;        pToDelete = nullptr;        pNode->next = nullptr;    }}

6 输入一个链表，输出链表的倒数第k个结点， 从1开始计数。
单链表使用两个指针可以在遍历一遍的情况下，完成任务。

ListNode* FindLastK(ListNode* pHead, int k){    if (!pHead || k < 1)        return nullptr;    ListNode* pAhead = nullptr;    ListNode* pBehind = pHead;    for (int i=0;i<k-1;++i)    {        pBehind = pBehind->next;        if (!pBehind)            return nullptr;    }    pAhead = pHead;    while (pBehind->next)    {        pAhead = pAhead->next;        pBehind = pBehind->next;    }    return pAhead;}

7 合并两个排序的链表
输入两个递增排序的链表，合并两个链表使结点仍是递增排序的。举例1–3-5-7，2-4-6-8
1-2-3-4-5-6-7-8. 相同重复的问题考虑递归调用。

ListNode* Merge(ListNode* pHead1, ListNode* pHead2){    if (!pHead1)        return pHead2;    else if (!pHead2)        return pHead1;    ListNode* pHeadMerge = nullptr;    if (pHead1->data > pHead2->data)    {        pHeadMerge = pHead2;        pHeadMerge->next = Merge(pHead1, pHead2->next);    }    else    {        pHeadMerge = pHead1;        pHeadMerge->next = Merge(pHead1->next, pHead2);    }    return pHeadMerge;}

8 复杂链表的复制。每个结点除了有一个next指针指向下一个结点，还有一个pBling指向链表的任意结点。大问题化分成一个个的小问题。找到影响效率的关键，再找效率高的替代解决方案。

结点定义为：

struct complexListNode{    int data;    complexListNode* next;    complexListNode* bling;    complexListNode(int x) :data(x), next(nullptr), bling(nullptr) {};};

实现的有三部分，1 本来是A-B-C-D, 变为A-A’-B-B’-C-C’-D-D’;

void CloneNodes(complexListNode* pHead){    complexListNode* pNode = pHead;    while (pNode)    {        complexListNode* pNew = new complexListNode(pNode->data);        pNew->next = pNode->next;        pNode->next = pNew;        pNode = pNew->next;    }}

2 将原有的A-B-C-D的bling的下一位赋给A’-B’-C’-D’.

void connectPBling(complexListNode* pHead){    complexListNode* pNode = pHead;     while (pNode)    {        complexListNode* pNodeClone = pNode->next;        if (pNode->bling)            pNodeClone->bling = pNode->bling->next;        pNode = pNodeClone->next;    }}

3 拆分两个链表为 A-B-C-D和A’-B’-C’-D’

complexListNode* seperate(complexListNode* pHead){    complexListNode* pNode = pHead;    complexListNode* pHeadClone = pNode->next;    complexListNode* pNodeClone = pNode->next;    while (pNode)    {           pNode->next = pNodeClone->next;        pNode = pNode->next;        if (!pNode)      //pNode到达尾部            break;        pNodeClone->next = pNode->next;        pNodeClone = pNodeClone->next;    }    return pHeadClone;}

4 合起来为：

complexListNode* clone(complexListNode* pHead){    if (!pHead)             return nullptr;    CloneNodes(pHead);    connectPBling(pHead);    return seperate(pHead);}

9 输入两个链表，找出它们的第一个公共结点。

ListNode* FindCommonNode(ListNode* pHead1, ListNode* pHead2){    if (!pHead1 || !pHead2)        return nullptr;    int length1 = 0, length2 = 0;    ListNode* pNode = pHead1;    while (pNode)    {        pNode = pNode->next;        length1++;    }    pNode = pHead2;    while (pNode)    {        pNode = pNode->next;        length2++;    }    int lenghtdif = length1 - length2;    ListNode* pHeadLong = pHead1;    ListNode* pHeadShort = pHead2;    if (length1 < length2)    {        pHeadLong = pHead2;        pHeadShort = pHead1;        lenghtdif = length2 - length1;    }    for (int i = 0; i < lenghtdif; ++i)        pHeadLong = pHeadLong->next;    while (pHeadLong && pHeadShort && pHeadLong!=pHeadShort)    {        pHeadLong = pHeadLong->next;        pHeadShort = pHeadShort->next;          }    return pHeadLong;}

10 输入一颗二叉搜索树，将该二叉搜索树转换成排序的双向链表。只能调整树中结点指针的方向。
递归的一个重要思想，子问题已完成。大问题分解成小问题。

struct BinaryTreeNode{    int data;    BinaryTreeNode* left;    BinaryTreeNode* right;};BinaryTreeNode* Convert(BinaryTreeNode* pRoot){    BinaryTreeNode* pLastNode = nullptr;    ConvertNode(pRoot, &pLastNode);    BinaryTreeNode* pHead = pLastNode;    while (pHead && pHead->left)        pHead = pHead->left;    return pHead;}void ConvertNode(BinaryTreeNode* pRoot, BinaryTreeNode** pLastNode){    if (!pRoot)        return;    BinaryTreeNode* pCurrent = pRoot;    if (pCurrent->left)        ConvertNode(pRoot->left, pLastNode);    pCurrent->left = *pLastNode;    if (*pLastNode)        (*pLastNode)->right = pCurrent;    *pLastNode = pCurrent;    if (pCurrent->right)        ConvertNode(pRoot->right, pLastNode);}

11 0，1,….n-1这n个数字排成一个圆圈，从数字0开始每次从这个圆圈里删除第m个数字。求圆圈里剩下的最后一个数字。

int LastNumLeft(int n, int m){    if (n < 1 || m < 1)        return -1;    list<int> li;    for (int i = 0; i < n; ++i)        li.push_back(i);    list<int>::iterator it = li.begin();    while (li.size()>1)    {        for (int i=0;i<m-1;++i)        {            if (it == li.end())                it = li.begin();            else            {                it++;                if (it == li.end())                    it = li.begin();            }                       }        it = li.erase(it);        if (it == li.end())          //删除为链表最后一个结点，赋值begin()            it = li.begin();    }    return li.front();}