栈的学习（浅）

最新推荐文章于 2023-08-11 15:24:13 发布
最新推荐文章于 2023-08-11 15:24:13 发布
阅读量493 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57517390/article/details/118002225
版权

 

数据结构

栈

数据结构

栈

什么是栈？---栈(stack)是限定仅在表尾进行插入或者删除的线性表，分为栈顶，栈低。

                      不含元素的空表称为空栈。因为栈限定在表尾进行插入或者删除，所以栈又被称为先出后出的线性表。

PS：代码区内的cout语句仅用来帮助你更好的理解栈的工作进程，实际手写栈的时候不需要加入它

1.顺序栈

栈和线性表类似，也有两种存储表示方法顺序栈和链栈，链栈的操作是线性表操作的特例。

顺序栈即栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时设top指示栈顶元素在顺序栈中的位置，top = -1表示空栈。

由于栈在使用的过程中所需要的大小难以估计，所以通常是先为栈分配一个MAX_SIZE基本容量，我们以下述类型说明作为顺序栈(C++)的定义：

初始化栈

在类中，我们用构造函数来初始化栈，top=-1来标记为空栈，new一个地址给data数组（此处以字符数组为例），不要忘记析构函数delete[] data，要释放资源。

Stack::Stack()
{
	size = MAX_SIZE;
	top = -1;
	data = new char[MAX_SIZE];//缺省构造函数分配默认最大内存空间
}
Stack::Stack(int s)
{
	size = s;
	top = -1;
	data = new char[size];//根据指定大小s分配栈的内存空间
}
Stack::~Stack()
{
	delete[]data;//内存回收
}

栈满与栈空

size-1位字符数组的最后一个元素的下标，当top==size-1，即入栈元素已经达到最大值了，为满栈。

若top==-1，即没有元素入栈，为空栈。

bool Stack::isFull()
{
	if (top >= size-1)
	{
		return 1;//栈已满
	}
	else
		return 0;//栈未满
}

bool Stack::isEmpty()
{
	if (top == -1)
		return 1;//栈为空
	else
		return 0;//栈已有元素
}

入栈与出栈

入栈时，需要先考虑栈是否为满栈状态。若为满栈，则不能继续入栈，若不为满栈，才可以继续入栈；每次加入一个元素，top++，即top往后移动一位，并将该元素ch赋值给此时对应的字符数组中---data[top]

出栈时，需要先考虑栈是否为空栈状态。若为空栈，则不能继续出栈，若不为空栈，才可以继续出栈；每次弹出一个元素（实际上该元素还在之前的位置，只是top索引减小了，搜索不到，相当于弹出该元素），top--，即top往前移动一位，返回data[top+1]这个被“弹出”的元素（top已经减减过了，所以要加一恢复它，得到弹出的元素）

void Stack::push(char ch)
{
	if (isFull())//解决数据上溢问题
	{
		cout << "栈已满，无法入栈" << endl;
	}
	else
	{
		top++;
		data[top] = ch;
		cout << "已将元素" << ch << "压入栈中" << endl;
		cout << "此时top= " << top << endl;
	}
}

char Stack::pop()
{
	if (!isEmpty())
	{
		cout << "出栈中..." << endl;
		top--;
		cout << "此时top= " << top << endl;
		return data[top + 1];
	}
	else//解决数据下溢问题
	{
		cout << "栈已为空，无法继续出栈" << endl;
	}
	
}

弹出元素但不出栈

与上面的出栈类似，只是不用top--。

char Stack::getTop()
{
	if (top != -1)
	{
		cout << "获得栈顶元素中..." << endl;
		cout << "此时top= " << top << endl;
		cout << "栈顶元素为：";
		return data[top];
	}
	else
	{
		cout << "栈已为空，无法获得栈顶元素" << endl;
	}
	
}

完整的顺序栈

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
const int  MAX_SIZE = 100;
class Stack//以存储字符型数据为例
{
private:
	char* data;//线性表,指针变量指向栈的数组，保存首地址
	int size;//堆栈的实际大小
	int top;//栈顶
public:
	Stack();
	Stack(int s);
	~Stack();
	void push(char ch);//入栈
	char pop();//出栈并返回栈顶元素
	char getTop();//获得栈顶元素但不出栈
	bool isEmpty();//栈是否为空
	bool isFull();//栈是否满
	void setNull(int len);//设置栈为空
	void display();
};
Stack::Stack()
{
	size = MAX_SIZE;
	top = -1;
	data = new char[MAX_SIZE];//缺省构造函数分配默认最大内存空间
}
Stack::Stack(int s)
{
	size = s;
	top = -1;
	data = new char[size];//根据指定大小s分配栈的内存空间
}
Stack::~Stack()
{
	delete[]data;//内存回收
}
void Stack::push(char ch)
{
	if (isFull())//解决数据上溢问题
	{
		cout << "栈已满，无法入栈" << endl;
	}
	else
	{
		top++;
		data[top] = ch;
		cout << "已将元素" << ch << "压入栈中" << endl;
		cout << "此时top= " << top << endl;
	}
}
char Stack::pop()
{
	if (!isEmpty())
	{
		cout << "出栈中..." << endl;
		top--;
		cout << "此时top= " << top << endl;
		return data[top + 1];
	}
	else//解决数据下溢问题
	{
		cout << "栈已为空，无法继续出栈" << endl;
	}

}
char Stack::getTop()
{
	if (!isEmpty())
	{
		cout << "获得栈顶元素中..." << endl;
		cout << "此时top= " << top << endl;
		cout << "栈顶元素为：";
		return data[top];
	}
	else
	{
		cout << "栈已为空，无法获得栈顶元素" << endl;
	}

}
bool Stack::isEmpty()
{
	if (top == -1)
		return 1;//栈为空
	else
		return 0;//栈不为空
}
bool Stack::isFull()
{
	if (top >= size - 1)
	{
		return 1;//栈已满
	}
	else
		return 0;//栈未满
}
void Stack::setNull(int len)//设置栈空
{
	memset(data, 0, len * sizeof(char));
	this->top = -1;
	cout << "此时top= " << top << endl;
}
void Stack::display()
{
	cout << "元素：NULL";
	for (int i = 0; i <= top; i++)
	{
		cout <<"->"<< data[i];
	}
	cout << endl;
	cout << "此时top= " << top << endl;
	cout << endl;
}
int main()
{
	int n;
	cout << "请输入栈的大小：";
	cin >> n;
	Stack a(n);
	int m;
	cout << "请输入入栈的元素的个数：";
	cin >> m;
	if (a.isEmpty())//栈若为空，则进行入栈
	{
		for (int i = 0; i < m; i++)
		{
			if (!a.isFull())//判断栈是否已满
			{
				cout << "请输入入栈的元素：";
				char b;
				cin >> b;
				a.push(b);
			}
		}
	}

	cout << endl;
	a.display();

	a.setNull(n);//设置栈空
	a.display();

	//cout << a.getTop();//获得栈顶元素但不出栈
	//cout << endl;

	//char x;//检查上溢问题
	//cin >> x;
	//a.push(x);

	/*for (int i = 0; i < n; i++)
	{
		if (!a.isEmpty())
		{
			cout<<a.pop();
			cout << "出栈已完成" << endl;
			cout << endl;
		}
	}

	cout << endl;
	cout << "此时的栈：" << endl;
	a.display();*/

	return 0;
}

顺序栈的异常捕获

异常处理机制的原理：在真正导致错误的语句发送之前，并且异常发生的条件已经具备了，使用我们自定义的的软件异常或者系统的软件异常来代替它，从而阻止它，因此当异常抛出时，真正的错误实际上还没有发生。

异常处理机制的语法结构：try{}块包含可能会有异常抛出的代码段； catch{}块包含用户自定义的异常处理代码； throw是一条语句，用于抛出异常； 需要注意的是：一条throw语句只能抛出一条异常，一个catch子句也只能捕获一种异常，异常捕获必须和try块结合使用，并 且可以通过异常组合在一个地点捕获多种异常。

注意：1、 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个处理代码。 2、被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的那一个。 3、对于每一个抛出的异常，总能找到一个对应的throw语句，一些在是我们自己定义的语句，一些是标准库之中的。若没有写 throw语句，但是还是会catch到了异常。 4、由于异常处理机制采用的是类型匹配而不是值判断，因此在catch语句中只需要参数类型，除非确实要使用那个异常对象。

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
const int  MAX_SIZE = 100;//默认栈的大小
class Stack//以存储字符型数据为例
{
private:
	char* data;//线性表,指针变量指向栈的数组，保存首地址
	int size;//堆栈的实际大小
	int top;//栈顶
public:
	Stack();
	Stack(int s);
	~Stack();
	void push(char ch);//入栈
	char pop();//出栈并返回栈顶元素
	char getTop();//获得栈顶元素但不出栈
	bool isEmpty();//栈是否为空
	bool isFull();//栈是否满
	void setNull(int len);//设置栈为空
	void display();
	class Full {};//定义异常内部类
	class Empty {};//定义异常内部类
};
Stack::Stack()
{
	size = MAX_SIZE;
	top = -1;
	data = new char[MAX_SIZE];//缺省构造函数分配默认最大内存空间
}
Stack::Stack(int s)
{
	size = s;
	top = -1;
	data = new char[size];//根据指定大小s分配栈的内存空间
}
Stack::~Stack()
{
	delete[]data;//内存回收
}
void Stack::push(char ch)
{
	if (isFull())//数据上溢，丢出异常
	{
		throw Full();
	}
	else
	{
		data[++top] = ch;
	}
}
char Stack::pop()
{
	if (isEmpty())//数据下溢，丢出异常
	{
		throw Empty();
	}
	else
	{
		return data[top--];
	}

}
char Stack::getTop()
{
	if (!isEmpty())
	{
		return data[top];
	}
	else
	{
		throw Empty();
	}

}
bool Stack::isEmpty()
{
	if (top == -1)
		return 1;//栈为空
	else
		return 0;//栈已有元素
}
bool Stack::isFull()
{
	if (top >= size - 1)
	{
		return 1;//栈已满
	}
	else
		return 0;//栈未满
}
void Stack::setNull(int len)
{
	memset(data, 0, len * sizeof(char));
	top = -1;
}
void Stack::display()
{
	cout << "元素：";
	for (int i = 0; i <= top; i++)
	{
		printf("\t%c", data[i]);
	}
	cout << endl;
	cout << "此时top= " << top << endl;
	cout << endl;
}

int main()
{
	Stack s1(2);//栈的大小为2
	char ch;
	try
	{
		s1.push('a');
		s1.push('b');
		s1.push('c');//试图压入第三个元素'c'，将会引发异常捕获
	}
	catch (Stack::Full)//捕获异常
	{
		cout << "栈已满，无法入栈" << endl;
	}

	try
	{
		ch = s1.pop();
		cout << ch << endl;
		ch = s1.pop();
		cout << ch << endl;
		ch = s1.pop();//试图弹出第三个元素,将会引发异常捕获
		cout << ch << endl;
	}
	catch (Stack::Empty)//捕获异常
	{
		cout << "栈已空，无法出栈" << endl;
	}
	return 0;
}

 

链栈

链栈的存储结构与单链表的存储结构相同。由于栈是在栈顶进行删除和添加元素的，因此，设置一个头结点为栈顶是最方便的

链栈的结构

以结构体的形式来储存；next指针指向下一个结点

typedef struct DNode
{
	int len;//数据域来记录链栈的长度
	struct DNode* next;//结点中的next指针(结构体指针),指向下一个结构体
	char data;
}Jnode, * link;//Jnode相当于struct Node的别名，*link相当于一个指针类型

链栈的初始化

link initialStack()//初始化链栈，返回头指针
{
	link head = new struct DNode;//创建一个头指针(结构体类型)
	//link head = new Jnode;效果和上一句一样
	head->len = 0;//初始化长度
	head->next = NULL;//头指针设置为空，防止野指针
	return head;//返回头指针
}

判断栈空

bool isEmpty(link head)//传入头指针判断栈是否为空
{
	if (head->len == 0 || head->next == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

入栈

每次入栈相当于新创建一个结点

然后改变指针的指向，从而插入新的结点

void push(link head, char a)//每次入栈相当于新创建一个结点
{
	head->len++;
	link node = new Jnode;
	node->next = head->next;//让新创建的结点与头结点后面的第一个结点相联系
	head->next = node;//让头结点指向新结点，元素入栈
	node->data = a;
}

出栈

出栈相当于改变指针指向结点的顺序

将头指针指向被删除的结点的下一个结点，以保证链栈不会断裂，再将第一个结点删除

void pop(link head)//出栈相当于改变指针指向结点的顺序
{
	if (!isEmpty(head))
	{
		head->len--;//链栈的结点个数减少
		link node = head->next;//从第一个结点开始
		head->next = node->next;//让头指针指向第二个结点，node(第一个结点)是要被删除的，
		delete node;//删除第一个结点
	}
}

出栈并获得栈顶元素

char getpop(link head)//出栈并获得出栈的元素
{
	if (!isEmpty(head))
	{
		head->len--;
		link node = head->next;//从第一个元素开始
		head->next = node->next;//让头指针指向第二个结点
		char a = node->data;
		delete node;
		return a;
	}
}

打印链栈

void show(link head)
{
	if (head->next == NULL)
	{
		cout << "栈已为空";
	}
	link node = head->next;//为了不改变头指针，将其赋值给行新的变量
	while (node != NULL)
	{
		cout << node->data << " ";
		node = node->next;//指向下一个结点
	}
	cout << endl;
	cout << "栈的长度：" << head->len << endl;
	
}

完整的链栈

#include<iostream>
using namespace std;
#define MAX_SIZE 100
typedef struct DNode
{
	int len;//数据域来记录链栈的长度
	struct DNode* next;//结点中的next指针(结构体指针),指向下一个结构体
	char data;
}Jnode, * link;//node相当于struct Node的别名，*link相当于一个指针类型

link initialStack()//初始化链栈，返回头指针
{
	link head = new struct DNode;//创建一个头指针(结构体类型)
	//link head = new Jnode;效果和上一句一样
	head->len = 0;//初始化长度
	head->next = NULL;//头指针设置为空，防止野指针
	return head;//返回头指针
}
bool isEmpty(link head)//传入头指针判断栈是否为空
{
	if (head->len == 0 || head->next == NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
void push(link head, char a)//每次入栈相当于新创建一个结点
{
	head->len++;
	link node = new Jnode;
	node->next = head->next;//让新创建的结点与头结点后面的第一个结点相联系
	head->next = node;//让头结点指向新结点，元素入栈
	node->data = a;
}
void pop(link head)//出栈相当于改变指针指向结点的顺序
{
	if (!isEmpty(head))
	{
		head->len--;//链栈的结点个数减少
		link node = head->next;//从第一个结点开始
		head->next = node->next;//让头指针指向第二个结点，node(第一个结点)是要被删除的，
		delete node;//删除第一个结点
	}
}
char getpop(link head)//出栈并获得出栈的元素
{
	if (!isEmpty(head))
	{
		head->len--;
		link node = head->next;//从第一个元素开始
		head->next = node->next;//让头指针指向第二个结点
		char a = node->data;
		delete node;
		return a;
	}
}
void show(link head)
{
	if (head->next == NULL)
	{
		cout << "栈已为空";
	}
	link node = head->next;//为了不改变头指针，将其赋值给行新的变量
	while (node != NULL)
	{
		cout << node->data << " ";
		node = node->next;//指向下一个结点
	}
	cout << endl;
	cout << "栈的长度：" << head->len << endl;
	
}
int main()
{
	link head = initialStack();
	cout << "请输入结点个数：";
	int t;
	cin >> t;


	cout << "请输入入栈元素：";
	for (int i = 0; i < t; i++)
	{
		char x;
		cin >> x;
		push(head, x);
	}
	cout << "入栈后：" << endl;
	show(head);


	int n;
	cout << "请输入出栈的元素的个数：";
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		pop(head);
	}
	cout << "出栈后" << endl;
	show(head);


	int m;
	cout << "请输入出栈的元素的个数：";
	cin >> m;
	if (!isEmpty(head))
	{
		for (int i = 0; i < m; i++)
		{
			cout << "出栈元素：" << getpop(head) << " ";
		}
		cout << endl;
	}
	else
	{
		cout << "栈已空" << endl;
	}
	

}

 

 

 

 

 

 

 

 

 

 

 

薇鹅鹅莉特
关注
专栏目录
2023王道考研数据结构第三章---栈
weixin_52572034的博客
08-30 903
2023王道考研数据结构第三章---栈
C/C++学习日记：C语言栈区与堆区浅谈
C语言C++学习俱乐部：765860056
11-05 986
在编程中,内存分为五大分区:栈区内存,堆区,静态区,常量区,代码区. 看下面一个函数,你能发现它又什么问题?又该如何改正? char * getString() { char str[20] = "iPhone"; return str; } 首先,我们先来了解下五大分区的作用,然后上面的getString()函数的错误,就迎刃而解了. 栈区内存:是给函数里面的局部变量和形参分配内存.当发生函数调用时,操作系统就会为这个函数里面的所有局部变量和形参分配内存, 当函数调用完毕时, 所有.
OC内存内部组成部分,栈与堆的主要区别和联系,copy,mutableCopy与深拷贝,浅拷贝的关系...
weixin_34177064的博客
06-02 119
为什么80%的码农都做不了架构师？>>> ...
数据结构--栈的相关知识点以及实现
铭
06-24 3181
参考：《数据结构--java语言描述》 栈是仅限在表尾（也就是栈顶）进行插入和删除操作的线性表。 允许插入和删除操作的一端称为栈顶(top)，另一端称之为栈底(button) 不含任何元素的栈称之为空栈。 假设栈S={a1 , a2, … , an},则称a1为栈元素， an为栈顶元素。由于入栈和出栈都是对栈顶元素进行操作，遵循后进先出（LIFO, last in first out）的原则，因此栈又称为后进先出的线性表 入栈和出栈是栈的两个主要操作，入栈和出栈操作都是对栈顶元素进行过操作。所..
stack 中empty 和 isEmpty 方法区别
weixin_46047612的博客
08-16 506
stack 栈元素
java 栈的isEmpty()和empty()的区别
god_sword_的博客
09-12 2818
java 栈的isEmpty()和empty()的区别 public synchronized boolean isEmpty() { return elementCount == 0; } public synchronized int size() { return elementCount; } public boolean empty() { return size() == 0; } 从源码来说两者使用上没什么区别 但是在Java中，isEmpt
Zigbee协议栈高手学习笔记
04-11
Zigbee协议栈是物联网通信领域中...这份笔记涵盖了Zigbee协议栈的各个方面，无论是新手入门还是资深开发者，都能从中获益匪浅。在学习过程中，结合实例代码分析和理论知识的理解，将极大地提升对Zigbee技术的掌握程度。
OpenBTS--开源GSM协议栈代码，超高学习和研究价值。
08-27
无论是对通信协议感兴趣的工程师，还是寻求创新解决方案的创业者，都能从这个开源项目中获益匪浅。通过探索和研究OpenBTS的源代码，你可以掌握移动通信的核心技术，从而在相关领域实现更大的突破。
深搜与栈浅谈
QQ82272760的博客
11-28 1040
文章目录一、引入二、栈三、深度优先搜索算法四、经典例题1.自然数的拆分问题 一、引入 搜索分为两大类——深度优先搜索算法和广度优先搜索算法。这里我给大家介绍一下深度优先搜索算法（简称深搜）。它通过递归（即函数调用自身）的方式，一步步向答案逼近，最终得出正确答案。但值得注意的是，这种算法未经剪枝优化会特别慢，很容易超时。深搜被广泛应用到多个领域。在比赛中，深搜的思路也是特别好想的，在想不出别的思路时可以用深搜骗点分。剪枝什么的暂时先不讲，下面我们先介绍一下栈，再简介一下深搜模板，最后通过几道例题讲解一下。.
浅谈Linux内核TCP_IP协议栈源代码教学.pdf
09-06
"浅谈Linux内核TCP_IP协议栈源代码教学.pdf" Linux操作系统是当今世界上最流行的开源操作系统之一，而TCP/IP协议栈是Linux内核的核心组件之一。因此，学习Linux内核TCP/IP协议栈源代码对学生的能力培养起着至关重要...
关于栈顶指针初值为-1和0的区别
热门推荐
weixin_46475770的博客
02-25 1万+
关于栈顶指针初值为-1或者0 的区别(c语言) 栈顶指针：S.top 栈顶元素：S.data[S.top] 当栈顶指针的初始值设置 S.top=-1时 ps: 当栈为空时，栈顶指针指向data[-1],但栈底是data[0] top data{4} data{3} data{2} data{1} data{0} data{-1} … 进栈操作：栈不满时，栈顶指针先+1，在送值到栈顶元素 （通俗来讲：先给客人指路，客人才知道自己的座位在哪） S.top=S.
栈文档之顺序栈
二木成林
04-22 4363
采用顺序存储的栈称为顺序栈，它采用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时设定一个指针（top）指向当前栈顶元素的位置。通常采用数组来实现。
【脚踢数据结构】深入理解栈
最新发布
qq_64928278的博客
08-11 719
栈是一种基本的线性数据结构，遵循 "先进后出"（Last-In-First-Out，LIFO）的原则。栈有两种常见实现方式：顺序栈和链式栈，对于这两种方式的C语言实现细节讲解和例题。
学习记录：微信小程序页面栈
YoHoo的博客
03-05 173
页面栈存放数为5，超过后不会入栈！ navigateTo：不会将旧页面出栈； redirectTo：将旧页面出栈，再将需要跳转到的页面入栈； navigateBack：则是将页面栈最后一个元素出栈，因此倒数第二个元素会成为最后一个元素，即变成「当前页面」 ...
[剑指offer]-栈的压入、弹出序列
yuemingyang7010的博客
06-16 121
题目描述 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的） 思路:用一个栈来模拟压入弹出操作。 如果下一个弹出的数字刚好是栈顶数字, 那么直...
C++ 空栈不能调用top()
给你一颗小瓜子的博客
08-14 3919
题目描述(链接：https://ac.nowcoder.com/acm/contest/6912/A来源：牛客网) 牛牛最近迷上了小游戏，于是他也想对他的01字符串进行一些操作，01字符串上的0和0相邻时会变成1，而1和1相邻时会在字符串上消失，而0和1相邻时什么都不会发生，牛牛现在把初始的字符串给你，你能告诉牛牛这个字符串最后会变成什么样吗。 采用栈实现时，当栈为空时，以为空栈调用top函数会返回NULL，然而调用时会发生段错误。 原来stack 的top函数在栈为空时返回的是超尾-1,所以 T.
栈
Top_xiao的博客
12-08 4022
栈 ​ 栈是一种“先进后出”的线性数据结构。栈只有一端能够进出元素。能进出元素的一端叫栈顶，不能进出元素的一端叫栈底。当我们添加或者删除元素的时候，只能从栈顶操作。 上图就是一个栈，栈里面有三个元素。其中 3 号元素是栈顶，1 号元素栈底。只有当前元素是栈顶的时候才能出栈。所以上图只有 3 号元素可以出栈。如果 3 号元素出栈，那么栈顶就会变成 2 号元素。 例题 ​ 实现一个栈，支持 Push（入栈）、Pop（出栈）和 GetMax （查询栈内元素的最大值）三个操作，要求时间复杂度均为 O(1). 思路
C语言栈的push函数,关于栈的有关问题。为什么Push函数top始终是NULL
weixin_39605905的博客
05-25 286
当前位置:我的异常网» C语言»关于栈的有关问题。为什么Push函数top始终是NULL关于栈的有关问题。为什么Push函数top始终是NULLwww.myexceptions.net网友分享于：2014-04-25浏览：7次关于栈的问题。为什么Push函数top始终是NULL？#include#include#includetypedefcharelemtype;typedef...
java 栈的isEmpty()和empty()有什么区别
狼行千里
09-04 1万+
public synchronized boolean isEmpty() {       return elementCount == 0; } public synchronized int size() {       return elementCount; } public boolean empty() { return size() == 0;} //所以没有本质区别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值