栈的基本操作和栈的面试题

最新推荐文章于 2019-08-14 22:52:03 发布
最新推荐文章于 2019-08-14 22:52:03 发布
阅读量294 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangtianqiang1314/article/details/80979439
版权

栈的基本操作：

头文件“Stack.h”

# pragma once
# include "Stack.h"
# include <stdio.h>
# include <stdlib.h>
# include <assert.h>
# include <string.h>
# define maxsize 100
typedef char DataType;
typedef struct Stack
{
	DataType array[maxsize];
	int top;
}stack;
//初始化
void InitStack(stack *p);
//销毁
void Destory(stack *p);
//判断是否为空
int IsEmpty(stack *p);
//压栈
void Push(stack *p, DataType data);
//出栈
void Pop(stack *p);
//返回栈顶的值
DataType Top(stack *p);
//栈的大小
int StackSize(stack *p);
//显示
void  Show(stack *p);
//测试
void StackTest();

Stack.c文件

# include "Stack.h"

//初始化
void InitStack(stack *p)
{
	assert(p);
	p->top = 0;
}
//销毁
void Destory(stack *p)
{
	assert(p);
	p->top = 0;
}
//判断是否为空
int IsEmpty(stack *p)
{
	return p->top == 0 ? 1 : 0;
}
//压栈
void Push(stack *p, DataType data)
{
	assert(p != NULL);
	if (p->top >= maxsize)
		printf("栈溢出\n");
	p->array[p->top++] = data;
}
//出栈
void Pop(stack *p)
{
	assert(p != NULL);
	if (p->top == 0)
	{
		printf("栈为空\n");
		return;
	}
	p->top--;
}
//返回栈顶的值
DataType Top(stack *p)
{
	assert(p != NULL);
	if (p->top == 0)
		printf("栈为空\n");
	return p->array[--(p->top)];
}
//返回栈顶的值
DataType GetTop(stack *p)
{
	assert(p != NULL);
	if (p->top == 0)
		printf("栈为空\n");
	return p->array[p->top - 1];
}
//栈的大小
int StackSize(stack *p)
{
	return p->top;
}
//显示
void  Show(stack *p)
{
	int i = 0;
	for (; i < p->top; i++)
		printf("%d ", p->array[i]);
	printf("\n");
}
//测试
void StackTest()
{
	stack s;
	InitStack(&s);
	Push(&s, 1);
	Push(&s, 2);
	Push(&s, 3);
	Push(&s, 4);
	Push(&s, 5);
	Show(&s);
	DataType a = Top(&s);
	printf("%d\n", a);
	Show(&s);
	
}

test.c 文件

# include "Stack.h"

int main()
{
	StackTest();
	system("pause");
	return 0;
}

面试题

1.括号匹配问题

//括号匹配问题
void Match(char *a)
{
	stack s;
	InitStack(&s);//初始化栈
	char c;
	int i= 0, b = 1;//b用来标记是否匹配
	while ( b == 1)
	{
		if (a[i] == '\0')
			break;
		if (a[i] == '(' || a[i] == '[' || a[i] == '{')
			Push(&s, a[i]);
		else if (a[i] == ')')
		{
			c = Top(&s);
			if (c != '(')
			  b = 0;
		}
		else if (a[i] == ']')
		{
			c = Top(&s);
			if (c != '[')
			   b = 0;
		}
		else if (a[i] == '}')
		{
			c = Top(&s);
			if (c != '{')
			   b = 0;
		}
		i++;
	}
	if (b&&IsEmpty(&s))
		printf("匹配\n");
	else
		printf("不匹配\n");
}

2.最小栈

头文件MiniStack.h

# pragma once
# include "MinStack1.h"
# include "Stack.h"
# include <stdio.h>
# include <stdlib.h>

typedef int ElemType1;
//用一个栈
typedef struct MinStack1
{
	stack data;
}MinStack1;

//初始化
void MinInit(MinStack1 *p);
//销毁
void MinDestory(MinStack1 *p);
//入栈
void MinPush(MinStack1 *p, ElemType1 data);
//出栈
void MinPop(MinStack1 *p);
//返回栈顶的值
ElemType1 MinTop(MinStack1 *p);
//返回最小值
ElemType1 Min(MinStack1 *p);
MiniStack.c文件： 
# include "MinStack1.h"

//初始化
void MinInit1(MinStack1 *p)
{
	assert(p != NULL);
	InitStack(&(p->data));
}
//销毁
void MinDestory1(MinStack1 *p)
{
	assert(p != NULL);
	Destory(&(p->data));
}
//入栈
void MinPush1(MinStack1 *p, ElemType1 data)
{
	assert(p != NULL);
	DataType a, min;//a存放栈的值 min存放最小值
	if (IsEmpty(&(p->data)))
	{
		a = data;
		min = data;
		Push(&(p->data), a);
		Push(&(p->data), min);
	}
	else
	{
		if (data < GetTop(&(p->data)))
		{
			min = data;
			a = data;
			Push(&(p->data), a);
			Push(&(p->data), min);
		}
		else
		{
			min = GetTop(&(p->data));
			a = data;
			Push(&(p->data), a);
			Push(&(p->data), min);
		}
	}
}
//出栈
void MinPop1(MinStack1 *p)
{
	assert(p != NULL);
	if (p->data.top == 0)
	{
		printf("栈为空\n");
	}
	Pop(&(p->data));
	Pop(&(p->data));
}
//返回栈顶的值
ElemType1 MinTop1(MinStack1 *p)
{
	assert(p != NULL);
	if (p->data.top == 0)
	{
		printf("栈为空\n");
	}
	return GetTop2(&(p->data));
}
//返回最小值
ElemType1 Min1(MinStack1 *p)
{
	assert(p != NULL);
	if (p->data.top == 0)
	{
		printf("栈为空\n");
	}
	return GetTop(&(p->data));
}
//测试
void MinStack1Test()
{
	MinStack1 s;
	MinInit1(&s);
	MinPush1(&s, 7);
	MinPush1(&s, 6);
	MinPush1(&s, 5);
	MinPush1(&s, 1);
	MinPush1(&s, 1);
	MinPush1(&s, 2);
	MinPush1(&s, 1);
	Show(&(s.data));
	MinPop1(&s);
	printf("栈顶的值：%d\n", MinTop1(&s));
	printf("最小值：%d\n", Min1(&s));
}
test.c 
//# include "MinStack.h"
# include "MinStack1.h"
int main()
{
	MinStackTest();
	//MinStack1Test();
	system("pause");
	return 0;
}

3.两个队列实现一个栈

头文件

# pragma once
# include "StackBy2Queue.h"
# include "Queue.h"

typedef struct Stack1
{
	queue d1;
	queue d2;
	int size;
}stack1;
//初始化
void StackInit(stack1 *p);
//销毁
void StackDestory(stack1 *p);
//入栈
void StackPush(stack1 *p,DataType data);
//出栈
void StackPop(stack1 *p);
//返回栈顶的值
DataType StackTop(stack1 *p);
//栈的大小
int StackSize1(stack1 *p);

具体实现代码

# include "StackBy2Queue.h"

//初始化
void StackInit(stack1 *p)
{
	assert(p != NULL);
	QueueInit(&(p->d1));
	QueueInit(&(p->d2));
}
//销毁
void StackDestory(stack1 *p)
{
	assert(p != NULL);
	QueueDestory(&(p->d2));
	QueueDestory(&(p->d1));
}
//入栈
void StackPush(stack1 *p,DataType data)
{
	assert(p != NULL);
	//先判断哪个队列不为空，放到该队列，第一个元素在q2  
	if (!QueueIsEmpty(&p->d1))
	{
		QueuePush(&p->d1, data);
	}
	else
	{
		QueuePush(&p->d2, data);
	}
	p->size++;
}
//出栈
void StackPop(stack1 *p)
{
	assert(p != NULL);
	//当d1为空，把d2的前size - 1个元素倒入d1 
	if (QueueIsEmpty(&p->d1) && QueueIsEmpty(&p->d2))
		printf("栈为空\n");
	if (QueueIsEmpty(&p->d1))
	{
		while (QueueSize(&p->d2) > 1)
		{
			QueuePush(&p->d1, QueueTop(&p->d2));
			QueuePop(&p->d2);
		}
		QueuePop(&p->d2);            //移除d2最后一个元素  
	}
	else            //d2为空  
	{
		while (QueueSize(&p->d1) > 1)
		{
			QueuePush(&p->d2, QueueTop(&p->d1));
			QueuePop(&p->d1);
		}
		QueuePop(&p->d1);
	}
	p->size--;
}
//返回栈顶的值
DataType StackTop(stack1 *p)
{
	assert(p != NULL);
	if (QueueIsEmpty(&p->d1) && QueueIsEmpty(&p->d2))
		printf("栈为空\n");
	//当d1为空，把d2的前size - 1个元素倒入d1  
	if (QueueIsEmpty(&p->d1))
	{
		while (QueueSize(&p->d2) > 1)
		{
			QueuePush(&p->d1, QueueTop(&p->d2));
			QueuePop(&p->d2);
		}
		return QueueTop(&p->d2);            //返回d2最后一个元素  
	}
	else            //d2为空  
	{
		while (QueueSize(&p->d1) > 1)
		{
			QueuePush(&p->d2, QueueTop(&p->d1));
			QueuePop(&p->d1);
		}
		return QueueTop(&p->d1);
	}
}
//栈的大小
int StackSize1(stack1 *p)
{
	return p->size;
}
//测试
void Stack1Test()
{
	stack1 s;
	QueueInit(&s);
	QueuePush(&s, 1);
	QueuePush(&s, 2);
	QueuePush(&s, 3);
	QueuePush(&s, 4);
	QueuePush(&s, 5);
	QueuePush(&s, 6);
	printf("%d\n", QueueTop(&s));
}

4.两个栈实现一个队列

头文件：

# pragma once 
# include "QueueBy2Stack.h"
# include "Stack.h"

typedef int ElemType;
typedef struct Queue1
{
	stack input;
	stack output;
	//队列的有效元素个数
	int size;
}queue1;
//初始化
void QueueInit1(queue1 *p);
//销毁
void QueueDestory1(queue1 *p);
//入队
void QueuePush1(queue1 *p,ElemType data);
//出队
void QueuePop1(queue1 *p);
//队头的值
ElemType QueueTop1(queue1 *p);
//打印
void  QueueShow1(queue1 *p);

具体实现代码

# include "QueueBy2Stack.h"

//初始化
void QueueInit1(queue1 *p)
{
	assert(p != NULL);
	InitStack(&(p->input));
	InitStack(&(p->output));
	p->size = 0;
}
//销毁
void QueueDestory1(queue1 *p)
{
	assert(p != NULL);
	Destory(&(p->output));
	Destory(&(p->input));
	p->size = 0;
}
//入队
void QueuePush1(queue1 *p, ElemType data)
{
	assert(p != NULL);
	//如果output为空直接入栈input
	//intput为空但是output不为空，此时入队操作，应该把栈output中的元素移回intput，再执行input入栈
	if (IsEmpty(&(p->output)))
	{
		Push(&(p->input), data);
	}
	else
	{
		while (!IsEmpty(&(p->output)))
		{
			ElemType a = Top(&(p->output));
			Push(&(p->input), a);
		}
		Push(&(p->input), data);
	}
	p->size++;
}
//出队
void QueuePop1(queue1 *p)
{
	//判断input是否为空，不为空则全部压入output栈，然后output栈pop
	assert(p != NULL);
	if (p->size==0)
	printf("队列为空\n");
	while (p->input.top!=0)
	{
		ElemType a = Top(&(p->input));
		Push(&(p->output), a);
	}
	Pop(&(p->output));
	p->size--;
}
//队头的值
ElemType QueueTop1(queue1 *p)
{
	assert(p != NULL);
	if (p->size==0)
	printf("队列为空\n");
	while (!IsEmpty(&(p->input)))
	{
		ElemType a = Top(&(p->input));
		Push(&(p->output), a);
	}
	return GetTop(&(p->output));
}
//打印
void  QueueShow1(queue1 *p)
{
	assert(p != NULL);
	if (p->size == 0)
		printf("队列为 空\n");
	while (p->input.top != 0)
	{
		ElemType a = Top(&(p->input));
		Push(&(p->output), a);
	}
	Show(&(p->output));
}
//测试
void Queue1Test()
{
	queue1 s;
	QueueInit1(&s);
	QueuePush1(&s, 1);
	QueuePush1(&s, 2);
	QueuePush1(&s, 3);
	QueuePush1(&s, 4);
	QueuePush1(&s, 5);
	QueuePush1(&s, 6);
	QueuePush1(&s, 7);
	QueueShow1(&s);
	printf("%d\n", s.size);
	QueuePop1(&s);
	QueueShow1(&s);
	printf("%d\n",QueueTop1(&s));
}

5.元素出栈入栈的合法性

void IsJudge(char *in, char *out)
{
	stack q;
	InitStack(&q);
	assert(in&&out);
	int i = 0;
	int j = 0;
	if (strlen(in) != strlen(out))
	{
		printf("不合法\n");
		return;
	}
	for (; i<strlen(in); i++)//将入栈序列压入栈
	{
		if (IsEmpty(&q)|| GetTop(&q) != out[j])//栈为空或者栈顶元素不等于出栈序列
		{
			Push(&q, in[i]);
		}
		else//相等时将栈顶元素出栈，并将出栈序列向后移动一位
		{
			Pop(&q);
			j++;
		}
	}
	while (!IsEmpty(&q))//压栈结束后，再比较出栈序列剩下的
	{
		if (GetTop(&q)!= out[++j])
		{
			printf("不合法\n");
			break;
		}
		else
			Pop(&q);
	}
	if (IsEmpty(&q))//循环比较后，如果栈为空，则出栈序列是合法的。
		printf("合法\n");
}

一个数组实现两个栈 

1.奇偶数组

头文件

# pragma once
# include "TwoStackBy1Array1.h"
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <assert.h>
# define CAPACITY 4
typedef int DataType;
//奇偶栈
typedef struct Stack2
{
	DataType *array;
	int capacity;
	int top1;
	int top2;
}stack2;
//初始化
void InitStack2(stack2 *p);
//销毁
void DestoryStack2(stack2 *p);
//增容
void ExpandIfRequire(stack2 *p);
//入栈
void PushStack2(stack2 *p,DataType data, int a);//a表示是哪一个
//出栈
void PopStack2(stack2 *p, int a);
//返回栈顶的值
DataType TopStack2(stack2 *p, int a);
//栈的大小
int SizeStack2(stack2 *p, int a);
//判断是否为空
int IsEmpty2(stack2 *p, int a);
//打印
void Show2(stack2 *p, int a);

具体实现代码

# include "TwoStackBy1Array1.h"

//初始化
void InitStack2(stack2 *p)
{
	assert(p!=NULL);
	p->capacity = CAPACITY;
	p->array = (DataType *)malloc(sizeof(DataType)*p->capacity);
	p->top1 = 0;
	p->top2 = 1;

}
//销毁
void DestoryStack2(stack2 *p)
{
	assert(p != NULL);
	p->top1 = 0;
	p->top2 = 1;
	free(p->array);
}
//增容
void ExpandIfRequire(stack2 *p)
{
	if (p->top1 != p->capacity&&p->top2 != p->capacity + 1)
		return;
	int oldcapacity = p->capacity;
	p->capacity *= 2;
	DataType *newarray = (DataType *)malloc(sizeof(DataType)*p->capacity);
	assert(newarray != NULL);
	memcpy(newarray, p->array, sizeof(DataType)*oldcapacity);
	free(p->array);
	p->array = newarray;
}
//入栈
void PushStack2(stack2 *p,DataType data, int a)
{
	assert(p != NULL);
	ExpandIfRequire(p);
	if (a == 1)
	{
		p->array[p->top1] = data;
		p->top1 += 2;
	}
	else if (a == 2)
	{
		p->array[p->top2 ] = data;
		p->top2 += 2;
	}
}
//出栈
void PopStack2(stack2 *p, int a)
{
	assert(p != NULL);

	if (a == 1)
	{
		p->top1 -=2;
	}
	else if (a == 2)
	{
		p->top2 -=2;
	}
}
//返回栈顶的值
DataType TopStack2(stack2 *p, int a)
{
	assert(p != NULL);
	if (a == 1)
	{
		return p->array[p->top1 - 2];
	}
	else if (a == 2)
	{
		return p->array[p->top2 - 2];
	}
}
//栈的大小
int SizeStack2(stack2 *p, int a)
{
	assert(p != NULL);
	if (a == 1)
	{
		return p->top1 / 2;
	}
	else if (a == 2)
	{
		return p->top2 / 2;
	}
}
//判断是否为空
int IsEmpty2(stack2 *p, int a)
{
	assert(p != NULL);
	if (a == 1)
	{
		return p->top1 == 0 ? 1 : 0;
	}
	else if (a == 2)
	{
		return p->top2 == 1 ? 1 : 0;
	}
}
//打印
void Show2(stack2 *p, int a)
{
	if (a == 1)
	{
		int i = 0;
		for (; i < p->top1; i+=2)
			printf("%d ", p->array[i]);
		printf("\n");
	}
	else if (a == 2)
	{
		int i = 1;
		for (; i < p->top2;i+=2)
			printf("%d ", p->array[i]);
		printf("\n");
	}
}
//测试
void Test()
{
	stack2 s;
	InitStack2(&s);
	PushStack2(&s, 1, 1);
	PushStack2(&s, 1, 2);
	PushStack2(&s, 2, 1);
	PushStack2(&s, 2, 2);
	PushStack2(&s, 3, 1);
	PushStack2(&s, 3, 2);
	PushStack2(&s, 4, 1);
	PushStack2(&s, 4, 2);
	Show2(&s,1);
	Show2(&s,2);
}

双头栈

头文件

# pragma once
# include "2StackBy1Array.h"
# include <stdio.h>
# include <stdlib.h>
# include <assert.h>
# define maxsize 100
# define MAXSIZE 200
typedef int DataType;
//双头栈
typedef struct TwoStack
{
	DataType array[MAXSIZE];
	int top1;
	int top2;
}twostack;
//初始化
void InitTwoStack(twostack *p);
//销毁
void  DestoryTwoStack(twostack *p);
//入栈
void PushTwoStack(twostack *p, DataType data, int a);
//出栈
void PopTwoStack(twostack *p, int a);
//返回栈顶的值
DataType TopTwoStack(twostack *p, int a);
//栈的大小
int SizeTwoStack(twostack *p, int a);
//判断是否为空
int EmptyTwoStack(twostack *p, int a);
//显示
void ShowTwoStack(twostack *p, int a);

具体实现代码

# include "2StackBy1Array.h"

//初始化
void InitTwoStack(twostack *p)
{
	assert(p != NULL);
	p->top1 = 0;
	p->top2 = MAXSIZE-1;
}
//销毁
void  DestoryTwoStack(twostack *p)
{
	assert(p != NULL);
	p->top1 = 0;
	p->top2 = MAXSIZE-1;
}
//入栈
void PushTwoStack(twostack *p, DataType data, int a)//a 表示是哪一个
{
	assert(p != NULL);
	if (a ==1)
	{
		if (p->top1 >= maxsize)
		{
			printf("栈溢出\n");
			return;
		}
		p->array[p->top1++] = data;
	}
	else if (a == 2)
	{
		if (p->top2 < maxsize)
		{
			printf("栈溢出\n");
			return;
		}
		p->array[p->top2--] = data;
	}
}
//出栈
void PopTwoStack(twostack *p, int a)
{
	assert(p != NULL);
	if (a == 1)
	{
		if (p->top1 == 0)
			printf("栈为空\n");
		p->top1--;
	}
	else if (a == 2)
	{
		if (p->top2 == MAXSIZE-1)
			printf("栈为空\n");
		p->top2++;
	}

}
//返回栈顶的值
DataType TopTwoStack(twostack *p, int a)
{
	assert(p != NULL);
	if (a == 1)
	{
		if (p->top1 == 0)
			printf("栈为空\n");
		return p->array[p->top1 - 1];
	}
	else if (a == 2)
	{
		if (p->top2== MAXSIZE-1)
			printf("栈为空\n");
		return p->array[p->top2+1];
	}
}
//栈的大小
int SizeTwoStack(twostack *p, int a)
{
	assert(p != NULL);
	if (a == 1)
	{
		return p->top1;
	}
	else if (a == 2)
	{
		return MAXSIZE - (p->top2)-1;
	}
}
//判断是否为空
 int EmptyTwoStack(twostack *p, int a)
{
	assert(p != NULL);
	if (a == 1)
	{
		return p->top1 == 0 ? 1 : 0;
	}
	else if (a == 2)
	{
		return p->top2 == MAXSIZE-1 ? 1 : 0;
	}
}
//显示
 void ShowTwoStack(twostack *p, int a)
 {
	 assert(p != NULL);
	 if (a == 1)
	 {
		 int i = 0;
		 for (; i < p->top1; i++)
			 printf("%d ", p->array[i]);
		 printf("\n");
	 }
	 else if (a == 2)
	 {
		 int i = MAXSIZE-1;
		 for (; i >(p->top2); i--)
			 printf("%d ", p->array[i]);
		 printf("\n");
	 }
 }
 //测试
 void Test()
 {
	 twostack s;
	 InitTwoStack(&s);
	 PushTwoStack(&s, 66, 1);
	 PushTwoStack(&s, 1, 2);
	 PushTwoStack(&s, 2, 1);
	 PushTwoStack(&s, 66, 2);
	 PushTwoStack(&s, 3, 1);
	 PushTwoStack(&s, 3, 2);
	 PushTwoStack(&s, 4, 1);
	 PushTwoStack(&s, 4, 2);
	 ShowTwoStack(&s, 1);
	 ShowTwoStack(&s, 2);
	 printf("%d", SizeTwoStack(&s, 2));
	 printf("%d", TopTwoStack(&s, 2));
 }

zhangtianqiang1314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python构建多叉树及多叉树的倒序遍历
cloud____的博客
09-13 2162
AllTreePath=[] class MultywayTree(): class Node():#初始化节点 def __init__(self,data): self.data=data self.child_list=[] self.parent=None def __init__(self,root):#初始化根节点 self.root=self.Node(root)
关于栈常见的面试题
PYTHON的博客
07-23 649
* 实现一个栈，要求实现push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1)* 法1：分析：将元素与最小值封装成一个结构体 头文件： StackAndQueueInterview.h： // 将元素与最小值封装成一个结构体 typedef struct Elem { ElemType _data; ElemType _minData; }Elem; ...
堆栈的使用（c语言描述）
weixin_42050660的博客
05-21 364
#include&lt;stdio.h&gt; #include&lt;string.h&gt; int len; struct stack { char str[55]; int top; }; typedef struct stack Stack; Stack s; void init() { s.top=-1; } void push(char element) { ...
【算法与数据结构】堆 heap - 基于数组实现的完全二叉树
kikajack的博客
08-14 190
#include <stdio.h> #include <string.h> #define MAXSIZE 100 typedef struct heap { int data[MAXSIZE]; int size; } heap; void heap_init(heap *h) { h->size = 0; memset(h-...
串之顺序串算法
ayangya的博客
12-17 1322
#include<stdio.h> #include<stdlib.h> #include<string.h> #define maxsize 100 typedef struct { char data[maxsize]; int length; }seqString;typedef struct { char ch; int count; }chh;//创建串的
面试题2021.pdf
03-28
本文档提供了多个JavaScript相关的面试题和答案，涵盖了基本数据类型、引用数据类型、类型转换、判断数据类型等知识点。下面是对每个知识点的详细解释： 基本数据类型和引用数据类型 在JavaScript中，有两种基本...
python常见面试题15道
07-02
Python 基础知识点总结 ...* 问题 1：Python 的基本特点和应用场景。 * 问题 2：递归函数的使用和 os 模块的应用。 * 问题 3：Python 的数据结构和操作，包括 dict、range 和 list comprehension。
的Java工程师面试题.doc
12-21
Java工程师面试题知识点总结 本文总结了Java工程师面试题中的知识点，涵盖了Java基础知识、面向对象编程、数据结构与算法、多线程编程等方面的知识点。 一、Java基础知识 1. Java标识符：Java标识符可以是字母、...
JAVA面试题集模板.doc
11-24
JAVA 面试题集模板知识点汇总 以下是根据给定的文件信息生成的知识点： 1. 异常处理机制： JAVA 中的异常处理机制是指当 JAVA 程序违反了 JAVA 的语义规则时，JAVA 虚拟机就会将发生的错误表示为一个异常。异常...
2022年Java企业面试题整理.doc
11-11
本文将对Java企业面试题整理进行详细的知识点解释和分析。该文档涵盖了Java面试中的多个方面，包括函数构建、冒泡算法、堆和栈的区别、索引的使用、项目体系构造图、同步和异步的区别等知识点。 1. 构建一种函数 ...
栈——经典面试题（1）
10-17
题目：输入两个整数序列，第一个表示栈的压入顺序，请判断第二序列是否为该栈的弹出序列，假设压入栈的所有数字均不相等。--java实现
栈的面试题
和产品battle的秃头程序
06-22 500
面试题30 包含min函数的栈 题目描述 定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。在该栈中，调动min、push、及pop的时间复杂度都是O（1）。 为了保证当我们弹出当前最小元素后，下一个最小元素也能够立即得出。因此我们可以把每次的最小元素放到另一个辅助栈中。以下列例子为例： 首先往空栈里压入数字3，显然3是当前最小值，把3也压入辅助栈中。接下来压入4，发现...
数据结构实验之栈与队列八：栈的基本操作
Horizonhui
09-27 996
数据结构实验之栈与队列八：栈的基本操作 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 堆栈是一种基本的数据结构。堆栈具有两种基本操作方式，push 和 pop。push一个值会将其压入栈顶，而 pop 则会将栈顶的值弹出。现在我们就来验证一下堆栈的使用。
栈的相关问题
ncut_nwpu的博客
05-10 268
一、使用栈实现将中缀表达式转换为后缀表达式算法：1.创建一个栈 2.对于输入表达式中的每一个字符t: t是一个操作数→直接输出 t是右括号→当前栈顶出栈并输出该符号，直到一个左括号出栈（左括号不输出） t是操作符→读出当前栈顶，并输出栈顶符号，直到出现一个左括号或者优先级比t低的符号或者栈空 t入栈 3.出栈并输出该符号，直至栈空二、使用栈计算后缀表达式的值1.创建...
剑指offer-面试题22.栈的压入,弹出序列
weixin_34362875的博客
07-26 90
题目:输入两个整数序列,第一个序列表示栈的压入顺序，请判断第 二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。 例如序列1、2、3、4、5是某栈的压栈序列，序列4、5、3、2、1 是该压栈序列对应的一个弹出序列，但4、3、5、1、2就不可能是该 该压栈序列的弹出序列。 这种判断其实只要掌握栈的先进后出原则,则不难解决。 本题的题解步骤如下: 1.设置一个辅助栈...
栈和队列的经典例题（括号匹配，用栈实现队列，用队列实现栈，设计循环队列）
身在边城 心在编程
04-19 371
栈和队列的基础接口实现 链接：https://blog.csdn.net/qq_43763344/article/details/89386829 .============================================================ 头文件： #include <iostream> #include <stdio.h> #include...
栈实现计算器四则运算+一个任意两个超大位数加法
h674174380的博客
08-22 627
前段时间利用栈写了一个实现了计算器功能的程序。觉得有意思的，因此今天在这了和大家分享一番。 首先，要写出计算器，你要按照以下几点去写，才能保证运算的优先级不发生错误。 v栈的应用举例 n栈在表达式计算过程中的应用 ：建立操作数栈和运算符栈。运算符有优先级。规则： n自左至右扫描表达式，凡是遇到操作数一律进操作数栈。 n当遇到运算符时，如果它的优先级比运算符栈栈
循环队列的基本操作
Duke10的博客
11-19 826
VC6.0下写的：#include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 typedef char datatype; typedef struct { datatype *base; //存储空间的基地址 int front; //记录队头的下标 int rear; //记录队尾下一个位
java 10k面试题
最新发布
07-08
还有JVM相关的知识在Java 10k面试题中也会涉及到，如垃圾回收机制、堆和栈的区别等。 总之，掌握这些Java的关键知识点是面试成功的前提。在面试中，不仅要掌握理论知识，还要注重实践经验和项目经验的积累。通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值