栈和队列面试题

最新推荐文章于 2025-01-13 19:42:41 发布
原创 最新推荐文章于 2025-01-13 19:42:41 发布 · 121 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Stack.h

#pragma once
#include <malloc.h>
#include <assert.h>
#include<stdio.h>
#include <stdlib.h>

typedef int STDataType;
#define DEFAULT_SZ 5

typedef struct STNode
{
	STDataType * data;
	struct Node* next;

}NODE, *PNODE;
typedef struct Stack
{
	STDataType * data;
	PNODE _top;		// 栈顶
	PNODE _end;    //栈底
	int _capacity;  // //栈的总大小 
	int _size;//当前栈的大小

}Stack;

void StackInit(Stack* ps);
void StackDestory(Stack* ps);

void StackPush(Stack* ps, STDataType x);
void StackPop(Stack* ps);
STDataType StackTop(Stack* ps);
int StackEmpty(Stack* ps);
int StackSize(Stack* ps);
void StackPrint(Stack *ps);

void TestStack();

Queue.h

#pragma once

#include <malloc.h>
#include <assert.h>
#include<stdio.h>
#include <stdlib.h>



typedef int QUDataType;
#define DEFAULT_SZ 5
typedef struct QueueNode
{
	struct QueueNode* _next;
	QUDataType _data;
}QueueNode, *pQueueNode;

typedef struct QUQueue
{
	QueueNode* _front; // 队头
	QueueNode* _back;  // 队尾
	int _size; //队列当前长度
	int _capacity; //队列总长度
	QUDataType _data;
}Queue, *pQueue;

void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);

QueueNode* BuyQueueNode(QUDataType );
void QueuePush(Queue* pq,QUDataType x);
void QueuePop(Queue* pq);
QUDataType QueueFront(Queue* pq);
QUDataType QueueBack(Queue* pq);
int QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

void TestQueue();

Topic.h

#pragma once

#include "Queue.h"
#include "Stack.h"


////////////////////////////////////////////////////////////////
// 1.两个栈实现一个队列
typedef struct QueueByTwoStack
{
	Stack s1;
	Stack s2;
}QueueByTwoStack;

void QueueByTwoStackInit(QueueByTwoStack* qts);
void QueueByTwoStackDestory(QueueByTwoStack* qts);

void QueueByTwoStackPush(QueueByTwoStack* qts, STDataType x);
void QueueByTwoStackPop(QueueByTwoStack* qts);
STDataType QueueByTwoStackFront(QueueByTwoStack* qts);

int QueueByTwoStackSize(QueueByTwoStack* qts);
int QueueByTwoStackEmpty(QueueByTwoStack* qts);

void TestQueueByTwoStack();

////////////////////////////////////////////////
// 2.两个队列实现一个栈

typedef struct StackByTwoQueue
{
	Queue q1;
	Queue q2;
}StackByTwoQueue;


void StackByTwoQueueInit(StackByTwoQueue* stq);
void StackByTwoQueueDestory(StackByTwoQueue* stq);
QUDataType StackByTwoQueueTop(StackByTwoQueue* stq);
int StackByTwoQueueEmpty(StackByTwoQueue* stq);
int StackByTwoQueueSize(StackByTwoQueue* stq);

void StackByTwoQueuePush(StackByTwoQueue* stq, QUDataType x);
void StackByTwoQueuePop(StackByTwoQueue* stq);

void TestStackByTwoQueue();

//////////////////////////////////////////////////////////////
// Min Stack

typedef int MSTDataType;

typedef struct MinStack
{
	Stack _st;
	Stack _minst;
}MinStack;

void MinStackInit(MinStack* pms);
void MinStackDestory(MinStack* pms);

void MinStackPush(MinStack* pms, MSTDataType x);
void MinStackPop(MinStack* pms);
MSTDataType MinStackMin(MinStack* pms);
void TestMinStack();

void TestIsLegalStackOrder();
//////////////////////////////////////////////////////
#define N 100
typedef int SSDataType;
typedef struct ShareStack
{
	SSDataType _a[N];
	int _top1;
	int _top2;
	int max_size;
}ShareStack;

void ShareStackInit(ShareStack* pss);
void ShareStackInit_01(ShareStack* pss);
void ShareStackPush1(ShareStack* pss, SSDataType x);//左边入栈
void ShareStackPush2(ShareStack* pss, SSDataType x);//右边入栈

// which 1、2
void ShareStackPush(ShareStack* pss, SSDataType x, int which);
void ShareStackPop(ShareStack* pss, int which);
SSDataType ShareStackTop(ShareStack* pss, int which);
void TestShareStack();

Stack.c


#include"Stack.h"



void StackInit(Stack* ps)
{
	assert(ps);
	ps->data = (STDataType *)malloc(sizeof(STDataType)* DEFAULT_SZ);
	ps->_capacity = DEFAULT_SZ;
	ps->_top = ps->_end;
	ps->_size = 0;

}
void StackDestory(Stack* ps)//销毁栈
{
	assert(ps);
	int i, len;
	len = ps->_size;
	if (ps->_top == ps->_end)
	{
		printf("栈为空，无法销毁\n");
		return;
	}
	else
	{
		for (i = 0; i < len; i++)
		{
			free(ps->_end);
			ps->_end++;
		}
		ps->_size = 0;
		ps->_capacity = 0;
		ps->_top = ps->_end = NULL;
	}
}
void StackPush(Stack* ps,STDataType x)
{
	PNODE newNode = (PNODE)malloc(sizeof(NODE));
	newNode->data = x;
	newNode->next = ps->_top;
	ps->_top = newNode;
}
void StackPop(Stack* ps)
{
	PNODE tmp = (PNODE)malloc(sizeof(NODE));
	assert(ps != NULL&&ps->_top != NULL&&ps->_end != NULL);
	tmp = ps->_top->next;
	free(ps->_top);
	ps->_top = NULL;
	ps->_top = tmp;
	ps->_size--;
}
STDataType StackTop(Stack* ps)
{
	assert(ps != NULL);
	return ps->_top - 1;
}
int StackEmpty(Stack* ps)
{
	assert(ps != NULL);
	if (ps->_top == ps->_end)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
int StackSize(Stack* ps)
{
	assert(ps != NULL);
	while (ps)
	{
		ps->_top++;
		ps->_size++;
	}
	return ps->_size;
	//return ps->_top;
}

void StackPrint(Stack *ps)
{
	PNODE tmp = ps->_top;
	while (tmp != ps->_end)
	{
		printf("%d", tmp->data);
		tmp = tmp->next;
	}
	printf("\n");
}

Queue.c

#include"Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq != NULL);
	pq->_front = pq->_back = (QUDataType*)malloc(sizeof(QUDataType)*DEFAULT_SZ);
	if (!pq->_front)
	{
		exit(0);
	}
	pq->_front->_next = NULL;
	pq->_size = 0;
	pq->_capacity = DEFAULT_SZ;
}
void QueueDestory(Queue* pq)
{
	assert(pq != NULL);
	if (pq == NULL)
	{
		printf("队列为空，无法销毁\n");
	}
	pQueueNode node = pq->_front;
	while (node)
	{
		pQueueNode cur = node->_next;
		free(node);
		node = cur;
	}
	pq->_front = pq->_back = NULL;
}

QueueNode* BuyQueueNode(QUDataType x)
{
	pQueueNode node = (pQueueNode)malloc(sizeof(QueueNode));
	node->_data = x;
	node->_next = NULL;
	return node;
}
void QueuePush(Queue* pq,QUDataType x)
{
	if(pq->_size == pq->_capacity)
	{
		QUDataType * ptr = NULL;
		ptr = (QUDataType *)realloc(pq->_data, sizeof(QUDataType)*(pq->_capacity) + 1);
		pq->_back->_data = x;
		pq->_back->_next = pq->_back;
	}
}
void QueuePop(Queue* pq)
{
	assert(pq != NULL);
	
	if (pq->_front == NULL)//空队列
	{
		pq->_front = pq->_back = NULL;
	}
	else
	{
		pQueueNode node;
		node = pq->_front->_next;
		free(pq->_front);
		pq->_front = node;
		if (node == NULL)
		{
			pq->_back =NULL;
		}
	}
}
QUDataType QueueBack(Queue* pq)
{
	assert(pq != NULL);
	return pq->_back->_data;
}
QUDataType QueueFront(Queue* pq)
{
	assert(pq != NULL);
	if (pq->_size == 0)
	{
		//printf("队列为空，无法取出\n");
		return 0;
	}
	return pq->_front->_data;
}
int QueueEmpty(Queue* pq)
{
	assert(pq != NULL);
	if (pq->_front == pq->_back)
	{
		
		return 1;
	}
	else
	{
		return 0;
	}
}
int QueueSize(Queue* pq)
{
	assert(pq != NULL);
	if (QueueEmpty(pq))
	{
		return 0;
	}
	else
	{
		return (pq->_back - pq->_front);
	}
}

Topic.c

#include"Queue.h"
#include"Stack.h"
#include"Topic.h"

////////////////////////////////////////////////////////////////
// 1.两个栈实现一个队列
void QueueByTwoStackInit(QueueByTwoStack* qts)
{
	StackEmpty(&qts->s1);
	StackEmpty(&qts->s2);
}
void QueueByTwoStackDestory(QueueByTwoStack* qts)

{
	StackDestory(&qts->s1);
	StackDestory(&qts->s2);
}

void QueueByTwoStackPush(QueueByTwoStack* qts, STDataType x)
{
	assert(qts != NULL);
	StackPush(&(qts->s1), x);
}
void QueueByTwoStackPop(QueueByTwoStack* qts)
{
	assert(qts != NULL);
	//如果s2有数据直接出
	//如果s2没有数据，就把s1的数据倒过来
	if (StackEmpty(&qts->s2) == 0)
	{
		while (StackEmpty(&qts->s1))
		{
			StackPush(&qts->s2, StackTop(&qts->s1));
			StackPop(&qts->s1);
		}
	}
}
STDataType QueueByTwoStackFront(QueueByTwoStack* qts)
{
	assert(qts != NULL);
	return StackTop(&qts->s2);
}
int QueueByTwoStackSize(QueueByTwoStack* qts)
{
	return StackSize(&qts->s1) + StackSize(&qts->s2);
}
int QueueByTwoStackEmpty(QueueByTwoStack* qts)
{

	return StackEmpty(&qts->s1);//StackEmpty(&qts->s2);
}

////////////////////////////////////////////////
// 2.两个队列实现一个栈
void StackByTwoQueueInit(StackByTwoQueue* stq)
{
	QueueInit(&stq->q1);
	QueueInit(&stq->q2);
}
void StackByTwoQueueDestory(StackByTwoQueue* stq)
{
	QueueDestory(&stq->q1);
	QueueDestory(&stq->q2);
}
QUDataType StackByTwoQueueTop(StackByTwoQueue* stq)
{
	if (QueueEmpty(&stq->q1))
	{
		return QueueBack(&stq->q1);
	}
	else
	{
		return QueueFront(&stq->q2);
	}
}
int StackByTwoQueueEmpty(StackByTwoQueue* stq)
{
	return QueueEmpty(&stq->q1)|QueueEmpty(&stq->q2);
}
int StackByTwoQueueSize(StackByTwoQueue* stq)
{
	return QueueSize(&stq->q1);
}

void StackByTwoQueuePush(StackByTwoQueue* stq, QUDataType x)
{
	assert(stq != NULL);
	if (QueueEmpty(&stq->q1) != 0)
	{
		QueuePush(&stq->q1, x);
	}
	else
	{
		QueuePush(&stq->q2, x);
	}
}
void StackByTwoQueuePop(StackByTwoQueue* stq)
{
	Queue* empty, *nonempty;
	assert(stq != NULL);
	empty = &stq->q1;
	nonempty = &stq->q2;
	if (QueueEmpty(&stq->q1) != 0)
	{
		empty = &stq->q2;
		nonempty = &stq->q1;
	}
	while (QueueSize(nonempty) > 1)
	{
		QueuePush(empty, QueueFront(nonempty));
		QueuePop(nonempty);
	}
	QueuePop(nonempty);
}

//////////////////////////////////////////////////////////////
// Min Stack
void MinStackInit(MinStack* pms)
{
	assert(pms != NULL);
	StackInit(&pms->_st);
	StackInit(&pms->_minst);
}
void MinStackDestory(MinStack* pms)
{
	assert(pms != NULL);
	StackDestory(&pms->_st);
	StackDestory(&pms->_minst);
}

void MinStackPush(MinStack* pms, MSTDataType x)
{
	assert(pms != NULL);
	StackPush(&pms->_st,x);
	if (StackEmpty(&pms->_minst) == 0
		||StackTop(&pms->_minst)>=x)
	{
		StackPush(&pms->_minst, x);
	}
}
void MinStackPop(MinStack* pms)
{
	assert(pms != NULL);
	if (StackTop(&pms->_st) == StackTop(&pms->_minst))
	{
		StackPop(&pms->_minst);
	}
		StackTop(&pms->_st);
}
MSTDataType MinStackMin(MinStack* pms)
{
	assert(pms != NULL);
	return StackTop(&pms->_minst);
}
//不合法 0
//合法 1
int IsLegalStackOrder(int* in, int* insize, int* out, int *outsize)
{
	assert(in&&out&&insize == outsize);
	Stack st;
	StackInit(&st);
	int inindex = 0;
	int outindex = 0;
	while (inindex < insize)
	{
		StackPush(&st, in[inindex]);
		++inindex;
		while(!StackEmpty(&st)
			&& StackTop(&st) == out[outindex])
		{
			StackPop(&st);
			++outindex;

		}
	}
	if (StackEmpty(&st) == 0)

	{
		return 1;
	}
	else
	{
		StackDestory(&st);
		return 0;
	}
}
//////////////////////////////////////////////////////
void ShareStackInit(ShareStack* pss)
{
	assert(pss != NULL);
	pss->_top1 = 0;
	pss->_top2 = 1;
}
void ShareStackInit_01(ShareStack* pss)
{
	assert(pss != NULL);
	pss->max_size = 10;
	pss->_top1 = 0;
	pss->_top2 = pss->max_size;

}
void ShareStackPush1(ShareStack* pss, SSDataType x)
{
	assert(pss != NULL);
	if (pss->_top1 == pss->_top2)
	{
		return;
	}
	pss->_a[pss->_top1] = x;
	pss->_top1++;
	return;
}

void ShareStackPush2(ShareStack* pss, SSDataType x)
{
	assert(pss != NULL);
	if (pss->_top1 == pss->_top2)
	{
		return;
	}
	pss->_top2--;
	pss->_a[pss->_top2] = x;
}


// which 1、2
void ShareStackPush(ShareStack* pss, SSDataType x, int which)
{
	assert(pss&&which==1||which==2);
	
	if (which == 1)
	{
		if (pss->_top1 >= N)
		{
			printf("Stack1 Full\n"); 
			return;
		}
			
		pss->_a[pss->_top1] = x;
		pss->_top1 += 2;
	}
	else if (which == 2)
	{
		if (pss->_top2 >= N)
		{
			printf("Stack2 Full\n");
			return;
		}
		pss->_a[pss->_top2] = x;
		pss->_top2 += 2;
	}

}
void ShareStackPop(ShareStack* pss, int which)
{
	assert(pss&&which == 1 || which == 2);
	if (which == 1)
	{
		if (0 == pss->_top1)
		{
			printf("栈1为空\n");
		}
		pss->_top1 -= 2;
	}
	else
	{
		if (0 == pss->_top2)
		{
			printf("栈2为空\n");
		}
		pss->_top2 -= 2;
	}
}
SSDataType ShareStackTop(ShareStack* pss, int which)
{
	assert(pss&&which == 1 || which == 2);
	if (which == 1)
	{
		return pss->_a[pss->_top1 - 1];
	}
	else
	{
		return pss->_a[pss->_top2 - 1];
	}
}

test.c

#include"Queue.h"
#include"Stack.h"
#include"Topic.h"
void TestQueueByTwoStack()
{
	QueueByTwoStack qts;
	QueueByTwoStackInit(&qts);
	QueueByTwoStackPush(&qts, 1);
	QueueByTwoStackPush(&qts, 2);
	QueueByTwoStackPush(&qts, 3);
	
	QueueByTwoStackPop(&qts);
	QueueByTwoStackPop(&qts);
	QueueByTwoStackPush(&qts, 4);
	QueueByTwoStackPush(&qts, 5);
	while (QueueByTwoStackEmpty(&qts))
	{
		printf("%d", QueueByTwoStackFront(&qts));
		QueueByTwoStackPop(&qts);
	}
	printf("\n");
}
void TestStackByTwoQueue()
{
	StackByTwoQueue stq;
	StackByTwoQueueInit(&stq);
	StackByTwoQueuePush(&stq, 1);
	StackByTwoQueuePush(&stq, 2);
	StackByTwoQueuePush(&stq, 3);
	StackByTwoQueuePush(&stq, 4);
	while (StackByTwoQueueEmpty(&stq))
	{
		printf("%d", StackByTwoQueueTop(&stq));
		StackByTwoQueuePop(&stq);
	}
	printf("\n");
}
void TestMinStack()
{
	MinStack mst;
	MinStackInit(&mst);
	MinStackPush(&mst,1);
	MinStackPush(&mst, 4);
	MinStackPush(&mst, 0);
	MinStackPush(&mst, 0);
	MinStackPush(&mst, 8);
	MinStackPush(&mst, 0);
	printf("min:%d\n", MinStackMin(&mst));
	MinStackPop(&mst);
	printf("min:%d\n", MinStackMin(&mst));
	MinStackPop(&mst);
	printf("min:%d\n", MinStackMin(&mst));
	MinStackPop(&mst);
	printf("min:%d\n", MinStackMin(&mst));
	MinStackPop(&mst);
	
	MinStackDestory(&mst);

}
void TestIsLegalStackOrder()
{
	int in[5] = { 1, 2, 3, 4, 5 };
	int out[5] = { 4, 5, 3, 2, 1 };
	printf("%d\n",IsLegalStackOrder(in,5,out,5));
}
void TestShareStack()
{

		ShareStack pss;
		ShareStackInit(&pss);
		ShareStackPush(&pss, 0, 1);
		ShareStackPush(&pss, 2, 1);
		ShareStackPush(&pss, 4, 1);
		ShareStackPush(&pss, 6, 1);
		ShareStackPush(&pss, 8, 1);
		ShareStackPush(&pss, 1, 2);
		ShareStackPush(&pss, 3, 2);
		ShareStackPush(&pss, 5, 2);
		ShareStackPush(&pss, 7, 2);
		printf("%d", ShareStackTop(&pss, 1));
		printf("%d", ShareStackTop(&pss, 2));

}
int main()
{
	//TestQueueByTwoStack();
	//TestStackByTwoQueue();
	//TestMinStack();
	//TestIsLegalStackOrder();
	void TestShareStack();
	system("pause");
	return;
}

 

栈和队列经典面试题详解
A13569039691的博客
05-15 1408
栈和队列经典面试题详解
哈希函数--开放定址法
qq_41268108的博客
09-12 1234
哈希概念 顺序搜索以及二叉树搜索树中，元素存储位置和元素各关键码之间没有对应的关系，因此在查找一个元素时，必须要经过关键码得多次比较。搜索的效率取决于搜索过程中元素的比较次数。 理想搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数（hashFunc）使元素的存储位置与他的关键码之间能够建立一一映射的关系，那么在查找时通该函数可以很快找到该元素...
7-1 银行业务队列简单模拟 （25 分)(数据结构_queue)
热门推荐
qq1263152915菜鸟小波的博客
03-21 1万+
题目描述 设某银行有A、B两个业务窗口，且处理业务的速度不一样，其中A窗口处理速度是B窗口的2倍 —— 即当A窗口每处理完2个顾客时，B窗口处理完1个顾客。给定到达银行的顾客序列，请按业务完成的顺序输出顾客序列。假定不考虑顾客先后到达的时间间隔，并且当不同窗口同时处理完2个顾客时，A窗口顾客优先输出。 输入格式: 输入为一行正整数，其中第1个数字N(≤1000)为顾客总数，后面跟着N位顾客的编号。...
【数据结构】栈和队列面试题总结(持续更新中...)
weixin_44258092的博客
08-09 957
介绍了栈和队列相关的OJ题目。
栈和队列经典面试题
bit_zyx的博客
04-07 3304
目录 1、括号匹配问题 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 1、括号匹配问题 链接直达： 有效的括号 题目： 思路： 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 ...
栈和队列高频面试题
2021dragon的博客
04-22 1687
题目一：括号匹配问题 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 1.左括号必须用相同类型的右括号闭合。 2.左括号必须以正确的顺序闭合。（题目来源） 题目二：用队列实现栈 题目三：用栈实现队列 题目四：设计循环队列 ...
详解栈和队列面试题(C语言版)，含动图和思路分析
iwkxi的博客
03-27 2824
文章目录1.栈和队列面试题1.1[括号匹配问题](https://leetcode-cn.com/problems/valid-parentheses/)1.2. [用队列实现栈](https://leetcode-cn.com/problems/implement-stack-using-queues/) 1.栈和队列面试题 1.1括号匹配问题 //C语言实现栈 typedef char STDataType; typedef struct Stack { STDataType* a; int t
（C语言版）力扣（LeetCode）栈和队列面试题
立志做一个高产且细节博主
05-13 1579
20. 有效的括号 解法一：建立栈解决 解法二：数组模拟栈解决 225. 用队列实现栈 解法：两个队列实现栈 232. 用栈实现队列 解法：两个栈实现队列 622. 设计循环队列
（C语言）数据结构之栈和队列面试题
博主qq1077644249
08-11 1031
下一次想出栈的时候就再倒一次，也就是把q2的前n-1个元素出队并入队到q1，然后q2把剩下的那个元素出队即可，此时q2为空下一次再入栈的时候，也就不用管q1还是q2，就直接谁有元素就往谁的里面入队元素即可。每次入队的时候先要判断当先队列是否是满的，不为满，让back当前位置赋值要入队的元素，然后back正常++往后走，关键的来了再进行back=back %（k+1）操作即可实现循环。为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。...
【栈和队列】常见面试题
Yui_的博客
08-08 1418
一些常见栈和队列面试题讲解
Java-数据结构-栈与队列(常考面试题与单调栈)
最新发布
爱是小小的癌的博客
01-13 2551
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
3栈和队列面试题精讲.ppt
07-31
3栈和队列面试题精讲
各种排序算法的实现
qq_41268108的博客
10-20 847
  插入排序 基本思想：每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好的序的一组元素的合适的位置上去，直到元素全部插完为止。 1.直接插入排序 基本思想：  当插入第i个元素时，前面的array[0]、array[1]、array[2]……array[i-1]已经排好序，此时用array[i]的排序码与array[i-1]、array[i-2]……的排序码进行比较，找到插入...
数据结构--顺序表
qq_41268108的博客
07-05 316
//初始化void InitSeqList(PSeqList pSeq);//尾部插入void PushBack(PSeqList pSeq, DataType data);//尾部删除void PopBack(PSeqList pSeq);//头部插入void PushFront(PSeqList pSeq, DataType data);//头部删除void PopFront(PSeqList...
C_链表基本接口的实现
qq_41268108的博客
07-14 302
plist.h#ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include &lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;assert.h&gt; typedef int DataType; typedef struct Node { DataType data; struct N...
栈和队列的实现
qq_41268108的博客
08-14 294
栈 Stack.h #pragma once #include &lt;malloc.h&gt; #include &lt;assert.h&gt; #include&lt;stdio.h&gt; #include &lt;stdlib.h&gt; #pragma once #ifndef __STACK_H__ #define __STACK_H__ //#pragma once #in...
二叉树相关接口
qq_41268108的博客
08-22 252
#pragma once #include &quot;Stack.h&quot; #include &quot;Queue.h&quot; #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;assert.h&gt; #include &lt;stdlib.h&gt; typedef char BTDataType; //孩子兄弟表示法：表示出每一个结点的第...
双向链表的基本实现
qq_41268108的博客
08-22 203
list.h #pragma once #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h&gt; typedef int LTDataType; typedef struct ListNode { struct ListNode* _next; struct ListNode* _prev; L...
栈与队列面试题解析：从基础到高级应用
&quot;3栈和队列面试题精讲.ppt&quot; 这篇内容主要讲解了与栈和队列相关的面试题目，并提供了详细的解题思路。栈和队列是两种基础且重要的线性数据结构，它们在算法和数据结构领域扮演着至关重要的角色。 线性表是一种简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值