数据结构——栈和队列及其面试题

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

1. 利用顺序表实现栈

函数接口:

typedef int SDataType;

typedef struct Stack {
SDataType array[100];
int top;
} Stack;

// 初始化
void StackInit(Stack *pStack);

// 压栈
void StackPush(Stack *pStack, SDataType data);

// 出栈
void StackPop(Stack *pStack);

// 返回栈顶元素
SDataType StackTop(Stack *pStack);

// 判断是否为空
// 1 空
// 0 不空
int StackIsEmpty(Stack *pStack);

// 返回数据个数
int StackSize(Stack *pStack);


2. 利用单链表实现队列

函数接口:

typedef int QDataType;

typedef struct QNode {
QDataType data;
struct QNode *pNext;
} QNode;

typedef struct Queue {
QNode *pFront;
QNode *pRear;
int size;
} Queue;

// 初始化
void QueueInit(Queue *pQueue);

// 入队列
void QueuePush(Queue *pQueue, QDataType data);

// 出队列
void QueuePop(Queue *pQueue);

// 返回队首元素
QDataType QueueFront(Queue *pQueue);

// 判断是否为空
// 1 空
// 0 不空
int QueueIsEmpty(Queue *pQueue);

// 返回数据个数
int QueueSize(Queue *pQueue);

 

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int QDataType;

typedef struct QNode {
	QDataType data;
	struct QNode *pNext;
} QNode;

typedef struct Queue {
	QNode *pFront;
	QNode *pRear;
	int size;
} Queue;

// 初始化 
void QueueInit(Queue *pQueue)
{
	assert(pQueue);
	pQueue->pFront = pQueue->pRear = NULL;
	pQueue->size = 0;
}

// 入队列 
void QueuePush(Queue *pQueue, QDataType data)
{
	assert(pQueue);
	pQueue->size++;
	QNode *pNewNode = (QNode*)malloc(sizeof(QNode));
	assert(pNewNode);
	pNewNode->data = data;
	pNewNode->pNext = NULL;

	if (pQueue->pRear == NULL)
	{
		pQueue->pFront = pQueue->pRear = pNewNode;
		return;
	}

	pQueue->pRear->pNext = pNewNode;
	pQueue->pRear = pNewNode;
}

// 出队列 
void QueuePop(Queue *pQueue)
{
	assert(pQueue);
	pQueue->size--;
	QNode *pOldNode = pQueue->pFront;
	pQueue->pFront = pQueue->pFront->pNext;
	free(pOldNode);

	if (pQueue->pFront == NULL)
	{
		pQueue->pRear = NULL;
	}

}

// 返回队首元素 
QDataType QueueFront(Queue *pQueue)
{
	assert(pQueue);
	assert(pQueue->size > 0);
	return pQueue->pFront->data;
}

// 判断是否为空 
// 1 空 
// 0 不空 
int QueueIsEmpty(Queue *pQueue)
{
	return pQueue->size == 0 ? 1 : 0;
}

// 返回数据个数 
int QueueSize(Queue *pQueue)
{
	return pQueue->size;
}
void print2(Queue *pQueue)
{
	assert(pQueue);
	
	QNode *pNode = pQueue->pFront;
	int i = 0;
	for (pNode; i<pQueue->size; pNode = pNode->pNext)
	{
		printf("%d ", pNode->data);
		i++;
	}
	printf("\n");
}
void testQueue()
{
	Queue queue;
	QueueInit(&queue);
	QueuePush(&queue, 1);
	QueuePush(&queue, 2);
	QueuePush(&queue, 3);
	QueuePush(&queue, 4);
	print2(&queue);
	int x = QueueSize(&queue);
	printf("%d\n", x);
	QueuePop(&queue);
	print2(&queue);
}


3. 栈与队列面试题
1) 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1)
2) 使用两个栈实现一个队列
3) 使用两个队列实现一个栈
4) 元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为 (4,5,3,2,1)
5) 一个数组实现两个栈(共享栈) 

 

 

 

#pragma once
typedef void* SDataType;
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef struct Stack {
	SDataType array[100];
	int top;//表示个数
} Stack;

// 初始化 
void StackInit(Stack *pStack)
{
	assert(pStack != NULL);
	pStack->top = 0;
}
void Stackdestroy(Stack *pStack)
{
	pStack->top = 0;
}

// 压栈 
void StackPush(Stack *pStack, SDataType data)
{
	assert(pStack);
	if (pStack->top < 100)
	{
		pStack->array[pStack->top] = data;
		pStack->top++;
	}
}

// 出栈 
void StackPop(Stack *pStack)
{
	assert(pStack);
	if (pStack->top > 0)
	{
		pStack->top--;
	}
}

// 返回栈顶元素 
SDataType StackTop(Stack *pStack)
{
	assert(pStack);
	if (pStack->top > 0)
	{
		return pStack->array[pStack->top-1];
	}
}

// 判断是否为空 
// 1 空 
// 0 不空 
int StackIsEmpty(Stack *pStack)
{
	return pStack->top == 0 ? 1 : 0;
}

// 返回数据个数 
int StackSize(Stack *pStack)
{
	return pStack -> top;
}
void print1(Stack *pStack)//打印栈
{
	assert(pStack);
	while (pStack->top)
	{
		printf("%d ", pStack->array[pStack->top - 1]);
		pStack->top--;
	}
	printf("\n");
}
void TestStack()
{
	Stack	stack;
	StackInit(&stack);
	StackPush(&stack, 1);
	StackPush(&stack, 1);
	StackPush(&stack, 1);
	StackPush(&stack, 1);
	int x=StackTop(&stack);
	printf("%d\n", x);

	int y = StackSize(&stack);//元素个数
	printf("%d\n", y);
	int z = StackIsEmpty(&stack);//判空
	printf("%d\n", z);
	StackPop(&stack);//出栈
	print1(&stack);
	Stackdestroy(&stack);
}
//实现一个栈，要求实现Push(出栈)Pop(入栈)、Min(返回最小值)的时间复杂度为O(1)
/*typedef struct MinStack {
	int	array1[100];	// 普通数据
	int top1;
	int array2[100];	// 最小数据
	int top2;
}	MinStack;*/
typedef struct MinStack{
	int array[100];
	int top;
}MinStack;
void Init(MinStack *pStack)
{
	pStack->top = 0;
	//pStack->top1 = pStack->top2 = 0;
}
void Push(MinStack *pStack, int data)
{
	
	int min = data;
	if (pStack->top != 0 && pStack->array[pStack->top - 1] < data)
	{
		min = pStack->array[pStack->top - 1];
	}
	pStack->array[pStack->top++] = data;
	pStack->array[pStack->top++] = min;
	/*if (pStack->top2 != 0 && pStack->array2[pStack->top2-1] < data)
	{
		min = pStack->array2[pStack->top2-1];
	}
	pStack->array1[pStack->top1++] = data;
	pStack->array2[pStack->top2++] = min;*/
}
void Pop(MinStack *pStack)
{
	pStack->top -= 2;
	//pStack->top1--;
	//pStack->top2--;
}
int  Top(MinStack *pStack)
{
	return pStack->array[pStack->top - 2];
	//return  pStack->array1[pStack->top1-1];
}
int Min(MinStack *pStack)
{
	return  pStack->array[pStack->top - 1];
	//return pStack->array2[pStack->top2-1];
}
void TestMinStack()
{
	MinStack  minStack;
	int array[] = { 3, 2, 3, 4, 5, 6, 7, 8, 9 };
	Init(&minStack);
	int i = 0;
	for (; i < sizeof(array) / sizeof(array[0]); i++)
	{
		Push(&minStack, array[i]);
		printf("栈顶元素: %d，Min: %d\n", Top(&minStack), Min(&minStack));
	}
	for (; i < sizeof(array) / sizeof(array[0]); i++) {
		Pop(&minStack);
	}
}
//使用两个栈实现一个队列 
typedef struct SQueue{
	Stack  stack1;//入数据
	Stack  stack2;//出数据
}SQueue;
void SInit(SQueue *PS)
{
	Stack *p1,*p2;
	p1 = &(PS->stack1);
	p2 = &(PS->stack2);
	
	StackInit(p1);
	StackInit(p2);
}
void SPush(SQueue *PS, SDataType data)
{
	Stack *p1, *p2;
	p1 = &(PS->stack1);
	p2 = &(PS->stack2);

	StackPush(p1,data);
}
void SPop(SQueue *PS)
{
	Stack *p1, *p2;
	p1 = &(PS->stack1);
	p2 = &(PS->stack2);
	SDataType data;
	if (StackIsEmpty(p2))
	{
		while (!StackIsEmpty(p1))
		{
			data = StackTop(p1);
			StackPop(p1);
			StackPush(p2, data);
		}
	}
	StackPop(p2);
}
SDataType SFront(SQueue *PS)
{
	Stack *p1, *p2;
	p1 = &(PS->stack1);
	p2 = &(PS->stack2);
	SDataType data;
	if (StackIsEmpty(p2))
	{
		while (!StackIsEmpty(p1))
		{
			data = StackTop(p1);
			StackPop(p1);
			StackPush(p2, data);
		}
	}
	return StackTop(p2);
}
//使用两个队列实现一个栈 
#include "Queue.h"
typedef struct QStack
{
	Queue queue;
}Qstack;
void QInit(Qstack *psd)
{
	QueueInit(&(psd->queue));
}
void QPush(Qstack *psd, SDataType data)
{
	QueuePush(&(psd->queue), data);
}
void QPop(Qstack *psd)
{
	int i;
	SDataType data;
	Queue *PQ = &(psd->queue);
	for (i = 1; i < QueueSize(PQ); i++)
	{
		data = QueueFront(PQ);
		QueuePop(PQ);
		QueuePush(PQ, data);
	}
	QueuePop(PQ);
}
QDataType STop(Qstack *psd)
{
	int i;
	SDataType data;
	Queue *PQ = &(psd->queue);
	for (i = 1; i < QueueSize(PQ); i++)
	{
		data = QueueFront(PQ);
		QueuePop(PQ);
		QueuePush(PQ, data);
	}
	data = QueueFront(PQ);
	QueuePop(PQ);
	QueuePush(PQ, data);
	return data;
}

 

 

 

#pragma once
#include<stdio.h>
//1. 两个数组实现
//2. 不再每次都入最小栈
typedef struct Minstack
{
	int array1[100];
	int top1;//普通数据
	int array2[100];
	int top2;//最小数据
}Minstack;
void Init(Minstack *pS)
{
	pS->top1 = pS->top2 = 0;
}
void Push(Minstack *pS,int data)
{
	pS->array1[pS->top1++] = data;
	if (pS->top2 == 0 || data <= pS->array2[pS->top2 - 1])
	{
		pS->array2[pS->top2++] = data;
	}
}
void Pop(Minstack *pS)
{
	if (pS->array1[pS->top1 - 1] == pS->array2[pS->top2 - 1])
	{
		pS->top2--;
	}
	pS->top1--;
}
int Top(Minstack *pS)
{
	return pS->array1[pS->top1 - 1];
}

int Min(Minstack *pS)
{
	return pS->array2[pS->top2 - 1];
}
void test()
{
	Minstack  minStack;
	int array[] = { 3, 2, 3, 4, 5, 6, 7, 8, 9 };
	Init(&minStack);
	int i = 0;
	for (; i < sizeof(array) / sizeof(array[0]); i++)
	{
		Push(&minStack, array[i]);
		printf("栈顶元素: %d，Min: %d\n", Top(&minStack), Min(&minStack));
	}
	for (; i < sizeof(array) / sizeof(array[0]); i++) {
		Pop(&minStack);
	}
}

 

 


 

 

 

CDatreides
关注
专栏目录
数据结构-栈和队列笔试题
DuckyLoser的博客
05-18 295
最小栈(两种方法) 两个栈实现一个队列 两个队列实现一个栈 判定字符串是否按照出栈顺序 共享栈(一个数组实现两个栈)#pragma once #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef char StackType; typedef struct Stack { StackType data; struc...
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2308
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
栈和队列及其背后的数据结构
ZJRUIII的博客
01-03 3859
文章目录一、栈(Stack)1.栈的基本概念2.用顺序表实现栈3.用链表实现栈4.有关栈的相关面试题例一：不可能的输出序列例二：中缀表达式转后缀表达式二、队列(Queue) 一、栈(Stack) 1.栈的基本概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈
【Java数据结构】栈与队列 经典面试题——刷题笔记
DerrickWestbrook的博客
11-25 1606
【Java数据结构】栈与队列 经典面试题——解题笔记+动图思路1. 实现一个最小栈题目：思路：实现代码2. 括号匹配问题题目：思路：实现代码3. 用队列实现栈题目：思路：实现代码：4. 用栈实现队列题目：思路：实现代码：5. 设计循环队列题目：思路：实现代码： 1. 实现一个最小栈 题目： 思路： 把题目要求的最小栈内部分为两个栈，一个stack用于储存所有元素，另一个min_stack用于储存最小的元素 压入第一个元素时，这个元素就是当前栈里最小元素，所以不光要压入stack栈中也要压入min.
【JS数据结构】线性结构——栈结构
早睡早起长头发的博客
10-13 740
一. 认识栈结构 1.栈结构 1.1栈（stack） 1.2 生活中类似于栈的 1.3 栈结构的图解 1.4 程序中的函数调用栈是使用栈实现的呢? 1.5 栈面试题 二. 栈结构实现 1.栈的创建 1.1 创建一个栈的类, 用于封装栈相关的操作 1.2 代码解析: 2.栈的操作 2.1 方式一 2.2 方式二 3.栈的使用 三. 栈结构应用 1.十进制转二进制 1.1 为什么需要十进制转二进制 1.2 如何实现十进制转二进制 1.3 代码来实现十进制转二进制
数据结构——队列 （队列结构、队列实现、优先级队列、队列面试题）
qq_52301431的博客
08-22 462
普通的队列插入一个元素, 数据会被放在后端. 并且需要前面所有的元素都处理完成后才会处理前面的数据.- 比如每个线程处理的任务重要性不同, 我们可以通过优先级的大小, 来决定该线程在队列中被处理的次序.- 比较完成后, 可以得出这个元素正确的队列中的位置. 其他处理方式, 和队列的处理方式一样.一旦优先级, 大于某个元素, 就将该元素插入到元素这个元素的位置. 其他元素会依次向后移动.- `dequeue()`：移除队列的第一（即排在队列最前面的）项，并返回被移除的元素。
数据结构-----栈和队列的一些面试题
Z_JUAN1的博客
07-04 382
一、实现一个栈，要求实现push、pop、min的时间复杂度为o(1)1.我们用一个栈实现，偶数下标放的是普通的数据，奇数下标放的是最小数据push:普通（偶数下标）的数据就正常放，奇数下标：当我们要放的数据大于最小值，那么我们就要更新我们的最小值，在放进去。2.我们用两个栈实现，一个栈里面放正常数据，另一个放最小数据push：正常栈就是就正常放，当最小栈为空的时候，就直接放，不为空的时候就要进行...
数据结构——栈（栈结构、栈面试题、栈的操作、栈结构实现、进制的转换）
qq_52301431的博客
08-22 569
因为我们使用的是数组来作为栈的底层实现的, 所以直接获取数组的长度即可.(也可以使用链表作为栈的顶层实现)- 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；- `peek()`：返回栈顶的元素，不对栈做任何修改（这个方法不会移除栈顶的元素，仅仅返回它）。- 注意: 我们的实现是将最新的元素放在了数组的末尾, 那么数组末尾的元素就是我们的栈顶元素。- 从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
队列和栈面试题【数据结构】
czf的编程工坊
03-18 296
1.实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1)。 2.使用两个栈实现一个队列 3.使用两个队列实现一个栈 4.元素出栈、入栈顺序的合法性。
[数据结构]栈和队列面试题解析
qq_59456417的博客
11-16 968
栈和队列面试题解析
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个节点并返回。
CDatreides的博客
08-17 1868
/* struct TreeLinkNode { int val; struct TreeLinkNode *left; struct TreeLinkNode *right; struct TreeLinkNode *next; TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(...
输入一个数组，判断该数组是不是二叉搜索树的后序遍历的结果。
CDatreides的博客
08-15 1268
解题思路：首先，我们应该对二叉搜索树有所了解。 二叉搜索树：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 本题是利用递归思想，判断根节点的左子树...
静态数据表的实现
CDatreides的博客
06-16 998
代码实现顺序表的操作函数 // 值类型 typedef int DataType; typedef struct SeqList { DataType data; // 值 int size; // 数量 } SeqList; // 初始化 void SeqListInit(SeqList *pSL); // 尾部插入 void SeqListPushBack(SeqList *pSL, Data...
数据结构——二叉树面试题（2）
CDatreides的博客
08-07 926
#pragma once #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;assert.h&gt; typedef struct BSTreeNode { struct BSTreeNode * pLeft; // prev struct BSTreeNode * pRight; // next int d...
Given a binary tree, determine if it is a valid binary search tree (BST).
CDatreides的博客
08-24 553
思路：定义一个数组，按照中序输出的方式将值放入数组中，然后遍历比较，满足从小到大排列，则满足二叉搜索树。
Given a linked list, determine if it has a cycle in it. Follow up: Can you solve it without using ex
CDatreides的博客
08-10 352
题目为：Linked List Cycle Given a linked list, determine if it has a cycle in it. Follow up: Can you solve it without using extra space?   解法思想： 算法思想就是设置一个快指针fp和一个慢指针sp，两个指针起始同时指向head节点，其中快指针每次走两步，慢指针...
常见排序算法的整理
CDatreides的博客
11-17 343
一直以来对排序算法没有深刻的理解，只能简单的代码编写，因此今天抽出一些时间对以前排序的不足加以修改。 这里我们来探讨一下常用的比较排序算法，下表给出了常见比较排序算法的性能： 稳定性的判别：如果说排序前两个相等的数位置是a,b，排序后两个数仍然是a,b，则说明这个排序是稳定的。通俗来讲就是说：排序前后两个相等的数相对位置不发生改变。 冒泡排序： 1.比较相邻的元素，如果前者大于后者，则...
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
CDatreides的博客
08-17 300
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Sol...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值