链表的倒数第k个节点

题目：

求链表的倒数第k个节点

题目要求：

1 输入一个单向链表，输出该链表中倒数第k个结点,

2 链表的倒数第0个结点为链表的尾指针(即与倒数第1个节点)

3 链表为空或者链表结点数小于k，返回空

题目解析：

设置两个指针pre,node; 将pre,node都指向链表第一个节点，然后node向前走pre步，这样pre和node之间就相隔k个节点，然后pre,node同时移动直到node指向链表末尾。此时pre位链表的倒数第k个节点

注意事项：

1 链表是否为空

2 链表节点数小于k

算法实现代码：

//-------------链表、链表结点、链表简单操作定义---------------------
struct Node
{
	char c;
	Node *next;
};

//链表有头结点,list->head->next指向第一个节点
struct List
{
	Node * head;
};

//返回list的第k个节点
Node* ListBack_K_Node(List *list, unsigned k)
{
	//如果链表为空，则返回结果为空
	if (nullptr == list || nullptr == list->head)
	{
		return nullptr;
	}

	//如果k=0；返回k = 1时的结果
	if (k == 0)
	{
		k++;
	}

	//node向前走k步
	Node*node = list->head->next;
	while ((unsigned)0 != k && nullptr != node)
	{
		--k;
		node = node->next;
	}

	//链表结点数小于k，则直接返回空
	if (unsigned(0) != k)
	{
		return nullptr;
	}

	//pre,node同步走，直到node == nullptr,此时pre即为倒数第k个节点
	Node *pre = list->head->next;
	while (nullptr != node)
	{
		node = node->next;
		pre = pre->next;
	}

	return pre;
}

链表实现、算法测试代码：

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

//-------------链表、链表结点、链表简单操作定义---------------------
struct Node
{
	char c;
	Node *next;
};

//链表有头结点,list->head->next指向第一个节点
struct List
{
	Node * head;
};

Node* AllocNode()
{
	Node *node = new Node;
	if (nullptr == node)
	{
		return nullptr;
	}

	node->next = nullptr;

	return node;
}

void InitList(List *list)
{
	list->head = AllocNode();
}

//在链表头部插入一个结点
Node* AddNodeToList(List *list, char c)
{
	//如果链表为空，直接返回
	if (nullptr == list)
	{
		return nullptr;
	}

	//如果链表头结点为空，则对链表初始化
	if (nullptr == list->head)
	{
		InitList(list);
	}

	Node *node = AllocNode();
	node->c = c;

	node->next = list->head->next;
	list->head->next = node;

	return list->head->next;
}


//根据str创建链表
Node* CreateList(List *list, const string &str)
{
	if (nullptr == list)
	{
		return nullptr;
	}

	for (size_t i = 0; i < str.size(); ++i)
	{
		AddNodeToList(list, str[i]);
	}

	return list->head->next;
}

//销毁链表
void DestroyList(List *list)
{
	if (nullptr == list || nullptr == list->head)
	{
		return;
	}

	Node *node = nullptr;
	while (nullptr != list->head->next)
	{
		node = list->head->next;
		list->head->next = node->next;

		delete node;
	}

	delete list->head;
	list->head = nullptr;
}

void PrintList(const List* list)
{
	if (nullptr == list || nullptr == list->head)
	{
		return;
	}

	for (Node *node = list->head->next; nullptr != node; node = node->next)
	{
		cout << node->c;
	}
	cout << endl;
}

//---------------------------------------------------------------------------------------------
//返回list的第k个节点
Node* ListBack_K_Node(List *list, unsigned k)
{
	//如果链表为空，则返回结果为空
	if (nullptr == list || nullptr == list->head)
	{
		return nullptr;
	}

	//如果k=0；返回k = 1时的结果
	if (k == 0)
	{
		k++;
	}

	//node向前走k步
	Node*node = list->head->next;
	while ((unsigned)0 != k && nullptr != node)
	{
		--k;
		node = node->next;
	}

	//链表结点数小于k，则直接返回空
	if (unsigned(0) != k)
	{
		return nullptr;
	}

	//pre,node同步走，直到node == nullptr,此时pre即为倒数第k个节点
	Node *pre = list->head->next;
	while (nullptr != node)
	{
		node = node->next;
		pre = pre->next;
	}

	return pre;
}

void TestListBack_K_Node(List *list, int k)
{
	Node *node = ListBack_K_Node(list, k);

	cout << "Search List's Back " << k << " node ";
	if (nullptr != node)
	{
		cout << "success ,node.c = " << node->c << endl;
	}
	else
	{
		cout << "failure" << endl;
	}
}

int main()
{
	string str("123456789");
	List list;
	InitList(&list);
	CreateList(&list, str);

	PrintList(&list);

	TestListBack_K_Node(&list, 0);
	TestListBack_K_Node(&list, 1);
	TestListBack_K_Node(&list, 5);
	TestListBack_K_Node(&list, 9);
	TestListBack_K_Node(&list, 10);
	TestListBack_K_Node(nullptr, 0);

	DestroyList(&list);
	return 0;
}

运行结果：