Class implementation of linear stack and linear queue (another binary tree pointer version)

Class implementation of stack and queue （ Instead of STL）

distinguish
1. expression ：count++—— operation ： to count+1—— Value of expression ：count The value of the original （ Not added 1 Previous value ）
2. expression ：++count —— operation ： to count+1—— Value of expression ：count Add 1 Later value

1. Stack

Linear stack

// Linear stack  
class stack {
    
public:
//1. Pressing stack 
 void Push(int m) {
    
  data[top++] = m;// Assign values first and then ++
 }
 
//2. Pop up top element 
 int Pop() {
    
  return data[--top];// First -- To assign a value 
  // If you don't need to return   direct top-1  Return type int Change it to void
 }

//3. Initialization of stack  
 void InitStack() {
    
  top = 0;
 }

//4. Sentenced to empty 
 bool Empty() {
    
  if (top == 0) return true;
  return false;
 }
 
 //5. Take the top element of the stack but don't delete 
 int Top(){
    
 return data[top-1];//！！！ Note that there ！！！
 }
 
private:
 int top;// Top pointer of stack （ Point to the element to be put , This can be changed by yourself ）
 int data[1000];// The static array is put on the stack 
};

Stack for storing binary tree pointers

// Put the linear stack of binary tree nodes 
class stack{
    
public:
	//1. initialization  
	void InitStack(){
    
		top = 0;
	}
	
	//2. Binary tree pointer stack  
	void Push(TreeNode *p){
    
		stack[top++] = p;
	}
	
	//3. Bomb stack  
    void Pop(){
    
        top--; 
    }
	
	//4. Sentenced to empty  
	bool Empty() {
    
  		if (top == 0)return true;
 		 return false;
    }
    
    //5. Take the top element of the stack  
    TreeNode* Top( ){
    
        return stack[top-1];
    }
    
private:
	int top;
	TreeNode *stack[512];
		
}; 

2. queue

The pointer settings of the head and tail of the queue in the code below
front— Point to the team header element
rear— Point to the last position of the tail element （ The next place to insert ）

Linear queue

// Linear queue 
class Queue {
    
public:
	//1. Initialization function  
	void InitQueue( ) {
    
		rear = front = 0;
	}
	
	//2. Determines if the queue is empty  （ Not too serious ）
	bool QueueEmpty() {
    
		if (rear == front) return true; // If it's empty, return to true
		else return false;
	}

	//3. The team 
	bool EnQueue(int e) {
    
		if (rear == MAXSIZE) return false;// This sentence must have a meaning ！ Or the array is out of bounds ！（ Array range MAXSIZE-1）
		data[rear++] = e;
		return true;
	}

	//4. Out of the team   Direct output version 
	int DeQueue() {
    // Out of the team is the top of the team 
		if (rear == front)  return false;
		int x = data[front++];
		return x;
	}
	
	//4.5 Out of the team   Only out of the team without output 
	void PopQueue(){
    
		front = front + 1;// Note that there ！ 
	}
	
	//5. Take the team leader element （ Return to the first element ）
	TreeNode* Front(){
    
		return data[front];   
	}

private:
	int front, rear;
	int data[MAXSIZE];

};

A queue for storing binary tree pointers

// Put the queue of binary tree nodes  
class Queue {
    
public:
	//1. Initialization function  
	void InitQueue( ) {
    
		rear = front = 0;
	}
	
	//2. Determines if the queue is empty 
	bool Empty() {
    
		if (rear == front) return true; // If it's empty, return to true  Not absolutely ！
		else return false;
	}

	//3. The team 
	bool Push(TreeNode* e) {
    
		if (rear == MAXSIZE) return false;// There has to be   Otherwise, the array will be out of bounds ！
		data[rear++] = e;
		return true;
	}
	
	//4. Delete team leader element 
	void Pop(){
    
		front = front + 1;// Note that there ！ rear front Are increasing backwards 
	}
	
	//5. Return to the first element 
	TreeNode* Front(){
    // An array ？
		return data[front]; 
	} 

private:
	int front, rear;// Pointer to a party — Point to the last position of the tail element   Team head pointer — Point to the team header element  
	TreeNode* data[MAXSIZE];// It stores pointers instead of nodes ！ Don't save the whole node 

};