《剑指Offer》面试题15：链表中倒数第k个结点

《剑指Offer》面试题15：链表中倒数第k个结点

1 代码的鲁棒性

    鲁棒（Robust）/健壮性是指程序能够判断输入是否合乎规范要求，并对不合要求的输入予以合理的处理。

    容错性是鲁棒性的一个重要体现，不鲁棒的软件在发生异常事件时，会出现不可预见的诡异行为，或者整个软件崩溃。

    提高代码鲁棒性的有效途径是进行防御式编程，即预见在什么地方可能会出现什么问题，并问这些可能出现的问题制定处理方式。在面试时，最简单也最实用的防御性编程是在函数入口添加代码以验证用户输入是否符合要求。

2 面试题15：链表中倒数第k个结点

题目描述

    输入一个链表。输出该链表中倒数第k个结点。为了符合大多数人的习惯，本题从1開始计数。即链表的尾结点是倒数第1个结点。比如一个链表有6个结点。从头结点開始它们的值依次是1。2。3，4，5，6.这个链表的倒数第3个结点是值为4的结点。

     链表结点定义：

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

解题思路

    为了实现只遍历链表一次就能找到倒数第k个结点，我们可以定义两个指针。第一个指针从链表的头指针开始遍历向前走k-1。第二个指针保持不动；从第k步开始，第二个指针也开化寺从链表的头指针开始遍历。由于两个指针的距离保持在k-1，当第一个（走在前面的）指针到达链表的尾指结点时，第二个指针正好是倒数第k个结点。

    考虑鲁棒性，有3种情况会导致代码崩溃：

    1）输入的链表为空；

    2）输入的链表的结点总数小于k。由于在for循环中会在链表上向前走k-1步，会由于空指针造成程序崩溃；

   3）输入的参数k=0。由于k是一个无符号整数，那么在for循环中k-1得到的将不是-1，而是无符号的0xFFFFFFFF。因此for循环执行的次数远远超出我们的估计，同样也会造成程序崩溃。

测试用例

代码

// 《剑指Offer——名企面试官精讲典型编程题》代码
// 著作权所有者：何海涛

#include "stdio.h"
#include "cstdlib"

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

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

	return pNode;
}

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

	pCurrent->m_pNext = pNext;
}

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

void PrintList(ListNode* pHead)
{
	printf("PrintList starts.\n");

	ListNode* pNode = pHead;
	while (pNode != NULL)
	{
		printf("%d\t", pNode->m_nValue);
		pNode = pNode->m_pNext;
	}

	printf("\nPrintList ends.\n");
}

void DestroyList(ListNode* pHead)
{
	ListNode* pNode = pHead;
	while (pNode != NULL)
	{
		pHead = pHead->m_pNext;
		delete pNode;
		pNode = pHead;
	}
}

//==================代码============================================
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;
}

// ====================测试代码====================
// 测试要找的结点在链表中间
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: NULL.\n");
	ListNode* pNode = FindKthToTail(NULL, 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: NULL.\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: NULL.\n");
	ListNode* pNode = FindKthToTail(pNode1, 0);
	PrintListNode(pNode);

	DestroyList(pNode1);
}

int main()
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();
	Test6();
	system("pause");
	return 0;
}

3 相关题目

    当我们用一个指针遍历链表不能解决问题的时候，可以尝试用两个指针来遍历链表。可以让其中一个指针遍历的速度快一些（比如一次在链表上走两步），或者让它先在链表上走若干步。

相关题目1：

#include <stdio.h>    
#include <stdlib.h>  

//定义链表结点类型     
typedef struct ListNode {
	int m_nValue;                         //单链表中的数据域     
	ListNode *m_pNext;                    //单链表的指针域     
};

ListNode* FindMidNode(ListNode* pHead)
{
	if (pHead == NULL)                    //0个结点
	{
		return NULL;
	}
	if (pHead->m_pNext == NULL || pHead->m_pNext->m_pNext == NULL)  //1个或2个结点
	{
		return pHead;
	}
	ListNode *pFirstNode = pHead;
	ListNode *pSecondNode = pHead;

	while (pFirstNode->m_pNext != NULL && pFirstNode->m_pNext->m_pNext != NULL)  //如果链表结点数为偶数，输出中间两个结点前面的一个。    
	{
		pFirstNode = pFirstNode->m_pNext->m_pNext;
		pSecondNode = pSecondNode->m_pNext;
	}
	return pSecondNode;
}

相关题目2：

#include <stdio.h>    
#include <stdlib.h>  

//定义链表结点类型     
typedef struct ListNode {
	int m_nValue;                         //单链表中的数据域     
	ListNode *m_pNext;                    //单链表的指针域     
};

bool isloop(ListNode* head)
{
	ListNode* slow = head;
	ListNode* fast = head;
	while (fast->m_pNext != NULL)
	{
		slow = slow->m_pNext;
		fast = fast->m_pNext->m_pNext;
		if (slow == fast)       //相遇，有环  
		{
			return true;
		}
	}
	if (fast->m_pNext = NULL)     //没有相遇，因而无环  
		return false;
}