栈与队列的基本操作

#include"stack.h"

int main()
{
	stacktest();
	//testQueue();
	system("pause");
	return 0;
}
#pragma once 

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


typedef int DataType;
typedef struct Stack1{
	DataType array[100];
	int top;

}  Stack1;



typedef struct Stack{
	DataType array[100];
	int top;
	int top1;

}  Stack;

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

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

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

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

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

// 返回数据个数 
int StackSize(Stack *pStack);
//取最小值
int stackMin(Stack *pStack);

//两个栈实现队列
void StackPush1(Stack *pStack1, Stack *pStack2, DataType data);


// 初始化 
void StackInit(Stack1 *pStack)
{
	assert(pStack);
	pStack->top = 0;
	//pStack->top1 = 1;

}
//压栈
void StackPush2(Stack1 *pStack, DataType data)
{
	assert(pStack);
	pStack->array[pStack->top] = data;
	pStack->top++;

}
void StackPop(Stack1 *pStack)
{
	assert(pStack);
	pStack->top--;
}

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

// 判断是否为空 
// 1 空 
// 0 不空 
int StackIsEmpty(Stack *pStack)
{
	assert(pStack);
	if (pStack->top == 0){
		return 1;
	}
	else{
		return 0;
	}
}
//返回数据个数
int StackSize(Stack *pStack)
{
	assert(pStack);
	return pStack->top;
}
#pragma once 

#include<stdlib.h>
#include<stdio.h>
#include<windows.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);

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

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

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

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

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





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

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

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

	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)
{
	assert(pQueue);
	if (pQueue->size == 0){
		return 1;
	}
	return 0;
}

// 返回数据个数 
int QueueSize(Queue *pQueue)
{
	assert(pQueue);
	return pQueue->size;
}

void testQueue()
{
	Queue	queue;

	QueueInit(&queue);

	QueuePush(&queue, 1);
	QueuePush(&queue, 2);
	QueuePush(&queue, 3);
	QueuePush(&queue, 4);

	
	system("pause");
}