链表操作练习

最新推荐文章于 2022-10-07 13:23:24 发布

fireflylane

最新推荐文章于 2022-10-07 13:23:24 发布

阅读量2k

点赞数 1

分类专栏： Data Structure And Algorithm P 文章标签：链表 C++

本文链接：https://blog.csdn.net/fireflylane/article/details/82869089

版权

Data Structure And Algorithm P 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

综合题

本小题请务必重视，综合了各种链表操作（各种考试考题），可以做成一个比较完整的工程，请设计测试程序进行测试，务必自己编写代码。
1．针对带表头结点的单链表，试编写下列函数。
(1) 建立函数create：根据一维数组a[n]建立一个单链表，使单链表中各元素的次序与a[n]中各元素的次序相同，要求该程序的时间复杂性为O(n)。
(2) 定位函数locate：在单链表中寻找第i个结点。若找到，则函数返回第i个结点的地址；若找不到，则函数返回NULL。
(3) 求最大值函数max：通过一趟遍历在单链表中确定值最大的结点。
(4) 统计函数number：统计单链表中具有给定值x的所有元素。
(5) 倒置函数reverse: 倒置线性表中元素的顺序。
(6) 整理函数tidyup：在非递减有序的单链表中删除值相同的多余结点。
(7) 合并两个链表mergelists: 输入的链表按照其元素顺序从小到大排序，输出的链表也要求按照元素的大小顺序排列。

注：认真完成上面的题目可以快速入门链表操作。本文给出的代码示例是博主的课堂练习，只考虑了相关功能的实现，有些细节的处理不够完善，不建议读者直接复制使用，希望读者阅读过程中思考这些问题。

分析

先来分析一下这个题目涉及的链表操作技术：

create/mergelists（（末尾）插入）
locate/max/number（遍历）
reverse
tidyup（删除）

可以看出，这七个题涉及的操作无非是线性表的增删查改，附上代码：

#include <iostream>
using namespace std;

template <typename E> class Link {
public:
	E element;      
	Link *next;        

	Link(const E& elemval, Link* nextval = NULL)
	{
		element = elemval;  next = nextval;
	}
	Link(Link* nextval = NULL) { next = nextval; }
};

template <typename E>
void lprint(Link<E> *L)
{
	if (L == NULL) return;
	cout << "< ";
	for (Link<E> *p = L->next; p != NULL; p = p->next)
	{
		cout << p->element << "  ";
	}
	cout << ">" << endl;
}

template <typename E>
Link<E>* create(E *a, int n)
{
	if (n == 0) return NULL;
	Link<E> *head, *curr;
	head = curr = new Link<E>();
	for (int i = 0; i < n; i++)
	{
		curr->next = new Link<E>(a[i]);
		curr = curr->next;
	}
	return head;
}

template <typename E>
Link<E>* locate(Link<E> *head, const int index)
{
	if (index <= 0) return NULL;
	int n = 0;
	Link<E>* curr = head;
	while (curr->next != NULL)
	{
		curr = curr->next;
		if (++n == index) return curr;
	}
	return NULL;
}

template <typename E>
Link<E>* max(Link<E> *head)
{
	Link<E> *curr = head->next, *temp = head->next;
	while (curr->next != NULL)
	{
		curr = curr->next;
		if (curr->element > temp->element) temp = curr;
	}
	return temp;
}

template <typename E>
int number(Link<E> *head, const E& value)
{
	int num = 0;
	Link<E>* curr = head;
	while (curr->next != NULL)
	{
		curr = curr->next;
		if (curr->element == value) num++;
	}
	return num;
}

template <typename E>
void reverse(Link<E> *head)
{
	if (head->next != NULL)
	{
		Link<E> *pre = NULL, *curr = head->next, *post = head->next->next;
		while (post != NULL)
		{
			curr->next = pre;
			pre = curr;
			curr = post;
			post = post->next;
		}
		curr->next = pre;
		head->next = curr;
	}
}

template <typename E>
void tidyup(Link<E> *head)
{
	Link<E> *curr = head->next;
	int temp = curr->element;
	while (curr->next != NULL)
	{
		if (curr->next->element == temp)
			curr->next = curr->next->next;
		else
		{
			curr = curr->next;
			temp = curr->element;
		}
	}
}

template <typename E>
void listMerge(Link<E> *head1, Link<E>* head2, Link<E> *head3)
{
	Link<E> *curr1 = head1->next, *curr2 = head2->next, *curr3 = head3;
	while (curr1 != NULL && curr2 != NULL)
	{
		if (curr1->element < curr2->element)
		{
			curr3->next = curr1;
			curr1 = curr1->next;
		}
		else
		{
			curr3->next = curr2;
			curr2 = curr2->next;
		}
		curr3 = curr3->next;
	}
	if (curr1 != NULL)
		curr3->next = curr1;
	if (curr2 != NULL)
		curr3->next = curr2;
}

int main()
{
	int a[] = { 11,11,22,22,22,33,33,44,44,44 };
	int b[] = { 9,14,19,23,28,38,43,54,78,89 };
	int c[] = { 5,17,18,24,27,39,46,50,70,99 };

	Link<int> *p = create(a, 10);
	lprint(p);
	Link<int> *p1 = locate(p, 11);
	if (p1 != NULL)
		cout << p1->element << endl;
	Link<int> *p2 = max(p);
	if (p2 != NULL)
		cout << p2->element << endl;
	cout << "the total number of 32 is " << number(p, 32) << endl;
	reverse(p);
	lprint(p);
	tidyup(p);
	lprint(p);

	p = create(b, 10);
	p1 = create(c, 10);
	Link<int> *p5 = new Link<int>;
	listMerge(p, p1, p5);

	lprint(p5);
	system("pause");
}

注：这里不得不提一下，第6题读者只需将它当做当做remove函数练习即可，它并不能真正意义上实现tidyup，只是本示例代码为了达到这种效果，故意凑了一个数组。

下面来着重看一下（5）reverse （7）mergelists

实现链表倒置的思路很简单，只需将当前结点curr的next指针修改为指向当前结点的前一个结点即可。
由于单链表每个结点只能存储下一个结点的地址，而不知道上一个结点的地址，所以我们需要一个指针pre保存当前结点前一个指针的地址。
但是只用两个指针是无法完成整个链表的倒置的，当我们将curr->next修改为pre后，我们就丢失了原来curr->next中保存的当前结点的下一个结点的地址，这样就无法遍历后面的链表了。
所以在修改curr->next之前，我们需要使用post指针将当前结点的下一个结点的地址保存下来。当完成curr->next指针的修改后，我们就将当前位置向后移动一个结点，即将curr指针指向post。相应的依次维护pre和post指针完成链表的遍历。

博主比较懒，不想绘图，就在网上找了一个链表转置操作的图解。

//链表转置
template <typename E>
void reverse(Link<E> *head)
{
	if (head->next != NULL)
	{
		Link<E> *pre = NULL, *curr = head->next, *post = head->next->next;
		while (post != NULL)
		{
			curr->next = pre;
			pre = curr;
			curr = post;
			post = post->next;
		}
		curr->next = pre;
		head->next = curr;
	}
}

下面我们来看mergelists函数，有点算法基础的读者可以一眼看出，这个函数就是归并排序（mergesort）的合并操作。具体思路是：对于两个有序的线性表A和B，每次将A和B中最小的元素从原表中‘删除’，放入空线性表C中。因为A和B原先就是有序递增的，A和B中的第一个元素分别是A和B表中的最小值，所以找A和B中所有元素的最小值就可以转化为比较A和B表中第一个元素的大小，较小的那一个即为所有元素的最小值。重复上述过程直到A或B中有一个表为空，此时，还未空的那一个表的剩余元素均大于表C中的元素且是有序的，我们只要将这些元素全部复制到表C中即可。

template <typename E>
void listMerge(Link<E> *head1, Link<E>* head2, Link<E> *head3)
{
	Link<E> *curr1 = head1->next, *curr2 = head2->next, *curr3 = head3;
	while (curr1 != NULL && curr2 != NULL)
	{
		if (curr1->element < curr2->element)
		{
			curr3->next = curr1;
			curr1 = curr1->next;
		}
		else
		{
			curr3->next = curr2;
			curr2 = curr2->next;
		}
		curr3 = curr3->next;
	}
	if (curr1 != NULL) //由于是链表，我们只需将指针指向修改一下即完成'元素复制'
		curr3->next = curr1;
	if (curr2 != NULL)
		curr3->next = curr2;
}

同样，附上归并排序图解。

ps：如果读者对于线性表ADT以及C++模板不熟悉的可以参考博主的另一篇博文
线性表（一）从线性表ADT到链表。里面还有链表insert操作的图解。

fireflylane

关注

1
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
链表操作练习

综合题本小题请务必重视，综合了各种链表操作（各种考试考题），可以做成一个比较完整的工程，请设计测试程序进行测试，务必自己编写代码。1．针对带表头结点的单链表，试编写下列函数。(1) 建立函数create：根据一维数组a[n]建立一个单链表，使单链表中各元素的次序与a[n]中各元素的次序相同，要求该程序的时间复杂性为O(n)。(2) 定位函数locate：在单链表中寻找第i个结点。若找到，则...
复制链接

扫一扫

专栏目录