华为OJ-输出单向链表中倒数第k个节点

题目描述

输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。

链表结点定义如下：

struct ListNode
{
      int       m_nKey;
      ListNode* m_pNext;
};

函数原型

ListNode* FindKthToTail(ListNode* pListHead, unsignedint k);
输入参数：
        ListNode* pListHead  单向链表
     unsigned int k  倒数第k个结点
输出参数（指针指向的内存区域保证有效）：
    无
返回值：
        正常返回倒数第k个结点指针，异常返回空指针

输入描述

1. 输入链表结点个数
2. 输入链表的值
3. 输入k的值

输出描述

输出一个整数

输入例子

8

1 2 3 4 5 6 7 8

4

输出例子

5

主要考虑传入参数不合法以及返回值为空时的输出

代码

#include <iostream>
#include <string>
using namespace std;

struct ListNode
{
  int m_nValue;
  ListNode* m_pNext;
};
void InsertNode(ListNode** pListHead, int value)
{
  ListNode* newNode = new ListNode;
  if (newNode == NULL)return;

  newNode->m_nValue = value;
  newNode->m_pNext = NULL;

  if (*pListHead == NULL)/*空链表*/
  {
    *pListHead = newNode;
  }
  else
  {
    ListNode *pNode = *pListHead;
    while (pNode->m_pNext != NULL)pNode = pNode->m_pNext;
    pNode->m_pNext = newNode;
  }
}
ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
{
  if (pListHead == NULL || k == 0)
    return NULL;
  ListNode* pAhead = pListHead;
  ListNode* pBehind = NULL;
  for (unsigned int i = 0; i < k - 1; i++)
  {
    if (pAhead->m_pNext != NULL)
      pAhead = pAhead->m_pNext;
    else return NULL;
  }
  pBehind = pListHead;
  while (pAhead->m_pNext != NULL)
  {
    pAhead = pAhead->m_pNext;
    pBehind = pBehind->m_pNext;
  }
  return pBehind;
}

int main(int argc, char* argv[])
{

  int nums = 0;
  while (cin >> nums)
  {
    ListNode* list = NULL;
    int temp = 0;
    for (int i = 0; i < nums; i++)
    {
      cin >> temp;
      InsertNode(&list, temp);
    }
    int k = 1;
    cin >> k;
    ListNode* findNode = FindKthToTail(list, k);
    if (findNode)
      cout << FindKthToTail(list, k)->m_nValue << endl;
    else cout << 0 << endl;
  }
  return 0;
}