因为有时候上位机处理不及时，MCU需要缓冲一些数据，我自己琢磨着怎么做这个，所以用代码实现了如下；
 
/********************************************************
 函数原型：
 函数功能：堆栈初始化
 输入参数：
 输出参数：
 说    明：
 *********************************************************/
 #define StackSize 8
 unsigned char StackTemp[StackSize];
 
 
 void StackInitinal(void)
 {
 u8 Num;
 
 for(Num =0; Num <StackSize; Num++)
 {
 StackTemp[Num] =0;
 }
 }
 
 
/********************************************************
 函数原型：
 函数功能：事件堆栈
 输入参数：
 输出参数：
 说    明：
 *********************************************************/
 void PushINStack(unsigned char Event) //压栈
 { 
 unsigned char PushINSta =0, Num =StackSize, NullNumber =0;       
 
 if(Event ==0)    
 {
 return; 
 }
 while(Num--)  //查询开始    
 {
 if(StackTemp[Num] ==Event) //查询是否有一致的       
 {            
 PushINSta =2;            
 break;        
 }        
 else if(StackTemp[Num] ==0) //位置是否为空        
 { 
 NullNumber =Num; //记录空的位置            
 PushINSta =1;        
 }    
 }    
 if(PushINSta==1)    
 { 
 PushINSta =0;  
 StackTemp[NullNumber] =Event; //事件存入空的位置        
 }    
 else if(StackTemp[StackSize-1] !=0)    
 { 
 if(PushINSta ==0)        
 { 
 StackTemp[StackSize-1] =Event; 
 return;        
 }    
 }
 }
 
 
/********************************************************
 函数原型：
 函数功能：事件出栈
 输入参数：
 输出参数：
 说    明：
 *********************************************************/
 unsigned char PushOUTStack(void) //出栈
 { 
 unsigned char Num =0, Push =0, temp =0, temp2 =0;   
 
 if(StackTemp[Num] !=0) //第0个寄存器内有数据    
 { 
 temp =StackTemp[Num];        
 StackTemp[Num] =0;        
 Push =1;        
 }    
 if(Push ==1)  //整理压栈数据    
 { 
 while(Push ==1)        
 { 
 temp2 =Num+1;            
 if(temp2 <(StackSize))            
 { 
 StackTemp[Num] = StackTemp[temp2]; 
 StackTemp[temp2] =0;            
 }            
 else            
 { 
 Push =0;            
 }            
 Num =temp2;        
 }    
 }    
 return temp;
 }
 
 

 
 
应用的时候，
 
...
 
PushINStack(Event ); //存入事件栈
 
 
...
 
temp =PushOUTStack(); //提取数组内最前面的数；
 

1.自定义Node.java实体类：
 
package data_table.syn.com.common.util;
 /**
  * 简单封装Node节点
  * @author Administrator
  *
  */
 public class Node {
 
 private Object value;// 值
 private Node next; // 下一个对象的地址值
 public Object getValue() {
 return value;
 }
 public void setValue(Object value) {
 this.value = value;
 }
 
 public Node getNext() {
 return next;
 }
 public void setNext(Node next) {
 this.next = next;
 }
 public Node() {
 super();
 // TODO Auto-generated constructor stub
 }
 public Node(Object value) {
 super();
 this.value = value;
 }
 
 
 
 }
 
 
2.数组实现队列先进先出的数据结构：
 
package data_table.syn.com.common.util;
 /**
  * 数组实现队列结构，先进先出
  * @author Administrator
  *
  */
 public class QueueByArray {
 private int size=0;
 private Object[] que=new Object[8];
 
 public int size() {
 return size;
 }
 /**
 * 进队列
 * @param object
 */
 public void enQue(Object value) {
 if (size>=que.length) {
 Object[] stemp=new Object[que.length*2];
 for(int i=0;i<que.length;i++) {
 stemp[i]=que[i];
 
 }
 que=stemp;
 }else {
 
 que[size]=value;
 }
 
 size++;
 }
 /**
 * 出队列
 * @return
 */
 public Object deQue() {
 if(size<=0) {
 throw new ArrayIndexOutOfBoundsException();
 }
 
 Object value=que[0]; // 取出第一个存储的值
 que[0]=null;
 if (size>1) {
 for(int i=1;i<size;i++) {
 que[i-1]=que[i];
 
 }
 }
 size--;
 return value;
 }
 
 
 }
 
 
3.单链表实现队列的先进先出的数据结构：
 
package data_table.syn.com.common.util;
 /**
  * 但链条实现队列结构，先进先出
  * @author Administrator
  *
  */
 public class QueueByLink {
 private int size=0;
 private Node head=null;
 //private Node behind=null;
 
 public int size() {
 return this.size;
 }
 /**
 * 进队列
 * @param object
 */
 public void enQue(Object value) {
 Node newNode=new Node(value);
 if (head==null) {
 head=newNode;
 }else {
 /*if (behind==null) { //第二节点
 Node temp=head;
 while (temp.getNext()!=null) {
 temp=temp.getNext();
 }
 temp.setNext(newNode);
 behind=temp;
 }else { // 多个节点
 behind.setNext(newNode);
 behind=behind.getNext();
 }*/
 Node temp=head;
 while (temp.getNext()!=null) {
 temp=temp.getNext();
 }
 temp.setNext(newNode);
 
 }
 size++;
 
 }
 /**
 * 出队列
 * @return
 */
 public Object deQue() {
 if (size<=0) {
 throw new ArrayIndexOutOfBoundsException();
 }
 Object value=head.getValue();
 if (size==1) {
 head=null;
 return value;
 }
 head=head.getNext(); // 将头付给它的下一个节点
 return value;
 }
 
 
 }
 
 
4.比较性能：
 
 
 a1)数组进队列：当存储在数组的长度内，数组直接拿到数组的size,可以直接存值，当存值超出数组的长度，数组需要扩容，性能消耗较大。
 
 a2)链条进队列：遍历整个链条，取到最后的node节点，存值。
 
 比较：当存值一定，数组进队列要比链条性能好的多。当存值不定时，性能数组稍差，综合考虑，数组进队列稍胜一筹。
 
 b1)数组出队列：拿到数组的第一个值出队列，然后将数组其他的元素向前移动，性能较差。数据越大，性能越差。
 
 b2)链条出队列：拿到head节点出队列，将他的下一个节点赋值为head节点，效率非常高。
 
 比较：链条远胜于数组
 综合比较：数组与但链条实现队列不分胜负。 
注意:单针对我自己实现的基础上。可以优化。
 

 
 

 

JavaScript模拟实现先进先出、先进后出效果
 JavaScript模拟实现先进先出、先进后出效果

一：图形分析
 
 
二：思路分析
 
1. 定义一个top来表示入栈的数量（栈顶），当添加一个数据时top会指向新添加的数据；
2. 设置top = -1；（初始值）默认栈为空，当 top == stack.size() 时表示栈满；
3. 定义一个数组 stack 模拟栈，保存需要入栈的值；
4. 入栈：接收一个值，将值保存到 stack 中，并将 top 的位置上移 ；
5. 出栈：将栈顶top的值取出，并将top下移，重新标记栈顶的位置；
 
三：实现代码
 
//定义一个 ArrayStack 表示栈结构
class ArrayStack {
	private int maxSize; // 栈的大小
	private int[] stack; // 数组，模拟一个栈，用于存放
	private int top = -1; // 表示栈顶，初始为-1

	public ArrayStack(int maxSize) {
		this.maxSize = maxSize;
		stack = new int[this.maxSize];
	}

	// 栈满
	public boolean isFull() {
		return top == maxSize - 1;
	}

	// 栈空
	public boolean isEmpty() {
		return top == -1;
	}

	// 入栈
	public void push(int value) {
		// 判断是否栈满
		if (isFull()) {
			System.out.println("栈满~~");
			return;
		}
		top++;
		stack[top] = value;
	}

	// 出栈-将栈顶的数据返回
	public int pop() {
		// 判断是否栈空
		if (isEmpty()) {
			throw new RuntimeException("栈空，没有数据~~");
		}
		int value = stack[top];
		top--;
		return value;
	}

	// 显示栈中的数据-从栈顶开始显示
	public void list() {
		// 判断是否栈空
		if (isEmpty()) {
			System.out.println("栈空~~");
			return;
		}
		//从栈顶开始展示数据
		for (int i = top; i >= 0; i--) {
			System.out.printf("stack[%d]=%d\n", i, stack[i]);
		}

	}
}