精华内容
下载资源
问答
  • 及栈的应用

    2018-11-08 07:51:05
    及栈的应用 stack:称作栈或堆叠,其特殊之处只允许在链表或数组的一端(堆栈顶端)插入(push)数据,输出数据(pop) 其特点是先进后出 栈的实现 <!--链表实现--> import LinkedList from '../...

    栈及栈的应用

    • stack:称作栈或堆叠,其特殊之处只允许在链表或数组的一端(堆栈顶端)插入(push)数据,输出数据(pop)
    • 其特点是先进后出

    栈的实现

    <!--链表实现-->
    import LinkedList from '../linked-list/LinkedList';
    
    export default class Stack {
      constructor() {
        this.linkedList = new LinkedList();
      }
    
      /**
       * @return {boolean}
       */
      isEmpty() {
        return !this.linkedList.tail;
      }
    
      /**
       * @return {*}
       */
      peek() {
        if (!this.isEmpty()) {
          return null;
        }
        return this.linkedList.tail.value;
      }
    
      /**
       * @param {*} value
       */
      push(value) {
        this.linkedList.append(value);
      }
    
      /**
       * @return {*}
       */
      pop() {
        const tailNode = this.linkedList.deleteTail();
        return tailNode ? tailNode.value : null;
      }
    
      /**
       * @return {*[]}
       */
      toArray() {
        return this.linkedList
          .toArray()
          .map(linkedListNode => linkedListNode.value)
          .reverse();
      }
    
      /**
       * @param {function} [callback]
       * @return {string}
       */
      toString(callback) {
        return this.linkedList.toString(callback);
      }
    }
    
    复制代码

    应用

    1. 简单的四则元算
    import Stack from './Stack';
    export default class InToPost {
      constructor() {
        this.theStack = new Stack();
        this.output = [];
      }
    
      /**
       * 转换为后缀表达式
       */
      doTrans(str) {
        this.output = [];
        for (let i = 0, len = str.length; i < len; i++) {
          const ch = str.charAt(i);
          switch (ch) {
            case '+':
            case '-':
              this.getOper(ch, 1);
              break;
            case '*':
            case '/':
              this.getOper(ch, 2);
              break;
            case '(':
              this.theStack.push(ch);
              break;
            case ')':
              this.getParen();
              break;
            default:
              this.output.push(ch);
              break;
          }
        }
        while (!this.theStack.isEmpty()) {
          this.output.push(this.theStack.pop());
        }
        return this.output;
      }
    
      getOper(opThis, prec1) {
        while (!this.theStack.isEmpty()) {
          const opTop = this.theStack.pop();
          if (opTop === '(') {
            this.theStack.push(opTop);
            break;
          } else {
            let prec2 = 0;
            if (opTop === '+' || opTop === '-') {
              prec2 = 1;
            } else {
              prec2 = 2;
            }
            if (prec2 < prec1) {
              this.theStack.push(opTop);
              break;
            } else {
              this.output.push(opTop);
            }
          }
        }
        this.theStack.push(opThis);
      }
    
      getParen() {
        while (!this.theStack.isEmpty()) {
          const chx = this.theStack.pop();
          if (chx === '(') {
            break;
          } else {
            this.output.push(chx);
          }
        }
      }
    
      /**
       * 计算
       */
      calculation() {
        const caStack = new Stack();
        let num1 = 0;
        let num2 = 0;
        let ans = 0;
        let ch;
        for (let i = 0, len = this.output.length; i < len; i++) {
          ch = this.output[i];
          if (ch >= '0' && ch <= '9') {
            caStack.push(parseInt(ch));
          } else {
            num2 = caStack.pop();
            num1 = caStack.pop();
            switch (ch) {
              case '+':
                ans = num1 + num2;
                break;
              case '-':
                ans = num1 - num2;
                break;
              case '*':
                ans = num1 * num2;
                break;
              case '/':
                ans = num1 / num2;
                break;
              default:
                break;
            }
            caStack.push(ans);
          }
        }
        ans = caStack.pop();
        return ans;
      }
    }
    
    复制代码
    • 四则元算 目前仅支持10位以内计算
    1. 将中缀表达式3+2--->变为后缀表达式32+
    • (1)从左到右逐个扫描中缀表达式中的各项,如果到达末尾则跳转转到(6),否则根据(2)~(5)的描述进行操作;
    • (2)遇到操作数直接输出;
    • (3)遇到运算符(设为a),则和栈顶的操作符(设为b)比较优先级,若a小于等于b的优先级,则连续出栈输出,直到a大于b的优先级或b为(,a进栈;
    • (4)遇到(,进栈;
    • (5)遇到),则连续出栈输出,直到遇到左括弧(为止。其中,(出栈但是并不输出;
    • (6)输出栈中剩余的操作符。
    1. 计算后缀表达式的值,遇到数字压栈,遇到操作符取出数字计算结果,压栈,重复此过程至循环结束,取出数据即最后结果

    2. 分割符匹配

    import Stack from './Stack';
    
    export default class BracketChecker {
      constructor() {
        this.stack = new Stack();
      }
    
      check(str) {
        let isMatch = false;
        const map = new Map([
          ['{', '}'],
          ['[', ']'],
          ['(', ')']
        ]);
        const keys = [...map.keys()];
        const values = [...map.values()];
        for (let i = 0, len = str.length; i < len; i++) {
          const ch = str.charAt(i);
          if (keys.includes(ch)) {
            this.stack.push(ch);
          } else if (values.includes(ch)) {
            if (!this.stack.isEmpty()) {
              const chx = this.stack.pop();
              // 遇到)括号出栈,并从map里面找到)括号需要配对的(括号,相等则匹配成功
              const needKey = [...map.entries()].filter((el) => {
                return el[1] === ch;
              }).pop().shift();
              isMatch = needKey === chx;
            }
          }
        }
        return isMatch && this.stack.isEmpty();
      }
    }
    
    复制代码

    参考链接

    展开全文
  • 栈的主要特点及实例应用

    千次阅读 2016-10-05 10:06:40
    要注意是一端封闭,另一端开口数据存储结构,所以存时候就像是们盛饭时候,碗里饭是慢慢多到顶,取出来时候就像吃时候,慢慢到底。 这就是说 先入后出,或者说后入先出。 下面是实现结构...

    学习数据结构的知识,第一课便是栈结构。

    要注意栈是一端封闭,另一端开口的数据存储结构,所以存的时候就像是们盛饭的时候,碗里的饭是慢慢多到顶的,取出来的时候就像吃的时候,慢慢到底。

    这就是说 先入的后出,或者说后入先出。

    下面是实现栈结构的代码:

    //超超 
    //2016/10/5日
    #include <iostream>
    using namespace std;
    enum error_code{success,overflow,underflow,rangeerror};
    typedef int elementtype ;
    const int maxlen=15;
    class stack{
    public:
    stack();
    bool        isempty()const;
    bool         isfull() const;
    error_code         get_top(elementtype &x)const;
    error_code         push(const elementtype x);
    error_code         pop();
    private:
    int         count;
    elementtype       data[maxlen];
    }; 
    stack::stack(){ 
    count = 0; 
    }


    bool  stack::isempty()const{
    if ( count == 0 )       
    return true;
    else          
    return false;
    }
    bool stack::isfull()const{
    if ( count == maxlen ) 
    return true;
    else 
    return false;         
    }
    error_code stack::get_top(elementtype &x)const{
    if ( isempty() ) 
    return  underflow;
    else {
    x = data[count - 1];
    return success;
    }
    }
    error_code stack::push(const elementtype x){
    if(isfull()) 
           return overflow;
    else{
    data[count]=x;
    count++;
    return success;
    }
    }
    error_code stack::pop(){
    if(isempty()) 
    return underflow;
    else{
    count--;
    return success;
    }
    }

    使用的时候直接取栈结构来使用,熟悉进制转换的人都知道,在做进制转换的时候余数是从下往上读的,读完最下面的一位就是最高位;

    在栈结构中,最高位应该是最后出栈的,所以非常符合这个数据结构

    基于栈结构,下面是进制转换的实现代码:


    //num为要转化的数字 m为要转的进制
    void decimalism_other(int num ,int m){
    stack s;
    int x;
    while(num!=0){
    s.push(num%m);
    num=num/m;
    }
    while(!s.isempty()){
    s.get_top(x);
    s.pop();
    cout<<x;
    }
    cout<<endl;


    }


    int main(){
    decimalism_other(18,8);
        return 1;
    }

    相比那种不使用栈结构的取数运算来说,这样的一个结构明显减轻了很多的花费。

    作为程序员必须要掌握的一个结构

    展开全文
  • 栈的实现及应用

    2016-11-30 21:37:42
    定义、特点及其应用

    1.栈定义
    栈又称堆栈,是一种运算受限的线性表,限制是仅仅允许在表的另外一端进行插入和删除运算。
    2.特点
    后进先出、cpu缓存利用率相对较高、不允许随意访问
    3.实现方式
    栈有两种实现方式,一种是顺序存储,和数组类似。一种是链式存储,和单链表类似。
    (这是在2013编译器下)
    栈里面有以下几种函数:

    void Push(const T& x);
    void Pop();
    T& Top();
    bool Empty();
    size_t Size();

    栈函数定义和实现:

    template<class T>
    class Stack
    {
    public:
        Stack()//构造函数
            :_a(NULL)
            , _size(0)
            , _capacity(0)
        {}
        Stack(const Stack<T> & s)//拷贝构造函数
        {
            _capacity = s._capacity;
            _size = s._size;
            _a = new T[_capacity];
            for (size_t i = 0; i < _size; i++)//非内置类型例如String类型时,用for循环赋值
            {
                _a[i] = s._a[i];
            }
        }
        Stack<T>& operator=(const Stack<T> &s)//赋值运算符重载
        {
            if (_capacity < s._capacity)
            {
                _capacity = s._capacity;
                _a = new T[_capacity];
            }
            _size = s._size;
            for (size_t i = 0; i < _size; i++)
            {
                _a[i] = s._a[i];
            }
            return *this;
        }
        ~Stack()//析构函数
        {
            if (_a)
            {
                delete _a;
            }
        }
        //接口函数实现
        void Push(const T& x)//入栈,插入数据
        {
            _CheckCapacity();
            _a[_size++] = x;
        }
        void Pop()//删除数据
        {
            assert(_size);
            --_size;
        }
        T& Top()//返回栈顶元素
        {
            assert(_size);
            return _a[_size - 1];
        }
        bool Empty()//判空
        {
            return _a == 0;
        }
        size_t Size()//元素个数
        {
            return _size;
        }
    
    protected:
        void _CheckCapacity()//判断容量
        {
            if (_size >= _capacity)
            {
                T* tmp = new T[_capacity * 2 + 10];
                for (size_t i = 0; i < _size; i++)
                {
                    tmp[i] = _a[i];
                }
                delete _a;
                _a = tmp;
                _capacity = _capacity * 2 + 10;
            }
        }
    protected:
        T * _a;//存储数据的指针
        size_t _size;//存储数据个数
        size_t _capacity;//容量
    };

    测试函数:

    void TestStack()
    {
        Stack<int> s;
        s.Push(1);
        s.Push(2);
        s.Push(3);
        s.Push(4);
        cout << s.Size() << endl;
        s.Pop();
        cout << s.Size() << endl;
        cout << s.Empty() << endl;
        cout << s.Top() << endl;
    }

    结果:
    这里写图片描述

    关于栈的一个小应用,其中有一个后缀表达式的计算,也叫做逆波兰表达式,参加运算的操作数总在操作符前面。
    后缀表达式求值过程:顺序扫描表达式的每一项,如果该项是操作数,则将其压入栈中,如果是操作符,则从栈中退出两个操作数,形成运算指令,并将运算结果再压入栈中。
    下面简单的模拟实现一下后缀表达式:

    #include<iostream>
    using namespace std;
    #include<assert.h>
    #include <stack>  
    
    enum Type             
    {
        OP_SYMBOL,  //操作符   
        OP_NUM,     //操作数    
        ADD,
        SUB,
        MUL,
        DIV,
    };
    
    struct Cell      //cell单元存储里面的枚举类型和所push的操作数  
    {
        Type _type;
        int _value;
    };
    
    int CountPRN(Cell* rpn, size_t n)   
    {
        assert(rpn);
        stack<int> s;                        
        for (size_t i = 0; i < n; ++i)
        {
            if (rpn[i]._type == OP_NUM) //若数组中为操作数则压栈      
            {
                s.push(rpn[i]._value);        
            }
            else if (rpn[i]._type == OP_SYMBOL)//若为操作符则出栈运算
            {
                int right = s.top(); 
                s.pop();
                int left = s.top();
                s.pop();
                switch (rpn[i]._value)     
                {
                case ADD:
                    s.push(left + right);
                    break;
                case SUB:
                    s.push(left - right);
                    break;
                case MUL:
                    s.push(left * right);
                    break;
                case DIV:
                    s.push(left / right);
                    break;
                default:
                    assert(false);
                }
            }
        }
        return s.top();                               
    }
    void TestRPN()
    {
        Cell RPN[] = {
                        { OP_NUM, 8 },
                        { OP_NUM, 2 },
                        { OP_SYMBOL, MUL }
                    };
        cout << CountPRN(RPN, sizeof(RPN) / sizeof(RPN[0]));
    }
    
    int main()
    {
        TestRPN();
        system("pause");
        return 0;
    }

    结果:这里写图片描述

    展开全文
  • 下面这张图为栈的工作特点: 从数据存储的角度看,用JavaScript实现栈有两种方式,一种是以数组做基础,一种是以链表做基础,本节中,我们使用数组实现栈。链表会作为单独的数据结果进行介绍。 我们先定义一个简单...

    开始

    栈是一种特殊的线性表,仅能够在栈顶进行操作,有着先进后出的特性。下面这张图为栈的工作特点:
    栈的工作特点
    从数据存储的角度看,用JavaScript实现栈有两种方式,一种是以数组做基础,一种是以链表做基础,本节中,我们使用数组实现栈。链表会作为单独的数据结果进行介绍。

    我们先定义一个简单的Stack

    function Stack(){
    	var items = []; // 用数组存储数据
    }
    

    数据会存储在 items数组中,现在,这个类没有任何的方法。

    栈的方法

    栈的方法有以下几种

    • push 添加一个元素到栈顶
    • pop 弹出栈顶的元素
    • top返回栈顶的元素
    • isEmpty 判断栈是否为空
    • size返回栈里的元素个数
    • clear 清空栈

    下面我们来逐一实现这些方法。

    push 方法

    function Stack(){
    	var items = []; // 用数组存储数据
    	this.push = function(item){
    		items.push(item); // 压栈
    	}
    }
    

    pop方法

    function Stack(){
    	var items = []; // 用数组存储数据
    	this.push = function(item){
    		items.push(item); // 压栈
    	}
    	this.pop = function(){
    		return items.pop()
    	}
    }
    

    top方法

    function Stack(){
    	var items = []; // 用数组存储数据
    	this.push = function(item){
    		items.push(item); // 压栈
    	}
    	this.pop = function(){
    		return items.pop()
    	}
    	this.top = function(){
    		return items[items.length - 1];
    	}
    }
    

    isEmpty 方法

    function Stack(){
    	var items = []; // 用数组存储数据
    	this.push = function(item){
    		items.push(item); // 压栈
    	}
    	this.pop = function(){
    		return items.pop()
    	}
    	this.top = function(){
    		return items[items.length - 1];
    	}
    	this.isEmpty = function(){
    		return items.length === 0;
    	}
    }
    

    size 方法

    function Stack(){
    	var items = []; // 用数组存储数据
    	this.push = function(item){
    		items.push(item); // 压栈
    	}
    	this.pop = function(){
    		return items.pop()
    	}
    	this.top = function(){
    		return items[items.length - 1];
    	}
    	this.isEmpty = function(){
    		return items.length === 0;
    	}
    	this.size = function(){
    		return items.length;
    	}
    }
    

    clear 方法

    function Stack(){
    	var items = []; // 用数组存储数据
    	this.push = function(item){
    		items.push(item); // 压栈
    	}
    	this.pop = function(){
    		return items.pop()
    	}
    	this.top = function(){
    		return items[items.length - 1];
    	}
    	this.isEmpty = function(){
    		return items.length === 0;
    	}
    	this.size = function(){
    		return items.length;
    	}
    	this.clear = function(){
    		items = [];
    	}
    }
    

    我们使用var items = []的原因是,我们要将items封闭在类的内部,不能暴露出来。需要将items封装成似有属性。

    	function Stack(){
    		this.items = [];
    	}
    	var stack = new Stack();
    	// 可以直接通过实例修改类的属性。
    	stack.items.push(3);
    

    被欺骗的感觉

    看完上面的实现,读者可能会有一种被欺骗的感觉,传的那么神乎其神的数据结构,这里实现的栈,竟然只是对数组做了一层封装!

    请大家思考下面几个问题

    1. 我们可以通过索引操作数组的任意元素,但是这个栈,我们能操作任意元素吗?栈提供的方法只允许你操作栈顶的元素,也就是数组的最后一个元素,这种限制给了我们一种思考问题的方式。
    2. 既然栈的底层实现就是数组,栈能做的事情数组也可以一样做,为什么弄一个栈出来,是不是多此一举呢?其实,封装是为了隐藏实现的细节,在栈的角度思考问题会更为方便。

    栈的应用练习

    通过以下两个练习,我们能够更为清晰的明白,从栈的角度思考问题更为方便。

    合法括号

    题目要求

    下面的字符串中包含小括号,请编写一个函数判断字符串中的括号是否合法,所谓合法,就是括号成对出现。

    sdf(ds(ew(we)re)rwqw)qwrwq		合法
    (sd(qwqe)sd(sd))		合法
    ()()sd()(sd()dw))(		不合法
    
    思路分析

    括号存在嵌套关系,也存在并列关系,如果使用数组来存储这些括号,然后再想办法一对一的抵消掉,似乎可行。但是我们无法判断一个左括号对应的是哪一个右括号。在数组的角度思考这个问题,就有些困难。

    现在,我们使用栈来解决这个问题

    • 遇到左括号,就把做括号压入栈中
    • 遇到右括号,判断栈是否为空,如果为空则说明没有左括号与之相对应,字符串括号不合法。如果栈不为空,则把栈顶元素移除,这对括号就抵消了。
      for循环结束,如果栈是空的,说明所有的左右括号都抵消了,如果栈力还有元素,则说明缺少右括号,字符串括号不合法。
    示例代码
    function is_leagl_brackets(string){
    	var stack = new Stack();
    	for (var i = 0;i<string.length;i++) {
    		var item = string[i];
    		// 遇到做括号入栈
    		if(item == '('){
    			stack.push(item)
    		}else if (item == ')'){
    		// 遇到右括号,判断栈是否为空
    			if(stack.isEmpty()){
    				return false
    			}else {
    				stack.pop() // 弹出左括号
    			}
    		}
    	}
    	//  如果栈为空,说明字符串括号合法
    	return stack.isEmpty()
    }
    console.log(is_leagl_brackets('sdf(ds(ew(we)re)rwqw)qwrwq')) // true
    console.log(is_leagl_brackets('(sd(qwqe)sd(sd))')) // true
    console.log(is_leagl_brackets('()()sd()(sd()dw))(')) // false
    
    小结

    栈的底层是不是使用了数组并不重要,重要的是栈的这种后进先出的特性。重要的是你只能操作栈顶的元素的限制。一定要忽略栈的底层实现,而关心栈的特性。

    计算逆波兰表达式

    题目要求

    逆波兰表达式,也叫后缀表达式,它将复杂的表达式转换为可以依靠简单的操作得到计算结果的表达式。例如(a+b)*(c+d)转换成为ab+cd+*

    示🌰

    [“4”,“13”,'5','/','+'] 等价于 (4+(13/5)) = 6
    ['10','6','9','3','-11','*','/','*','17','+','5','+'] 等价于((10*(6/((9+3)*-11)))+17) + 5
    

    请编写函数calc_exp(exp)实现逆波兰表达式,其中exp的类型是数组。

    后缀变中缀
    [“4”,“13”,‘5’,’/’,’+’] --> [“4”,‘2’,’+’] --> 6

    思路分析

    [“4”,“13”,'5','/','+'] 就是一个数组,如果使用数组来解决这个问题,遇到/时,取出135进行计算,然后将这两者删除,把计算结果放到4的后面,书写算法会过于麻烦。

    如果是栈来解决这个问题,就会变得简单而自然。使用for循环遍历数组,对每一个数组元素进行如下操作

    • 如果元素不是 + - * /的其中一个,就压入栈中。
    • 如果元素是+ - * /中的一个,就从栈中连续弹出两个元素,并对这两个元素进行计算,将结果压入栈中

    for循环结束之后,栈里只有一个元素,这个元素就是整个表达式的计算结果。

    示例代码
    function calc_exp(exp) {
    	var stack = new Stack()
    	for (var i = 0;i<exp.length; i++) {
    		var item = exp[i];
    		if (['+','-','*','/'].indexOf(item) >= 0) {
    			var val_1 = stack.pop()
    			var val_2 = stack.pop()
    			var exp_str = val_2 + item + val_1;
    			console.log(exp_str)
    			// 计算并取整
    			var res = parseInt(eval(exp_str));
    			// 计算结果压入栈中
    			stack.push(res.toString())
    		}else {
    			stack.push(item)
    		}
    	}
    	return stack.pop()
    }
    
    console.log(calc_exp(['4','13','5','/','+'])) // 6
    
    

    拓展:实现一个有min方法的栈

    实现一个栈,除了常见的pushpop方法意外,提供一个min方法,返回栈里的最小的元素,且时间复杂度为O(1)

    function MinStack() {
    	var data_stack = new Stack();
    	var min_stack = new Stack();
    	// 用min_stack 记录每次 push 进来的元素之后,栈中的最小值
    	this.push = function (item) {
    		data_stack.push(item);
    		if(min_stack.isEmpty() || item < min_stack.top()){
    			min_stack.push(item)
    		}else {
    			min_stack.push(min_stack.top())
    		}
    	};
    	// 这样,每次pop之后,min_stack 也会将上次栈中的最小值弹出
    	this.pop() = function () {
    		data_stack.pop()
    		min_stack.pop()
    	}
    	this.min = function () {
    		return min_stack.top()
    	}
    }
    
    

    拓展:实现中缀转后缀表达式

    输入:(1 + (4+5+3) -3) + (9+8)
    输出: ['1','4','5','+','3','+','+','3','-','9','8','+','+'] 
    
    // 运算符优先级
    var priority_map = {
    	"+":1,
    	"-":1,
    	"*":2,
    	"/":2
    }
    function infix_exp_2_postfix_exp(exp) {
    	var stack = new Stack()
    	var postfix_list = []
    	for (var i = 0;i<exp.length;i++) {
    		var item = exp[i];
    		// 如果是数字,则直接放入 post_fix_list中
    		if(isNaN(item)){
    			postfix_list.push(item)
    		// 遇到左括号入栈
    		}else if (item == "("){
    			stack.push(item)
    		// 遇到右括号,把栈顶元素弹出,直到遇到左括号
    		}else if (item == ')') {
    			while (stack.top() != "(") {
    				postfix_list.push(stack.pop())
    			}
    			// 左括号出栈
    			stack.pop()
    		}else{
    			// 遇到运算符,把栈顶运算符弹出,直到栈顶的运算符的优先级小于当前运算符
    			while (!stack.isEmpty()&&['+','-','*','/'].indexOf(stack.top())>=0 && priority_map[stack.top()] >= priority_map[item]) {
    				postfix_list.push(stack.pop())
    			}
    			stack.push(item)
    		}
    	}
    	// for 循环结束后,栈里可能还有元素,都弹出放入到postfix_list当中
    	while (!stack.isEmpty()) {
    		postfix_list.push(stack.pop())
    	}
    	return postfix_list
    }
    
    展开全文
  • 实验4、顺序栈的基本操作及应用 (1)实验目的 通过该实验,让学生掌握栈的相关基本概念,认识栈是插入和删除集中在一端进行的线性结构,掌握栈的“先入后出”操作特点。栈在进行各类操作时,栈底指针固定不动,掌握...
  • 栈的基本知识及应用

    2017-11-02 19:36:41
    栈的基本知识及应用 1.栈的概念和特性 栈(stack)是一种特殊的线性表。作为一个简单的例子,可以把食堂里冼净的一摞碗看作一个栈。在通常情况下,最先冼净的碗总是放在最底下,后冼净的碗总是摞在最顶上。而在使用...
  • 前面,我们实现了两种常见线性表 —— 顺序表 和 链表 ,本篇我们来介绍另外一种常用线性表 —— 定义 线性表中一种特殊数据结构,数据只能从固定一端插入数据或删除数据,另一端是封死特点 ...
  • 实验4、顺序栈的基本操作及应用 (1)实验目的 通过该实验,让学生掌握栈的相关基本概念,认识栈是插入和删除集中在一端进行的线性结构,掌握栈的“先入后出”操作特点。 栈在进行各类操作时,栈底指针固定不动,...
  • 不含任何元素的栈称为空栈,其特点为 先进后出。 功能:可以将数据从一种序列变为另一种序列 注:图片来自网络 #pragma once #define _CRT_SECURE_NO_WARNINGS 1 #include &lt;stdio.h&gt; ...
  • 数据结构:顺序栈的基本操作及应用 实验目的 通过该实验,让学生掌握栈的相关基本概念,认识栈是插入和删除集中在一端进行的线性结构,掌握栈的“先入后出”操作特点。栈在进行各类操作时,栈底指针固定不动,掌握栈...
  • 1、栈的定义 — 栈是限制在一端进行插入操作和删除操作的线性表(俗称堆栈),允许进行操作的一端称为“栈顶”,另外一固定端称为“”栈底“,当栈中没有元素时称为”空栈“。特点:后进先出(LIFO)。 2、...
  • 3、掌握栈的特点(先进后出 FILO)基本操作,如入栈、出栈等。 4、利用栈的特点解决实际问题,提高编程能力。 二. 实验内容 1、编写一个程序实现循环队列的各种基本运算,并在此基础上设计一个主程序,完成如下功能...
  • 适合于各种需要回退到上一状态的应用场景。并且通过对进出规则进一步控制,将优先级转化为出现位置先后顺序上。 ADT Stack{ 数据对象:同一数据类型若干数据集合 结构关系:线性关系 基本运算: int ...
  • 栈Stack的基本操作 两个小应用 栈的特点先进后出 ** Stack.h 文件 ** #ifndef __STACK_H__ #define __STACK_H__ enum B00I{FALSE,TRUE}; typedef struct stack{ char *pbuff; int icapa; int itop; }Stack; ...
  • 单调原理及应用 详解 附各种类型题目练习

    万次阅读 多人点赞 2017-09-29 15:25:12
    既然是,就满足后进先出的特点。与之相对应的是单调队列。 实现: 例如实现一个单调递增的,比如现在有一组数10,3,7,4,12。从左到右依次入栈,则如果为空或入栈元素值小于栈顶元素值...
  • 1. 栈的概念 栈是一种“操作受限”的线性表,支持两种基础操作,入栈和出栈。特点是先进后出,后进先出,也就说是先入栈的数据后出栈,后入栈的数据先出栈。 栈有几个概念需要我们了解: 栈大小:就是栈的容量,...
  • 1.栈的特点 仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为栈底。如果用链表实现栈,怎么利用链表去做呢,我们可以把链表头看成栈顶,链尾堪称栈底,添加元素的时候,元素添加到链...
  • 2、掌握和队列的特点,即后进先出和先进先出的原则。 3、掌握和队列的基本运算,如:入栈与出栈,入队与出队等运算在顺序存储结构和链式存储结构上的实现。 二、实验题目(已选题目四) 本次实验提供4个...
  • 2、掌握栈和队列的特点,即先进后出与先进先出的原则。 3、掌握栈和队列的基本操作实现方法。 二、 实验任务 1. 实现栈的顺序存储 2. 利用栈实现数制转换 ————————————————————...
  • (stack),有些地⽅称为堆栈,是⼀种容器,可存⼊数据元素、访问元素、删除元素,它的特点在于只能允许在容器的⼀端(称为顶端指标,英语:top)进⾏加⼊数据(英语:push)和输出数据(英语:pop)的运算。...
  • 目录一、概念二、栈的实现方式2.1 基于数组的实现2.2 基于链表的实现三、栈的应用场景3.1 栈在函数调用中的应用3.2 栈在表达式求值中的应用3.3 栈在括号匹配中的应用3.4 栈在浏览器进退中的应用四、主要参考链接 ...
  • 精品 软件技术基础相关实验 实验名称 栈的应用 一 实验目的 掌握顺序栈和链式栈的定义和运算了解它们的应用 二实验要求 1掌握顺序栈的定义特点及常见算法 2 掌握链式栈的定义特点及常见算法 3 参照给定的栈的程序...
  • 对程序员来说栈结构最为熟悉的一种数据结构,其特点是遵从后进先出(LIFO——Last In First Out)原则,新添加或待删除的元素保存在栈的同一端,称作栈顶,另一端称作栈底。在栈中,新元素总是靠近栈顶,而旧元素...
  • 2. 栈的特点 后进先出,通俗点讲,栈的插入或者删除只能在表的&amp;amp;amp;quot;顶端&amp;amp;amp;quot;进行操作的线性表。 注:对于栈,表尾称之为栈顶(top);表头称之为栈低(bottom) 3.栈的操作 栈的...
  • 栈应用之简易计算器算法原理实现(C语言)

    千次阅读 多人点赞 2017-07-25 17:52:44
    上面表达式称为中缀表达式,其特点是操作符位于中间位置(仅一个操作符)。 a b * 上面表达式称为后缀表达式,其特点是操作符位于后面位置(仅一个操作符)。 计算器算法原理是将中缀表达式转换为后缀表达式,...
  • 实验4、顺序栈的基本操作及应用 要求: (1)实验目的 通过该实验,让学生掌握栈的相关基本概念,认识栈是插入和删除集中在一端进行的线性结构,掌握栈的“先入后出”操作特点。栈在进行各类操作时,栈底指针固定不...
  • 应用架构演变 单一应用架构 特点: 所有功能集成在一个项目工程中 所有功能可以打一个war部署到服务器 应用和数据库分开部署 通过部署应用集群和数据库集群来提高系统稳定性 优点: 开发简单 便于共享 易于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 413
精华内容 165
关键字:

栈的特点及应用