剑指offer --反向输出链表与输出链表的倒数第k个元素

最新推荐文章于 2024-03-22 22:43:55 发布
lengshien
最新推荐文章于 2024-03-22 22:43:55 发布
阅读量278
点赞数
分类专栏：剑指offer 文章标签：链表
本文链接：https://blog.csdn.net/lengshien/article/details/71680565
版权
剑指offer 专栏收录该内容
5 篇文章 0 订阅
订阅专栏
List.h

#ifndef LIST_H
#define LIST_H
#include <stdio.h>
#include <stdlib.h>

struct ListNode
{
  int m_nValue;
  ListNode* m_pNext;
};
ListNode* CreatListNode(int value);
void ConnectListNodes(ListNode* pCurrent,ListNode pNext);
void PrintListNode(ListNode* pNode);
void PrintList(ListNode* phead);
void DestroyList(ListNode* phead);
void AddToTail(ListNode** phead,int value);
void RemoveNode(ListNode** phead,int value);

ListNode* CreateListNode(int value)
{
    ListNode *pNode = new ListNode();
    pNode->m_nValue = value;
    pNode->m_pNext = nullptr;

    return pNode;
}
void ConnectListNodes(ListNode* pCurrent,ListNode* pNext)
{
    if(pCurrent==nullptr)
    {
        printf("Error to connect two nodes!!\n");
        exit(1);
    }

    pCurrent->m_pNext = pNext;

}

void PrintListNode(ListNode* pNode)
{
    if(pNode==nullptr)
    {
        printf("The node is nullptr.\n");
    }
    else
    {
        printf("The key in node is %d.\n",pNode->m_nValue);
    }

}
void PrintList(ListNode* phead)
{
    printf("\n Print list starts.\n");
    ListNode* pNode = phead;
    while(pNode!=nullptr)
    {
        printf("%d\t",pNode->m_nValue);
        pNode = pNode->m_pNext;
    }
    printf("\nPrint List end.\n");
}
void DestroyList(ListNode* phead)
{
    ListNode* pNode = phead;
    while(pNode!=nullptr)
    {
        phead = phead->m_pNext;
        delete pNode;
        pNode = phead;
    }
}
void AddToTail(ListNode** phead,int value)
{
    ListNode* pNew = new ListNode();
    pNew->m_nValue = value;
    pNew->m_pNext = nullptr;

    if(*phead == nullptr)
    {
        *phead = pNew;
    }
    else
    {
        ListNode* pNode = *phead;
        while(pNode->m_pNext!=nullptr)
            pNode = pNode->m_pNext;
        pNode->m_pNext = pNew;
    }
}
void RemoveNode(ListNode** phead,int value)
{
  if(*phead == nullptr||phead == nullptr)
    return ;
  ListNode* pToBeDeleted = nullptr;

  if((*phead)->m_nValue == value)
  {
      pToBeDeleted = *phead;
      *phead = (*phead)->m_pNext;
  }
  else
  {
      ListNode* pNode = *phead;
      while(pNode->m_pNext!=nullptr&&pNode->m_pNext->m_nValue!=value)
        pNode = pNode->m_pNext;
      if(pNode->m_pNext!=nullptr&&pNode->m_pNext->m_nValue==value)
      {
          pToBeDeleted = pNode->m_pNext;
          pNode->m_pNext = pNode->m_pNext->m_pNext;
      }
      if(pToBeDeleted!=nullptr)
      {
          delete pToBeDeleted;
          pToBeDeleted = nullptr;
      }
  }
}



#endif // LIST_H



 #include "List.h"
#include <stack>
#include <cstdio>

void PrintListReversingly_Iteratively(ListNode* pHead)
{
    std::stack<ListNode*> nodes;

    ListNode* pNode = pHead;
    while(pNode!=nullptr)
    {
        nodes.push(pNode);
        pNode = pNode->m_pNext;
    }
    while(!nodes.empty())
    {
        pNode = nodes.top();
        printf("%d\t",pNode->m_nValue);
        nodes.pop();
    }
}

void PrintListReversingly_Recursively(ListNode* pHead)
{
    if(pHead!=nullptr)
    {
        if(pHead->m_pNext!=nullptr)
        PrintListReversingly_Recursively(pHead->m_pNext);

        printf("%d\t",pHead->m_nValue);
    }

}
ListNode* FindKthToTail(ListNode* pHead,unsigned int k)
{
    if(pHead==nullptr||k==0)
        return nullptr;

    ListNode* pAhead=pHead;
    ListNode* pBehind =nullptr;
    for(unsigned int i=0;i<k-1;i++)
    {
        if(pAhead->m_pNext!=nullptr)
        {
            pAhead = pAhead->m_pNext;
        }
        else
            return nullptr;
    }
    pBehind = pHead;
    while(pAhead->m_pNext!=nullptr)
    {
        pAhead = pAhead->m_pNext;
        pBehind = pBehind->m_pNext;
    }
    return pBehind;
}
//void Test(ListNode* pHead)
//{
//    PrintList(pHead);
//    PrintListReversingly_Iteratively(pHead);
//    printf("\n");
//    PrintListReversingly_Recursively(pHead);
//}
//void Test1()
//{
//    printf("\n Test1 begin. \n");
//
//    ListNode *pNode1 = CreatListNode(1);
//    ListNode *pNode2 = CreatListNode(2);
//    ListNode *pNode3 = CreatListNode(3);
//    ListNode *pNode4 = CreatListNode(4);
//    ListNode *pNode5 = CreatListNode(5);
//
//    ConnectListNodes(pNode1,pNode2);
//    ConnectListNodes(pNode2,pNode3);
//    ConnectListNodes(pNode3,pNode4);
//    ConnectListNodes(pNode4,pNode5);
//
//    Test(pNode1);
//    DestroyList(pNode1);
//}
//void Test2()
//{
//    printf("\n Test2 begin. \n");
//    ListNode *pNode1 = CreatListNode(1);
//    Test(pNode1);
//    DestroyList(pNode1);
//}
//void Test3()
//{
//    printf("\n Test3 begin. \n");
//    ListNode *pNode1 = nullptr;
//    Test(pNode1);
//    DestroyList(pNode1);
//}

// ====================测试代码====================
// 测试要找的结点在链表中间
void Test1()
{
    printf("=====Test1 starts:=====\n");
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    printf("expected result: 4.\n");
    ListNode* pNode = FindKthToTail(pNode1, 2);
    PrintListNode(pNode);

    DestroyList(pNode1);
}
// 测试要找的结点是链表的尾结点
void Test2()
{
    printf("=====Test2 starts:=====\n");
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    printf("expected result: 5.\n");
    ListNode* pNode = FindKthToTail(pNode1, 1);
    PrintListNode(pNode);

    DestroyList(pNode1);
}
// 测试要找的结点是链表的头结点
void Test3()
{
    printf("=====Test3 starts:=====\n");
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    printf("expected result: 1.\n");
    ListNode* pNode = FindKthToTail(pNode1, 5);
    PrintListNode(pNode);

    DestroyList(pNode1);
}
// 测试空链表
void Test4()
{
    printf("=====Test4 starts:=====\n");
    printf("expected result: nullptr.\n");
    ListNode* pNode = FindKthToTail(nullptr, 100);
    PrintListNode(pNode);
}
// 测试输入的第二个参数大于链表的结点总数
void Test5()
{
    printf("=====Test5 starts:=====\n");
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    printf("expected result: nullptr.\n");
    ListNode* pNode = FindKthToTail(pNode1, 6);
    PrintListNode(pNode);

    DestroyList(pNode1);
}
// 测试输入的第二个参数为0
void Test6()
{
    printf("=====Test6 starts:=====\n");
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    printf("expected result: nullptr.\n");
    ListNode* pNode = FindKthToTail(pNode1, 0);
    PrintListNode(pNode);

    DestroyList(pNode1);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();

    return 0;
}