stack and 队列

分为动态和静态

注意取栈顶和出栈的区别

typedef struct sqstack {
	int* base;//栈底指针
	int* top;//栈顶指针
 }sqstack;

栈的本质用数组实现

初始化就是把2个指针分别都指向数组头

要与链表一样考虑是否分配内存成功

bool initstack(sqstack&s) {//制造一个空栈
	s.base = new int[Maxsize];//分配空间
	if (!s.base) {
		return false;
	}
	s.top = s.base;
	return true;
}

入栈

要判定是否为满

注意栈顶指针一直指向尾元素的下一位置

bool push(sqstack& s,int e) {
	if (s.top - s.base == Maxsize) {
		cout << "满了" << endl;
		return false;
	}
	*(s.top++) = e;
	return true;
}

出栈要判空

bool pop(sqstack& s,int &e) {
	if (s.base == s.top) {
		cout << "empty" << endl;
		return false;
	}
	e = *(s.top--);
	return true;
}

int gettop(sqstack s) {
	if (s.top == s.base) {
		return -1;
	}
	return *(s.top-1);//注意此处必须先-1再输出否则会越界
}

（循环）队列

本质也是数组（用的多）

typedef struct sqqueue {
	int* base;//基地址
	int front, rear;//头指针，尾指针
};

初始化就是分配内存判是否分配成功 再指向数组 然后下标初始化0

bool initqueue(sqqueue& s) {
	s.base = new int[Maxsize];
	if (!s.base)
		return false;
	s.front = 0;
	s.rear = 0;
	return true;
}

添加元素

判满 注意条件（rear+1）%size==front ！！！

！！！注意2 循环链表有一个元素是空的

bool addsqqueue(sqqueue& s, int e) {
	if ((s.rear + 1) % Maxsize == s.front) {//此处注意由于s.rear指向的是最
		                                    //后一个元素的下一个元素所以是浪费了一个空间
		                                    //所以尾指针的下一元素是头指针的话就是循环链表满了
		return false;
	}
	s.base[s.rear] = e;//注意base是数组 rear是下标
	s.rear = (s.rear + 1) % Maxsize;//必须是这样不然会越界
	return true;
}

出队列

判空 条件为是否相等

bool popsqqueue(sqqueue& s, int& e) {
	if (s.front == s.rear) {
		return false;
	}
	e = s.base[s.front];
	s.front = (s.front + 1) % Maxsize;
	return true;
}

取数据

判空

int gethead(sqqueue& s) {
	if (s.rear == s.front)
		return -1;
	return s.base[s.front];//注意队列是出头
}

元素个数（rear-front+size）%size

int queuelength(sqqueue s) {
	return (s.rear - s.front + Maxsize) % Maxsize;
}