栈、队列与背包

最新推荐文章于 2021-06-07 20:02:40 发布
最新推荐文章于 2021-06-07 20:02:40 发布
阅读量362 收藏
点赞数
分类专栏： 基础数据结构与算法 基础数据结构与算法 文章标签： 栈 链表 api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21916897/article/details/70988535
版权

栈

栈：一种基于后进先出策略的集合类型；

在链表的表示方法下，栈在同一端进出元素，所以只需要一个指针域即可。

栈API：
class stack{
stack()创建一个空栈
void  Empty()判断栈是否为空
void size()栈长
void push(string item)
进栈
string pop()
出栈
void trave()
遍历栈
void clear()
清空栈
bool find(string item)查找元素是否存在
}; 
代码： 

class stack
{
	struct Node
	{
		string data;
		Node* next;
	};
private:
	Node* first = NULL;
	int N = 0;
public:
	bool Empty(){ return N == 0; }
	int size(){ return N; }
	void push(string item)
	{
		Node* oldfirst = first;
		first = new Node();
		first->data = item;
		first->next = oldfirst;
		N++;
	}
	string pop()
	{
		if (Empty())exit(0);
		Node* curr = first;
		string item = first->data;
		first = first->next;
		delete curr;
		N--;
		return item;
	}
	void trave()
	{
		Node* curr = first;
		for (int i = 0; i < N; ++i)
		{
			cout << curr->data << " ";
			curr = curr->next;
		}
		cout << endl;
	}
	void clear()
	{
		for (int i = 0; i < N; ++i)
		{
			Node* curr = first;
			first = first->next;
			delete curr;
		}
		N = 0;
	}
	bool find(string item)
	{
		Node* curr = first;
		for (int i = 0; i < N; ++i)
			if (curr->data == item)return true;
			else curr = curr->next;
			return false;
	}
};

队列

是一种基于先进先出策略的集合类型；

在链表的表示方式下，队列的一端进一端出，所以需要两个指针域。

尾插法进队，first结点出队，否则遍历不好启动。


队列API：
class queue{
queue()建立一个空队列
bool Empty()队列是否为空
int size()队列长度
void enqueue(string item)进队
string dequeue()出队
void trave()遍历
void clear()清空队列
bool find()查找队列
}; 
代码： 

class queue
{
	struct Node
	{
		string data;
		Node* next;
	};
private:
	Node* first=NULL;
	Node* last = NULL;
	int N = 0;
public:
	bool Empty(){ return N == 0; }
	int size(){ return N; }
	void enqueue(string item)
	{
		Node* oldlast = last;
		last = new Node();
		last->data = item;
		if (Empty())first = last;
		else oldlast->next = last;
		N++;
	}
	string dequeue()
	{
		if (Empty())exit(0);
		Node* curr = first;
		string item = first->data;
		first = first->next;
		delete curr;
		N--;
		return item;
	}
	void trave()
	{
		Node* curr = first;
		for (int i = 0; i < N; ++i)
		{
			cout << curr->data << " ";
			curr = curr->next;
		}
		cout << endl;
	}
	void clear()
	{
		for (int i = 0; i < N; ++i)
		{
			Node* curr = first;
			first = first->next;
			delete curr;
		}
		N = 0;
	}
	bool find(string item)
	{
		Node* curr = first;
		for (int i = 0; i < N; ++i)
			if (curr->data == item)return true;
			else curr = curr->next;
			return false;
	}
};
栈和队列本质上都是一种被限制的线性表，只是在限制条件上有所不同而已。


特殊的队列：

双向队列：

class Deque//双向队列
{
	struct Node
	{
		string data;
		Node* right;
		Node* left;
	};
private:
	Node* first = NULL;
	Node* last = NULL;
	int N = 0;
public:
	bool Empty(){ return N == 0; }
	int size(){ return N; }
	void pushleft(string item)//左进队
	{
		Node* oldfirst = first;
		first = new Node();
		first->data = item;
		if (Empty())last = first;
		else
		{
			first->right = oldfirst;
			oldfirst->left = first;
		}
		N++;
	}
	void pushright(string item)//右进队
	{
		Node* oldlast = last;
		last = new Node();
		last->data = item;
		if (Empty())first = last;
		else
		{
			last->left = oldlast;
			oldlast->right = last;
		}
		N++;
	}
	string popleft()//左出队
	{
		if (Empty())exit(0);
		Node* curr = first;
		string item = curr->data;
		first = first->right;
		delete curr;
		N--;
		return item;
	}
	string popright()//右出队
	{
		if (Empty())exit(0);
		Node* curr = last;
		string item = curr->data;
		last = last->left;
		delete curr;
		N--;
		return item;
	}
	void traveleft()//左遍历
	{
		Node* curr = first;
		for (int i = 0; i < N; ++i)
		{
			cout << curr->data << " ";
			curr = curr->right;
		}
		cout << endl;
	}
	void traveright()//右遍历
	{
		Node* curr = last;
		for (int i = 0; i < N; ++i)
		{
			cout << curr->data << " ";
			curr = curr->left;
		}
		cout << endl;
	}
	void clear()//清空
	{
		for (int i = 0; i < N; ++i)
		{
			Node* curr = first;
			first = first->right;
			delete curr;
		}
		N = 0;
	}
};


循环队列： 

class xeque//循环队列
{
	struct Node
	{
		string data;
		Node* next;
	};
private:
	Node* first = NULL;
	Node* last = NULL;
	int N = 0;
public:
	bool Empty(){ return N == 0; }
	int size(){ return N; }
	void push(string item)
	{
		Node* oldlast = last;
		last = new Node();
		last->data = item;
		if (Empty())first = last;
		else
		{
			oldlast->next = last;
			last->next = first;
		}
		N++;
	}
	string pop()
	{
		if (Empty())exit(0);
		Node* curr = first;
		string item = curr->data;
		first = first->next;
		delete curr;
		if (--N)last->next = first;
		return item;
	}
	void trave()
	{
		Node* curr = first;
		for (int i = 0; i != N; ++i)
		{
			cout << curr->data << " ";
			curr = curr->next; 
		}
		cout << endl;
	}
	void clear()
	{
		for (int i = 0; i != N; ++i)
		{
			Node* curr = first;
			first = first->next;
			delete curr;
		}
		N = 0;
	}
};

双向循环队列： 

class xwque//双向循环队列
{
	struct Node
	{
		string data;
		Node* right;
		Node* left;
	};
private:
	Node* first=NULL;
	Node* last=NULL;
	int N = 0;
public:
	bool Empty(){ return N == 0; }
	int size(){ return N; }
	void pushleft(string item)
	{
		Node* oldfirst = first;
		first = new Node();
		first->data = item;
		if (Empty())last = first;
		else
		{
			oldfirst->left = first;
			first->right = oldfirst;
			last->right = first;
			first->left=last;
		}
		N++;
	}
	void pushright(string item)
	{
		Node* oldlast = last;
		last = new Node();
		last->data = item;
		if (Empty())first = last;
		else
		{
			oldlast->right = last;
			last->left = oldlast;
			first->left = last;
			last->right = first;
		}
		N++;
	}
	string popleft()
	{
		if (Empty())exit(0);
		Node* curr = first;
		string item = curr->data;
		first = first->right;
		if (--N)
		{
			last->right = first;
			first->left = last;
		}
		delete curr;
		return item;
	}
	string popright()
	{
		if (Empty())exit(0);
		Node* curr = last;
		string item = last->data;
		last = last->left;
		if (--N)
		{
			last->right = first;
			first->left = last;
		}
		delete curr;
		return item;
	}
	void traveleft()
	{
		Node* curr = first;
		for (int i = 0; i != N; ++i)
		{
			cout << curr->data << " ";
			curr = curr->right;
		}
		cout << endl;
	}
	void traveright()
	{
		Node* curr = last;
		for (int i = 0; i != N; ++i)
		{
			cout << curr->data << " ";
			curr = curr->left;
		}
		cout << endl;
	}
	void clear()
	{
		for (int i = 0; i != N; ++i)
		{
			Node* curr = first;
			first = first->right;
			delete curr;
		}
		N = 0;
	}
};

双栈队列： 

class stque//双栈队列，栈为本章中的栈
{
private:
	int N=0;
	stack k1;
	stack k2;
public:
	bool Empty(){ return N == 0; }
	int size(){ return N; }
	void enqueue(string item)
	{
		k1.push(item);
		N++;
	}
	string dequeue()
	{
		for (int i = 0; i <N-1; ++i)
			k2.push(k1.pop());
		string item = k1.pop();
		N--;
		for (int i = 0; i < N; ++i)
			k1.push(k2.pop());
		return item;
	}
	void trave()
	{
		for (int i = 0; i != N; ++i)
			k2.push(k1.pop());
		k2.trave();
		for (int i = 0; i != N; ++i)
			k1.push(k2.pop());
	}
	void clear()
	{
		k1.clear();
		N = 0;
	}
	bool find(string item)
	{
		return k1.find(item);
	}
};

int main()//双栈队列，测试用例
{
	stque p;
	string item;
	int m;
	cout << "**********************************" << endl;
	cout << "0.查看菜单.   1.进队." << endl;
	cout << "2.出队.       3.遍历队." << endl;
	cout << "4.队是否为空.  5.队列长." << endl;
	cout << "6.清空队列.    7.查找." << endl;
	cout << "**********************************" << endl;
	while (cin >> m)
	{
		switch (m)
		{
		case 0:
			cout << "**********************************" << endl;
			cout << "0.查看菜单.   1.进队." << endl;
			cout << "2.出队.       3.遍历队." << endl;
			cout << "4.队是否为空.  5.队列长." << endl;
			cout << "6.清空队列.    7.查找." << endl;
			cout << "**********************************" << endl;
			break;
		case 1:
			cout << "输入进队元素:" << endl;
			cin >> item;
			p.enqueue(item);
			break;
		case 2:
			cout << "出队元素为:" << p.dequeue() << endl;
			break;
		case 3:
			cout << "遍历队：" << endl;
			p.trave();
			break;
		case 4:
			if (p.Empty())cout << "队为空" << endl;
			else if (!p.Empty()) cout << "队不为空" << endl;
			break;
		case 5:
			cout << "队长为:" << p.size() << endl;
			break;
		case 6:
			cout << "清空队列." << endl;
			p.clear();
			break;
		case 7:
			cout << "输出想要查找的元素：" << endl;
			cin >> item;
			if (p.find(item))cout << "元素存在" << endl;
			else if (!p.find(item))cout << "元素不存在" << endl;
			break;
		}
	}
	system("pause");
	return 0;
}


背包

是一种只进不出的元素集合。

API:

背包API:
class Bag{
Bag{创建背包
void add(Item item)添加元素
bool Empty()背包是否为空
int size()背包元素数量
void trave()遍历背包
}; 


代码：

template<typename Item>
class Bag
{
	class Node
	{
		friend class Bag;
		Item data;
		Node* next;
		Node(Item item,Node* x):data(item), next(x){}
	};
public:
	bool Empty(){ return N == 0; }
	int size(){ return N; }

	void add(Item item)
	{
		Node* oldfirst = first;
		first = new Node(item,oldfirst);
		N++;
	}
	void trave()
	{
		for (Node* x = first; x != NULL; x = x->next)
			cout << x->data << " ";
		cout << endl;
	}
private:
	Node* first = NULL;//链首
	int N = 0;//元素数量
};

测试用例： 

int main()
{
	Bag<string> p;
	int m;
	string item;
	cout << "**********************************" << endl;
	cout << "0.查看菜单.   1.进包." << endl;
	cout << "2.遍历背包.     3.包是否为空." << endl;
	cout << "4.包长" << endl;
	cout << "**********************************" << endl;
	while (cin >> m)
	{
		switch (m)
		{
		case 0:
		{
			cout << "**********************************" << endl;
			cout << "0.查看菜单.   1.进包." << endl;
			cout << "2.遍历背包.     3.包是否为空." << endl;
			cout << "4.包长" << endl;
			cout << "**********************************" << endl;
			break;
		}

		case 1:
		{
			cout << "输入进包元素:" << endl;
			cin >> item;
			p.add(item);
			break;
		}

		case 2:cout << "遍历包：" << endl;
			p.trave();
			break;

		case 3:if (p.Empty())cout << "包为空" << endl;
			   else if (!p.Empty()) cout << "包不为空" << endl;
			   break;

		case 4:cout << "包长为:" << p.size() << endl;
			break;
		}
	}
	system("pause");
	return 0;
}


叙狼烟
关注
专栏目录
西工大数据结构——栈与队列——背包问题
a15735748145a的博客
03-18 2832
西工大数据结构——栈与队列——背包问题
1.3 背包、队列与栈
泽阳Alex的博客
05-14 246
背包、队列与栈 1.API 每个API都含有一个无参数的构造函数、一个向集合中添加单个元素的方法、一个测试集合是否为空的方法和一个返回集合大小的方法。Stack和Queue都含有一个能够删除集合中特定元素的方法。三个API如下： 2.泛型 泛型可以存储任意类型的数据，在上面的API中，<Item>记号将Item定义为一个类型参数，表示一个占位符，指某种具体数据类型。如用栈处...
背包 队列 栈
weixin_42373064的博客
12-03 204
API 每份API都含有 一个无参数的构造函数， 一个向集合中添加单个元素的防范， 一个测试集合是否为空的方法 一个返回集合大小的方法。 另Stack和Queue都含有一个能够删除集合中特定元素的方法。 两种java特性：范型，迭代。    泛型：集合类的抽象数据类型的一个关键特征是我们应该可以用他们储存任意类型的数据，java机制能够做到这一点，它被称为泛型，也叫做参数化类...
栈,队列,背包
test4csdn的博客
07-31 235
栈 队列 背包的自己实现 在学习JavaSE以及最近做的项目之后,觉得有一种莫名的感觉,就是会感觉书写的代码不真实,没有之前使用c语言的什么东西都要自己写的麻烦感,觉得写的东西都是java帮助我完成的,什么结构方法也都有现成的,虽然很方便,但总是少了些什么,所以决定看一看数据结构这些内容,来实现自己写API,今天就看一看栈队列和背包的实现 栈 首先我们来看一看栈这种数据结构,之前接触的都是基...
队列 栈的java_背包，队列，栈的java实现
weixin_33002763的博客
02-22 101
先从栈开始实现，从简单开始，栈的特点是先进后出LIFO，应该具有的操作有：入栈push 出栈pop，判断栈是否为空isEmpty和返回栈大小size，使用java中最简单的数组实现字符串栈为开始：public class FixCapacityStringStack{privateString[] str = null;private intn = 0;publicFixCapacityStrin...
背包、队列和栈
dashen的博客
11-20 1243
背包（Bag）、队列（Queue）、下压栈（Stuck）是基础数据类型集合的三种类型，他们的区别在于删除或者访问对象的顺序不同。 背包 背包是一种不支持从中删除元素的集合数据类型，它的作用就是帮助用例收集元素并迭代遍历所有收集到的元素。 具体实现： /** * 背包 * @author xiaoqi * * @param */ public class Bag { p
背包，栈，队列
qq_31799003的博客
11-12 166
背包（只进不出，类似高中数学选修的抓球问题） public class Bag&lt;Item&gt; implements Iterable&lt;Item&gt; Bag()//创建一个空背包 void add(Item item)//添加一个元素 boolean isEmpty()//背包是否为空 int size()//背包中元素数量 栈...
Java 实现栈、队列、背包
Tracycater的专栏
04-01 263
1、栈是一种后进先出策略的集合类型 /** * 通用节点 */ public class Node<T> { private T item; private Node<T> next; public Node(T item) { this.item = item; } public T getItem(...
关于队列背包栈的认识
zhanghua1068的博客
06-14 265
关于栈，堆用法的方法
数据结构与算法(1)：背包、队列和栈的实现
elegant coder
01-20 344
本文将介绍三种数据类型，分别是背包(Bag)、队列(Queue)和栈(Stack)。它们的不同之处在于删除或者访问对象的顺序不同。 其次是介绍【链式数据结构】的重要性，特别是经典数据结构【链表】，有了它们我们才能高效实现背包、队列和栈。 集合结构介绍及API 背包 背包是一种不支持从中删除元素的集合数据类型——它的目的就是帮助用例收集元素并迭代遍历所有收集到的元素（用例也可以检查背包是...
【数据结构——栈与队列】（C语言）背包问题，递归
weixin_44234214的博客
08-03 2554
问题描述 一个简化的背包问题：一个背包能装为 总重量为 T ，现有 n 个物件，其重量分别为（W 1 、 、W 2 、 、… 、W n ）。问能否从这 n 个物件中挑选若干个物件放入背包为 中，使其总重量正好为 T ？若有解则给出全部解，否则输出无解。 代码实现 #include<stdio.h> int x=0,y=0; void knapsack(int ...
简述背包、队列和栈的基本概念
最新发布
03-23
背包、队列和栈都是计算机科学中常见的数据结构。 背包是一种不支持从中删除元素的集合数据类型，它只支持添加元素。背包的特点是元素的添加顺序不重要，也不会对元素进行排序。 队列是一种先进先出（FIFO）的数据...
利用优先队列式分支限界法解决0-1背包问题
m0_46559879的博客
06-07 7311
问题描述： 给定n种物品和一个背包。物品i的重量是Wi，其价值为Vi，背包最大承载重量为C。物品是不可分割的，应如何选择装入背包的物品，使得装入背包中物品的总价值最大? 要求： 随机生成物品和背包数据，利用分支限界法求解该问题并形成解题报告。 一、问题分析： 0-1背包问题用优先队列式分支限界法实现时， ①问题有2^n种可能解（物品放入/不放入背包）； 解空间树为子集树：左子节点（当前物品放入）、右子节点（当前物品不放入） ②约束条件：背包剩余容量 lw ≥ 当前物品重量 w (判断能否生成左孩子结点) 约
数据结构迭代器的构造
叙以流火述烽烟丶
05-19 1243
数据结构迭代器的构造 一般情况下链表的遍历是通过指针的移动来寻找下一个结点，并输出数据的。 但是在数据结构的设定中，结点都是被设为private的，也就是说我们无法在链表以外对链表元素进行逐个处理的，也就是说在对图中链表元素进行分类处理是很不方便的，所以为了比面这种情况，我们将为链表构造迭代器，用来处理链表元素。 实现： 链表迭代器的实现，便是用指针模拟正常的循环，所以我们需要： 1.构
图（2）——有向图
叙以流火述烽烟丶
05-20 1182
有向图
字符串（1）——字符串排序
叙以流火述烽烟丶
05-27 1121
字符串排序 无数的重要领域都是基于字符串处理的。 字母表
图（1）——无向图
叙以流火述烽烟丶
05-17 962
无向图 术语表 图：由一组顶点个一组能够将两个顶点相连的边组成。 自环：一条连接一个顶点和其自身的边。 平行边：连接同一对顶点的两条边称为平行边。 多重图：含有平行边。 简单图：没有平行边和自环。 相邻：两个顶点通过一条边相连，并称这条边依附这两个顶点。 顶点的度数：依附于他的边的数量。 子图：一幅图的所有边的一个子集（以及所依附的所有顶点）组成的图。 路径：由边顺序连接的一系
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值