【单链表】23 单链表ADT模板简单应用算法设计:有序单链表的提纯

问题描述 :

目的:使用C++模板设计单链表的抽象数据类型(ADT)。并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。

内容:

(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的设计中,推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。)

 

(2)ADT的简单应用:使用该ADT设计并实现单链表应用场合的一些简单算法设计。

 

应用5:试设计一个算法,删除有序单链表A中的冗余元素,即使得操作之后的单链表中只保留操作之前表中所有值都不相同的元素,并保持其有序性。要求利用原表中的结点,并释放A表中冗余的结点空间。

参考函数原型:

template<class ElemType>

void Purge_Lk_OL( LinkList<ElemType> &A ); //测试数据限定为整数。实际应用时,不受其限制

 

输入说明 :

第一行:顺序表A的数据元素的数据类型标记(0:int,1:double,2:char,3:string)

第二行:单链表A的数据元素(数据元素之间以空格分隔)

输出说明 :

如第一行输入值为0、1、2、3之外的值,直接输出“err”

否则:

 

第一行:单链表A的遍历结果

空行

第三行:提纯后单链表A的遍历结果

输入范例 :

0
3 3 5 5 8 11 11

输出范例 :

3->3->5->5->8->11->11

3->5->8->11

解题代码: 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <sstream>
#include <stack>
#include <map>
#include <ctime>
#include <array>
#include <set>
using namespace std;
//单链表ADT
/* 单链表的结点定义 */
template<class ElemType>
struct LinkNode
{
	ElemType data;//元素
	LinkNode<ElemType>* next;//next指针
	LinkNode(LinkNode<ElemType>* ptr = NULL)
	{
		//创建节点的时候可以传入next指针
		next = ptr;
	}
	LinkNode(const ElemType& item, LinkNode<ElemType>* ptr = NULL)
	{
		//创建节点的时候可以传入一个元素或者:元素+next指针。
		next = ptr;
		data = item;
	}
};
//带头结点的单链表
template<class ElemType>
class LinkList
{
private:
	LinkNode<ElemType>* head;   // 头指针
	LinkNode<ElemType>* tail;   // 尾指针
	void empty_push(ElemType num)//空链表插入第一个节点
	{
		head = new LinkNode<ElemType>;//头指针指向新建节点
		tail = head;//尾指针指向头指针
		head->data = num;//赋值
		//head->next = NULL;
		return;
	}
	bool check_P(int n)//检查下标是否合法:0-n
	{
		if (0 <= n && n < size())
			return true;
		return false;
	}
public:
	/*
	
	int size(void)获取长度
	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
	void have_look(void)   //输出
	void push_back(ElemType num) //尾部插入
	void insert_head(ElemType num) 头部插入
	bool insert_back(int place, ElemType num) 插入到指定位置之后

	*/
	LinkList()
	{
		//无参数的构造函数
		//head = new LinkNode<ElemType>;//头指针指向新建节点
		//tail = head;//尾指针指向头指针
		head = NULL;
		tail = NULL;
	}
	LinkList(const ElemType& item)
	{
		//带参数的构造函数 我觉得没几个人会用吧
		head = new LinkNode<ElemType>(item);
		tail = head;
	}
	LinkList(LinkList<ElemType>& List)
	{
		//拷贝构造函数
		;
	}
	~LinkList()
	{
		//析构函数
		
	}
	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
	{
		LinkNode<ElemType>* pla=head;
		while (i--)
		{
			pla = pla->next;
		}
		return pla;
	}
	void have_look(void)
	{
		LinkNode<ElemType>* p = head;
		while (p->next!= NULL)
		{
			cout << p->data;
			cout << "->";
			p = p->next;
		}
		cout << p->data << endl;
		return;
	}
	int size(void)//finish 返回数组的长度
	{
		int len = 0;
		if (head == NULL && tail == NULL)
			return 0;
		LinkNode<ElemType>* p;
		p = head;
		while (p != NULL)
		{
			len++;
			p = p->next;
		}
		return len;
	}
	void push_back(ElemType num)
	{
		if (size()==0)//空链表特判
		{
			empty_push(num);
			return;
		}
		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
		p->data = num;//赋值
		tail->next = p;//尾指针指向节点next赋值为p
		tail = p;//尾指针指向p
		return;
	}
	void insert_head(ElemType num)
	{
		if (size() == 0)//空链表特判
		{
			empty_push(num);
			return;
		}
		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
		p->data = num;//赋值
		p->next = head;//链接
		head = p;
		return;
	}
	bool insert_back(int place, ElemType num)
	{
		if (size() == 0 && place==0)//空链表特判
		{
			empty_push(num);
			return true;
		}
		if (check_P(place) == false)//位置合法性判断
			return false;
		if (place == size() - 1)//尾部插入特判
		{
			push_back(num);
			return true;
		}
		LinkNode<ElemType>* p=get_address(place);
		LinkNode<ElemType>* p2 = new LinkNode<ElemType>;//新建
		p2->data = num;//赋值
		p2->next = p->next;//定位
		p->next = p2;//链接
		return true;
	}
	LinkNode<ElemType>* get_front(LinkNode<ElemType>* p)//获取一个指针的上一个,头指针和非法指针会报错.
	{
		LinkNode<ElemType>* p1;
		p1 = head;
		while (p1->next != NULL)
		{
			if (p1->next == p)
				return p1;
			p1=p1->next;
		}
	}
	bool del(int i)//删除指定位置元素  。注意,没有写非法请求检查(0->n-1)
	{
		return del_p(get_address(i));
	}
	bool del_p(LinkNode<ElemType>* p)
	{
		if (size() == 0)
			return false;
		if (head == tail)
		{
			if (p == head)
			{
				delete head;
				head = NULL;
				tail = NULL;
				return true;
			}
			else
				return false;
		}
		if (p == head)
		{
			LinkNode<ElemType>* p1 = head->next;
			delete head;
			head = p1;
			return true;
		}
		if (p == tail)
		{
			LinkNode<ElemType>* p1 = get_front(p);
			delete p;
			p1->next=NULL;
			tail = p1;
			return true;
		}
		LinkNode<ElemType>* p1 = get_front(p);
		p1->next = p->next;
		delete p;
		return true;
	}
	ElemType at(int i)
	{
		LinkNode<ElemType>* p=get_address(i);
		return p->data;
	}
	void reverse(int m, int n)//反转m->n区间
	{
		m++, n++;
		LinkNode<ElemType>* newHead = new LinkNode<ElemType>;
		newHead->next = head;
		LinkNode<ElemType>* p = newHead;
		for (int i = 0; i < m - 1; i++)
			p = p->next;
		LinkNode<ElemType>* start = p->next;
		LinkNode<ElemType>* t = start->next;
		if (n == size())
		{
			tail = start;
		}
		for (int i = m; i < n; i++)
		{
			start->next = t->next;
			t->next = p->next;
			p->next = t;
			t = start->next;
		}
		head = newHead->next;
		return;
	}
	LinkList<ElemType>* get_head(void)
	{
		return head;
	}
	LinkList<ElemType>* get_tail(void)
	{
		return head;
	}
	void pick(LinkList<ElemType> &lis)
	{
		tail->next=lis.head;
		tail = lis.tail;
		return;
	}
};
//LinkList<int> a;
//===============================================================
vector<int> departString_int(string data)
{
	vector<int> back_part;//output type
	int i, j;
	vector<string> part;
	string A_part;
	stringstream room;
	room.str(data);
	while (room >> A_part)
		part.push_back(A_part);
	for (i = 0; i < part.size(); i++)
	{
		int num_cahe;
		num_cahe = atoi(part[i].c_str());
		back_part.push_back(num_cahe);
	}
	return back_part;
}
vector<double> departString_double(string data)
{
	vector<double> back_part;//output type
	int i, j;
	vector<string> part;
	string A_part;
	stringstream room;
	room.str(data);
	while (room >> A_part)
		part.push_back(A_part);
	for (i = 0; i < part.size(); i++)
	{
		double num_cahe;
		num_cahe = atof(part[i].c_str());
		back_part.push_back(num_cahe);
	}
	return back_part;
}
vector<char> departString_char(string data)
{
	vector<char> back_part;//output type
	int i, j;
	vector<string> part;
	string A_part;
	stringstream room;
	room.str(data);
	while (room >> A_part)
		part.push_back(A_part);
	for (i = 0; i < part.size(); i++)
	{
		char num_cahe;
		num_cahe = part[i].at(0);
		back_part.push_back(num_cahe);
	}
	return back_part;
}
vector<string> departString_string(string data)
{
	vector<int> back_part;//output type
	int i, j;
	vector<string> part;
	string A_part;
	stringstream room;
	room.str(data);
	while (room >> A_part)
		part.push_back(A_part);
	return part;
}
//===================================================

template<class ElemType>
void Purge_Lk_OL(LinkList<ElemType>& A)
{
	int i=0, j=0;
	for (i = 0; i < A.size()-1;)
	{
		if (A.at(i) == A.at(i + 1))
			A.del(i);
		else
			i++;
	}
	A.have_look();
}

//===================================================
int main()
{
	int i, j;
	int kinds;
	string s1, s2;
	int m;
	//数值类型输入判断
	cin >> kinds;
	if (kinds != 0 && kinds != 1 && kinds != 2 && kinds != 3)
	{
		cout << "err" << endl;
		return 0;
	}
	cin.get();
	vector<int> I_1, I_2;
	vector<double> D_1, D_2;
	vector<char> C_1, C_2;
	vector<string> S_1, S_2;
	
	LinkList<int> LI_1, LI_2;
	LinkList<double> LD_1, LD_2;
	LinkList<char> LC_1, LC_2;
	LinkList<string> LS_1, LS_2;
	//---------------
	getline(cin, s1);
	if (kinds == 0)
		I_1 = departString_int(s1);
	if (kinds == 1)
		D_1 = departString_double(s1);
	if (kinds == 2)
		C_1 = departString_char(s1);
	if (kinds == 3)
		S_1 = departString_string(s1);
	//--------------
	/*getline(cin, s2);
	if (kinds == 0)
		I_2 = departString_int(s2);
	if (kinds == 1)
		D_2 = departString_double(s2);
	if (kinds == 2)
		C_2 = departString_char(s2);
	if (kinds == 3)
		S_2 = departString_string(s2);*/
	//--------------
	if (kinds == 0)
	{
		for (i = 0; i < I_1.size(); i++)
			LI_1.push_back(I_1[i]);
	}
	if (kinds == 1)
	{
		for (i = 0; i < D_1.size(); i++)
			LD_1.push_back(D_1[i]);
	}
	if (kinds == 2)
	{
		for (i = 0; i < C_1.size(); i++)
			LC_1.push_back(C_1[i]);
	}
	if (kinds == 3)
	{
		for (i = 0; i < S_1.size(); i++)
			LS_1.push_back(S_1[i]);
	}
	//--------------
	/*if (kinds == 0)
	{
		for (i = 0; i < I_2.size(); i++)
			LI_2.push_back(I_2[i]);
	}
	if (kinds == 1)
	{
		for (i = 0; i < D_2.size(); i++)
			LD_2.push_back(D_2[i]);
	}
	if (kinds == 2)
	{
		for (i = 0; i < C_2.size(); i++)
			LC_2.push_back(C_2[i]);
	}
	if (kinds == 3)
	{
		for (i = 0; i < S_2.size(); i++)
			LS_2.push_back(S_2[i]);
	}*/
	//--------------
	if (kinds == 0)
		LI_1.have_look();
	if (kinds == 1)
		LD_1.have_look();
	if (kinds == 2)
		LC_1.have_look();
	if (kinds == 3)
		LS_1.have_look();
	//--------------
	//if (kinds == 0)
	//	LI_2.have_look();
	//if (kinds == 1)
	//	LD_2.have_look();
	//if (kinds == 2)
	//	LC_2.have_look();
	//if (kinds == 3)
	//	LS_2.have_look();
	//--------------
	cout << endl;
	//+++++++++++++++++++++++++
	/*if (kinds == 0)
		Merge_L_Order(LI_1, LI_2);
	if (kinds == 1)
		Merge_L_Order(LD_1, LD_2);
	if (kinds == 2)
		Merge_L_Order(LC_1, LC_2);
	if (kinds == 3)
		Merge_L_Order(LS_1, LS_2);*/
	if (kinds == 0)
		Purge_Lk_OL(LI_1);
	if (kinds == 1)
		Purge_Lk_OL(LD_1);
	if (kinds == 2)
		Purge_Lk_OL(LC_1);
	if (kinds == 3)
		Purge_Lk_OL(LS_1);
	return 0;
}
//===============================================================

 

相关推荐
<p> <strong><span style="background-color:#FFFFFF;color:#E53333;font-size:24px;">本页面购买不发书!!!仅为视频课购买!!!</span></strong> </p> <p> <strong><span style="color:#E53333;font-size:18px;">请务必到</span></strong><a href="https://edu.csdn.net/bundled/detail/49?utm_source=banner"><strong><span style="color:#E53333;font-size:18px;">https://edu.csdn.net/bundled/detail/49</span></strong></a><strong><span style="color:#E53333;font-size:18px;">下单购买课+书。</span></strong> </p> <p> <span style="font-size:14px;">本页面,仅为观看视频页面,如需一并购买图书,请</span><span style="font-size:14px;">务必到</span><a href="https://edu.csdn.net/bundled/detail/49?utm_source=banner"><span style="font-size:14px;">https://edu.csdn.net/bundled/detail/49</span></a><span style="font-size:14px;">下单购买课程+图书!!!</span> </p> <p> <br /> </p> <p> <span style="font-size:14px;">疯狂Python精讲课程覆盖《疯狂Python讲义》全书的主体内容。</span> </p> <span style="font-size:14px;">内容包括Python基本数据类型、Python列、元组和字典、流程控制、函数式编程、面向对象编程、文件读写、异常控制、数据库编程、并发编程与网络编程、数据可视化分析、Python爬虫等。</span><br /> <span style="font-size:14px;"> 全套课程从Python基础开始介绍,逐步步入当前就业热点。将会带着大家从Python基础语法开始学习,为每个知识点都提供对应的代码实操、代码练习,逐步过渡到文件IO、数据库编程、并发编程、网络编程、数据分 析和网络爬虫等内容,本课程会从小案例起,至爬虫、数据分析案例终、以Python知识体系作为内在逻辑,以Python案例作为学习方式,最终达到“知行合一”。</span><br />
©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页