使用数组实现栈和队列

一、数组实现栈：

1、使用一个类实现，该类私有成员有m_top、m_size、m_buffer 分别表示数组中栈顶位置、数组初始空间大小、指向该数组的指针。

2、该类的成员函数包括：isEmpty、isFull、push、pop、top、clearStack、stackLength

3、实现思路：

1、构造函数：初始化数组大小，m_top指向0位置，每次push元素都直接装进m_Top位置，然后该位置++

ArrayStack::ArrayStack(int size) {
	m_Size = size;
	m_Buffer = new char[size];
	m_Top = 0;
}

2、析构函数：释放数组空间，指针指向空

ArrayStack::~ArrayStack() {
	delete[] m_Buffer;
	m_Buffer = nullptr;
}

3、判断栈空：如果m_top<=0则为空，因为每次push之后m_top都会++，只要有元素入栈该位置就不为0

bool ArrayStack::isEmpty() {
	if (m_Top <= 0)//因为初始化m_Top位置为0，所以小于等于0为空
		return true;
	else
		return false;
}

4、判断栈满

bool ArrayStack::isFull(){
	if (m_Top >= m_Size)//如果大于等于m_Size为满了
		return true;
	else
		return false;
}

5、入栈：栈不满才执行入栈，入栈之后m_top++;

bool ArrayStack::push(char elem) {
	if (isFull()) {//入栈的时候判断是否为空
		return false;
	}
	m_Buffer[m_Top] = elem;//该位置元素设置为elem
	m_Top++;//然后位置++
	return true;
}

6、获取栈顶元素：注意栈顶元素为m_top-1位置，m_top指向不变

char ArrayStack::top() {
	assert(!isEmpty());//如果为空就报错，不能取出元素
	int temp = m_Top - 1;//注意取出元素是m_Top-1
	return m_Buffer[temp];
}

7：弹栈：栈不空才执行弹栈，弹栈实际上就是m_top--;

bool ArrayStack::pop() {
	if (isEmpty())
		return false;
	m_Top--;
	return true;
}

完整代码：

1、arrayStack.h

#pragma once

#ifndef ARRAY_SATCK_H
#define ARRAY_STACK_H
#include <iostream>
#include"arrayStack.h"

using namespace std;
class ArrayStack {
private:
	char* m_Buffer;
	int m_Size;
	int m_Top;
public:
	ArrayStack(int size);
	~ArrayStack();
	bool isEmpty();
	bool isFull();
	void clearStack();
	int stackLength();
	bool push(char elem);
	char top();
	bool pop();
};
#endif

2、arrayStack.cpp

#include "arrayStack.h"
#include<iostream>
#include<assert.h>

ArrayStack::ArrayStack(int size) {
	m_Size = size;
	m_Buffer = new char[size];
	m_Top = 0;
}
ArrayStack::~ArrayStack() {
	delete[] m_Buffer;
	m_Buffer = nullptr;
}
bool ArrayStack::isEmpty() {
	if (m_Top <= 0)//因为初始化m_Top位置为0，所以小于等于0为空
		return true;
	else
		return false;
}
bool ArrayStack::isFull(){
	if (m_Top >= m_Size)//如果大于等于m_Size为满了
		return true;
	else
		return false;
}
void ArrayStack::clearStack() {
	m_Top = 0;
}
int ArrayStack::stackLength() {
	return m_Top;
}
bool ArrayStack::push(char elem) {
	if (isFull()) {//入栈的时候判断是否为空
		return false;
	}
	m_Buffer[m_Top] = elem;//该位置元素设置为elem
	m_Top++;//然后位置++
	return true;
}
bool ArrayStack::pop() {
	if (isEmpty())
		return false;
	m_Top--;
	return true;
}
char ArrayStack::top() {
	assert(!isEmpty());//如果为空就报错，不能取出元素
	int temp = m_Top - 1;//注意取出元素是m_Top-1
	return m_Buffer[temp];
}

3、main.cpp

#include<iostream>
#include<string>
#include "arrayStack.h"
using namespace std;

int main() {
	ArrayStack* pstack = new ArrayStack(5);//创建一个拥有5个元素的数组
	pstack->push('h');
	pstack->push('e');
	pstack->push('l');
	pstack->push('l');
	pstack->push('o');
	while (!pstack->isEmpty()) {
		cout << "元素个数：" << pstack->stackLength()<<endl;
		char temp = pstack->top();
		cout << "当前元素：" << temp << endl;;
		pstack->pop();
	}
	cout << endl;
	while (1);
}

二、数组实现队列

和实现栈很像，也是通过维护位置来确定弹出压入顺序的，需要维护两个位置，一个指向堆首一个指向队尾

1、arrayQueue.h

#pragma once
#include<iostream>
using namespace std;

class ArrayQueue {
private:
	int m_Top;
	int m_Size;
	int m_Tail;
	int* m_Buffer;
public:
	ArrayQueue(int size);
	~ArrayQueue();
	bool isEmpty();
	bool isFull();
	bool push(int elem);//入队
	bool pop();//删除队首元素，但不返回其值
	int front();//获取对首元素
	int back();//获取队尾元素
	void clearQueue();
	int QueueLength();
};

2、arrayQueue.cpp

#include<iostream>
#include<assert.h>
#include "arrayQueue.h"
using namespace std;

ArrayQueue::ArrayQueue(int size) {
	m_Top = 0;
	m_Size = size;
	m_Tail = 0;
	m_Buffer = new int[size];
}
ArrayQueue::~ArrayQueue() {
	delete[] m_Buffer;
	m_Buffer = nullptr;
}
bool ArrayQueue::isEmpty() {
	if (m_Top==m_Tail)
		return true;
	return false;
}
bool ArrayQueue::isFull() {
	if (m_Tail>= m_Size)
		return true;
	return false;
}
int ArrayQueue::front() {
	assert(!isEmpty());
	return m_Buffer[m_Top];
}
int ArrayQueue::back() {
	assert(!isEmpty());
	return m_Buffer[m_Tail--];
}
bool ArrayQueue::push(int elem) {
	if (isFull()) return false;
	m_Buffer[m_Tail] = elem;
	m_Tail++;
}
bool ArrayQueue::pop() {
	if (isEmpty()) return false;
	m_Top++;
}
void ArrayQueue::clearQueue() {
	m_Top = 0;
	m_Tail = 0;
}
int ArrayQueue::QueueLength() {
	if (isEmpty()) return 0;
	return m_Tail - m_Top;//注意这个位置m_Tial已经指向下一个元素的位置
}

main.cpp

#include<iostream>
#include "arrayQueue.h"
using namespace std;

int main() {
	ArrayQueue* pQueue = new ArrayQueue(5);
	pQueue->push(1);
	pQueue->push(2);
	pQueue->push(3);
	pQueue->push(4);
	pQueue->push(5);
	while (!pQueue->isEmpty()) {
		cout <<"队列元素个数："<< pQueue->QueueLength() << endl;
		cout <<"出队元素："<< pQueue->front() << endl;
		pQueue->pop();
	}
}