简述堆栈的存取点写出栈 *** 作指令

在计算机领域，堆栈是一个不容忽视的概念，但是很多人甚至是计算机专业的人也没有明确堆栈其实是两种数据结构。堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。要点芦橘：堆，顺序随意。栈，后进先出(Last-In/First-Out)。

单片机堆栈 *** 作腊哗猛指令如下：

PUSH

direct（堆栈指令）其作用是先将栈指针SP的内容加1，然后将直接寻址单元中的数压入到sP所指的单元中。若数据已入栈，则SP指向最后堆人数据所在的存储单元（即指向栈顶）。

POP

direct（出栈指令）其作用是先将栈指针SP所指出单元的内容送入直接寻址单元中，然后将栈指针SP的内容减1，此时SP指向新的栈顶。

使用堆栈时，一般需设定SP的初始值。堆栈原则上可以设在内部RAM的任意区域，但为使用方便，一般设在30H～7FH。另外，需注意留出足轮桥够的存储单元作栈区，否则可能发生数据重叠，引起程序混乱。

由于入栈的第一个数必须存放在SP+1的存储单元，故实际栈顶是在SP+1所指出的单元。

// 接口类，命名随意

public interface Access

{

    // 插入方法

    void put(char c)

    

    // 取出方法

    char get()

}

// 子类继承接口实现具体的堆栈结构

public class Stack

    : Access

{

    // 用来存储字符串

    private char[] _chars

    

    // 用来栈顶计数

    private int top = 0

    

    // 构造函数

    public Stack()

    {

        _char = new char[2048]

    }

    

    // 实现接口方法put

    public void put(char c)

    {

        if(top>= 2048)

            throw new System.OverfloatException("栈已满！")

        _chars[top] = c

        top++ // 计数增加

    }

    

    // 实现接口方法get

    public char get()

    {

        if(top<=0)

            throw new System.NullEception("空栈")

        top--

        return _char[top]

    }

}

// 实现队列

public class Queue

    : Access

{

    // 存储数据

    private char[2048] _chars

    

    // 存储头指针

    private int frontin

    

    // 存储尾指针

    private int readout

    

    // 实现接口方法

    public void put(char c)

    {

        // 为了区分队列已满还是为空灶含，我们最多只允许存储2047个字符

        // 这样，两个数字相等时表示空队

        // 当frontin的下一个数字是readout时为满

        if((frontin+1)%2048 == readout)

            throw new System.OverfloatException("队列已满")

        _chars[frontin] = c

        frontin = frontin++%2048

    }

    // 实现方法

     public char get()

     敬唤{

         if(front == readout)

             throw new System.NullException("队列为空"亮辩凯)

         char tmp = _chars[readout]

         readout = readout++%2048

         return tmp

     }

}

// 其实吧，栈使用一个计数器，入栈时计数器增加，出栈时计数器减少。从而达到LIFO(后进先出，last in and first out)的效果。

// 队列使用的循环队列，要两个计数器，一个负责进，另一个负责出，如果超出容量时从头计数。这样通过数字形成一个循环使用的效果。

// 队列稍复杂的是，我们要区分队列满/空的情况。当然我们可以使用一个变量，或者永远少存一个，这样可以区分满空的情况即可。

// 虽然是循环，但是不可能超出容量！

// 这玩意吧，估计就是考查你们对LIFI（后进先出）及FIFO(先进先出）的理解情况。

// 当然，这样的东西在.net上只有练习做用，没有实质的用处——因为.net已经对大部分的结构实现了，比如Stack<T>就是泛型栈，而Queue<T>就是泛型队列，当然同时还有线程安全版本的结构！所以只要理解，这些代码其实一点用没有的。

#include <stdio.h>

#include <stdlib.h>缺物

#define MAX 1024///栈使用数组模拟，MAX是最大元素个数

typedef int DataType ///数据域使用整形

typedef struct _stack

{

DataType data[MAX]//悄扮高/存放数据

int top ///栈顶指针

}stack

///初始化

int initStack(stack (*s))

{

return emptyStack(s)

}

///数据压栈，成功返回1，失败返回0

int push(stack (*s), DataType d)

{

if ((*s).top >= MAX - 1) //栈已满

{

printf("栈已满，不能压栈\n")

return 0

}

//数据压栈

(*s).top++

(*s).data[(*s).top] = d

return 1

}

///数据出栈，成功返回1，d指向的区启尺域存储d出的数据，失败返回0

int pop(stack (*s), DataType *d)

{

if ((*s).top <= -1)

{

printf("栈为空，不能出栈\n")

return 0

}

//出栈

*d = (*s).data[(*s).top]

(*s).top--

return 1

}

///清空栈

int emptyStack(stack (*s))

{

(*s).top = -1

return 1

}

int main(int argc, char** argv)

{

stack s

int i, d

initStack(&s)

//压栈

for (i = 0i <1025i++)

{

push(&s, i)

}

//清空

emptyStack(&s)

for (i = 0i <10i++)

{

push(&s, i)

}

//出栈

for (i = 0i <11i++)

{

pop(&s, &d)

printf("%d\n", d)

}

return 0

}

---