单链表中的常见算法问题(剑指offer5/13/15/16/17)

1.单链表的结点

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

2.创建链表

ListNode* createList(int length) {
	//创建表头结点
	ListNode* head = new ListNode();
	head->m_pNext = NULL;
	ListNode* p = head;

	int value = 0; //临时存储用户键入的第i个结点值
	for (int i = 0; i < length; ++i) {
		cout << "ListNode" << i << ":\t";
		cin >> value;

		//将新创建的结点插入链表中
		ListNode* q = new ListNode();
		q->m_nKey = value;
		q->m_pNext = NULL;
		p->m_pNext = q;
		p = q;
	}

	return head;
}

3.删除链表

void deleteList(ListNode* head) {
	if (NULL == head) {
		return;
	}

	ListNode* p = head;
	ListNode* q = p;
	while (p->m_pNext) {
		q = p;
		p = p->m_pNext;

		delete q;
		q = NULL;
	}

	delete head;
	head = NULL;
}

4.遍历输出链表(从表头到表尾)

void showList(ListNode* head) {
	//如果是空链表直接退出
	if (NULL == head)
		return;

	ListNode* p = head->m_pNext;
	while (p != NULL) {
		cout << p->m_nKey << "\t";
		p = p->m_pNext;
	}

	cout << endl;
}

5.链表的长度

int listLength(ListNode* head) {
	if (NULL == head) {
		return 0;
	}

	int length = 0;
	ListNode*p = head->m_pNext;
	while (NULL != p) {
		p = p->m_pNext;
		++length;
	}
	return length;
}

6.链表逆置

ListNode* listReverse(ListNode* sourceHead) {
	if (NULL == sourceHead)
		return NULL;

	ListNode* newHead = new ListNode();
	newHead->m_pNext = NULL;

	ListNode* p = NULL; //中间结点

	while (sourceHead->m_pNext != NULL) {
		//将原来链表的第一个结点从链表中删除
		p = sourceHead->m_pNext;
		sourceHead->m_pNext = p->m_pNext;

		//将删除掉的结点以头插法插入到新的链表中
		p->m_pNext = newHead->m_pNext;
		newHead->m_pNext = p;
	}

	return newHead;
}

7.O(1)时间删除一个指定结点

void deleteListNode(ListNode* pHeadListNode, ListNode* pToBeDeleted) {
	if (NULL == pHeadListNode || NULL == pToBeDeleted) {
		return;
	}

	//方法二：在保证链表中包含待删除结点的前提下,将待删除结点的下一个结点值
	//替换掉要删除结点的值,然后删除待删除结点的下一个结点

	//如果待删除结点是链表中的唯一结点
	ListNode* pHeadNext = pHeadListNode->m_pNext;
	if (pHeadNext == pToBeDeleted && pHeadNext ==
	NULL) {
		delete pToBeDeleted;
		pToBeDeleted = NULL;
		pHeadNext = NULL;
	}
	//如果要删除的结点不是最后一个结点,且待删除的链表的长度大于1
	else if (pToBeDeleted->m_pNext != NULL) {
		ListNode* pDeletedNext = pToBeDeleted->m_pNext;
		pToBeDeleted->m_nKey = pDeletedNext->m_nKey;
		pToBeDeleted = pDeletedNext->m_pNext;

		delete pDeletedNext;
	}
	//如果待删除结点是链表的末尾结点(也是最常见的操作方法)
	else {
		//方法一:找到要删除结点,用其前一个结点指向其下一个结点,从而达到删除的目的
		ListNode* p = pHeadListNode;
		ListNode* q = pHeadListNode->m_pNext;
		while (q != pToBeDeleted && q != NULL) {
			p = q;
			q = q->m_pNext;
		}
		if (q != NULL) {
			p->m_pNext = q->m_pNext;
		}
	}
}

8.输出单链表中的倒数第K个结点的值

int findLastKNodeValue(ListNode* head, const unsigned int k) {
	if (NULL == head || k <= 0) {
		return -1;
	}

	//计数器
	unsigned int count = 0;
	ListNode* p = head;
	ListNode* q = head;

	//如果链表长度多于k,则q先遍历k个值
	while (count < k && q != NULL) {
		q = q->m_pNext;
		++count;
	}

	//如果少于k直接退出
	if (NULL == q) {
		return -1;
	}

	//如果链表的结点多于k个,两个指针一起遍历到先遍历指针为NULL时
	while (NULL != q) {
		q = q->m_pNext;
		p = p->m_pNext;
	}

	//当链表长度多于k时,输出倒数第k个结点的值
	return p->m_nKey;
}

9.合并两个排序的链表

ListNode* mergeSortedLinkedList(ListNode* head1, ListNode* head2) {
	//有个链表为空时返回另外一个链表即可--代码的鲁棒性
	if (NULL == head1) {
		return head2;
	}

	if (NULL == head2) {
		return head1;
	}

	//合并后的新头 结点
	ListNode* head = new ListNode();
	head->m_pNext = NULL;

	ListNode* s = head;
	while (NULL != head1->m_pNext && NULL != head2->m_pNext) {
		ListNode* p = head1->m_pNext;
		ListNode* q = head2->m_pNext;

		if (p->m_nKey < q->m_nKey) {
			head1->m_pNext = p->m_pNext;

			p->m_pNext = s->m_pNext;
			s->m_pNext = p;
			s = p;
		} else {
			head2->m_pNext = q->m_pNext;

			q->m_pNext = s->m_pNext;
			s->m_pNext = q;
			s = q;
		}

	}

	while (NULL != head1->m_pNext) {
		ListNode* p = head1->m_pNext;
		head1->m_pNext = p->m_pNext;

		p->m_pNext = s->m_pNext;
		s->m_pNext = p;
		s = p;
	}

	while (NULL != head2->m_pNext) {
		ListNode* q = head2->m_pNext;
		head2->m_pNext = q->m_pNext;

		q->m_pNext = s->m_pNext;
		s->m_pNext = q;
		s = q;
	}

	return head;
}

测试代码

/*
 *
 *  Created on: 2014-3-20 16:16:52
 *      Author: danDingCongRong
 */

#include<iostream>
using namespace std;

int main() {
	int listLen = 0;
	cout << "输入链表的长度：\t";
	cin >> listLen;

	ListNode* head = createList(listLen);
	cout << "原始链表：" << endl;
	showList(head);

	cout << "链表的长度为：" << listLength(head) << endl;

	ListNode* newHead = listReverse(head);
	cout << "逆置后的链表：" << endl;
	cout << "" << endl;
	showList(newHead);

	cout << "倒数第5个数是：" << endl;
	cout << findLastKNodeValue(newHead, 5) << endl;

	ListNode* head1 = createList(listLen);
	cout << "原始链表：" << endl;
	showList(head1);

	ListNode* head2 = createList(listLen);
	cout << "原始链表：" << endl;
	showList(head2);

	cout << "合并两个有序的链表：" << endl;
	ListNode* head3 = mergeSortedLinkedList(head1, head2);
	showList(head3);

	cout << "链表的长度为：" << listLength(head3) << endl;

	return 0;
}

注：部分代码参考自剑指offer