精华内容
下载资源
问答
  • 循环lifo
    2022-08-23 14:07:11

    事件循环是许多开发人员困惑的根源,但它是 JavaScript 引擎的基础部分。它允许 JavaScript 是单线程的,但能够以非阻塞方式执行。要理解事件循环,我们首先需要解释一些关于 JavaScript 引擎的东西,例如调用堆栈、任务、微任务及其各自的队列。让我们一一分解。

    调用堆栈

    调用堆栈是一种跟踪 JavaScript 代码执行的数据结构。顾名思义,它是一个堆栈,因此是内存中的 LIFO(后进先出)数据结构。执行的每个函数都表示为调用堆栈中的一个框架,并放置在前一个函数的顶部。

    让我们看一个简单的例子,一步一步来:

    function foo() {
      console.log('foo');
      bar();
    }
    
    function bar() {
      console.log('bar');
    }
    1. 调用堆栈最初是空的。
    2. 该函数<
    更多相关内容
  • 循环缓冲区和循环数组均支持FIFO,LIFO和MIXED(FIFO + LIFO); 这可以引导您设计一个优先级队列系统,其中优先级项的前项和最低优先级的后项。 该库能够从队列的前面和后面插入和读取。 该库支持的缓冲区系统不...
  • LIFo栈之逆序链表 第一题 int* reversePrint(struct ListNode* head, int* returnSize){ int vec[10000];//辅助栈 int top=0; struct ListNode*cur=head; while(cur)//入栈 { vec[top++]=cur->val; cur=...

    LIFo栈之逆序链表

    第一题

    int* reversePrint(struct ListNode* head, int* returnSize){
    int vec[10000];//辅助栈
    int top=0;
    struct ListNode*cur=head;
    while(cur)//入栈
    {
        vec[top++]=cur->val;
        cur=cur->next;
    }
    int i=top;
    *returnSize=i;
    int temp=0;
    int*ret=(int *)malloc(sizeof(int)*(*returnSize));
    for(int j=i-1;j>=0;j--)
    {
        ret[temp]=vec[j];
        temp++;
    }
    return ret;
    }

    入栈,打印,元素顺序相反

    第二题

    struct ListNode* reverseList(struct ListNode* head){
    struct ListNode*stack[5001];//辅助栈
    int top=0;
    struct ListNode*cur=head;
    if(head==NULL)
    {
        return NULL;
    }
    while(cur)
    {
        stack[top++]=cur;
        cur=cur->next;
    }
    for(int j=top-1;j>0;j--)
    {
        stack[j]->next=stack[j-1];
    }
    stack[0]->next=NULL;
    return stack[top-1];
    }

    括号匹配

    第一题

    int maxDepth(char * s){
        int depth=0;
        int maxdepth=-1;
    for(int i=0;s[i];i++)
    {
        if(s[i]=='(')
        {
    depth++;
        }
        else if(s[i]==')')
        {
            depth--;//表示匹配成功,前提为保证s中括号有效
        }
        maxdepth=maxdepth>depth?maxdepth:depth;//实时更新最大深度
    }
    return maxdepth;
    }

    前提是字符串有效,

    第二题

    bool isValid(char * s){
    int len=strlen(s);
    char stack[len];
    int top=0;//辅助栈
    for(int i=0;i<len;i++)
    {
        if(s[i] == '(' || s[i] == '[' || s[i] == '{')
        {
            stack[top]=s[i];
            top++;
        }
        else{
            if(top==0)
            {
                return false;
            }
            char topElem=stack[top-1];
            top--;//栈顶出栈
            if(s[i] == ')' && topElem != '(')
                    return false;                     //左右括号不匹配
                if(s[i] == ']' && topElem != '[')
                    return false;                     //左右括号不匹配
                if(s[i] == '}' && topElem != '{')
                    return false;                     //左右括号不匹配
        }
    }
    if(top!=0)
    {
        return false;//表示栈里还有没匹配的元素
    }
    return true;
    }

    出入栈版本:

    左括号就入栈,右括号就出栈(top--)并检验是否能匹配

    回文链表

    bool isPalindrome(struct ListNode* head){
        
    int stack[100001];
    int top=0;
    struct ListNode*fast=head;
    struct ListNode*slow=head;
    if(head==NULL||head->next==NULL)
    {
        return true;
    }
    if(head->next->next==NULL)
    {
        if(head->val==head->next->val)
        {
            return true;
        }
        return false;
    }
    while(fast!=NULL&&fast->next!=NULL)
    {
    fast=fast->next->next;
    slow=slow->next;
    }//slow是中间结点
    struct ListNode*temp=slow->next;
    if(head==NULL||head->next==NULL)
    {
        return true;
    }
    while(temp!=NULL)
    {
        stack[top]=temp->val;
        top++;
        temp=temp->next;
    }//把后面的入栈
    struct ListNode*cur=head;
    while(top)
    {
        int vtx=stack[top-1];
        top--;
        if(cur->val!=vtx)
        {
            return false;
        }
        cur=cur->next;
    }
    return true;
    }

    将后半段入栈,再依次出栈与head相比较,作用相当于翻转链表

    表达式求值

    第一题

    int calPoints(char ** ops, int opsSize){
        int ret = 0;
        int * points = (int *)malloc(sizeof(int) * opsSize);
        int pos = 0;
        for (int i = 0; i < opsSize; i++) {
            switch (ops[i][0]) {
                case '+':
                    ret += points[pos - 1] + points[pos - 2];
                    points[pos++] = points[pos - 1] + points[pos - 2];
                    break;
                case 'D':
                    ret += 2 * points[pos - 1];
                    points[pos++] = 2 * points[pos - 1];
                    break;
                case 'C':
                    ret -= points[pos - 1];
                    pos--;
                    break;
                default:
                    ret += atoi(ops[i]);
                    points[pos++] = atoi(ops[i]);
                    break;
            }
        }
        free(points);
        return ret;
    }

    第二题

    逆波兰表达式

    bool isNumber(char* token) {
        return strlen(token) > 1 || ('0' <= token[0] && token[0] <= '9');
    }
    
    
    int evalRPN(char** tokens, int tokensSize) {
        int n = tokensSize;
        int stk[n], top = 0;
        for (int i = 0; i < n; i++) {
            char* token = tokens[i];
            if (isNumber(token)) {
                stk[top++] = atoi(token);
            } else {
                int num2 = stk[--top];
                int num1 = stk[--top];
                switch (token[0]) {
                    case '+':
                        stk[top++] = num1 + num2;
                        break;
                    case '-':
                        stk[top++] = num1 - num2;
                        break;
                    case '*':
                        stk[top++] = num1 * num2;
                        break;
                    case '/':
                        stk[top++] = num1 / num2;
                        break;
                }
            }
        }
        return stk[top - 1];
    }
    

     是数字的写法'0'<=token[0]&&'9'<=token[0]

    出栈一个元素只需要vtx=token[--top]

    双栈判等

    第一题

    char* build(char*str)
    {
        int n=strlen(str);
        int top=0;
        char*stack=malloc(sizeof(char)*(n+1));
    for(int i=0;i<n;i++)
    {
        if(str[i]!='#')
        {
            stack[top++]=str[i];
        }
        else if(top>0)
        {
            top--;
        }
    }
    stack[top]='\0';
    return stack;
    }
    bool backspaceCompare(char * s, char * t){
        return strcmp(build(s),build(t))==0;
    }

    知识点:

    1.初始化stack都用malloc

    2.字符串比较strcmp

     其他

    先pop,循环判断pop进的是不是push的首元素,是就push出来,最后剩下的一定是123   321这样的,判断然后把他push出来,判断栈是否为空 

    展开全文
  • 循环结构--1-- 结构循环1.1 while循环1.2do…while循环1.3 for循环--2-- break和continue2.1break关键字2.2continue关键字--------------------------【写在开头:】『生活中的循环:C语言中的循环循环结构是程序...

    循环结构

    --1-- 结构循环

    1.1 while循环

    1.2 do…while循环

    1.3 for循环

    --2-- break和continue

    2.1 break关键字

    2.2 continue关键字

    --------------------------

    【写在开头:】

    生活中的循环:

    3e80f45114eefeaebfcb27c5b669d280.png

    C语言中的循环:

    循环结构是程序中一种很重要的结构。其特点是,在给定的条件成立时,反复执行某程序段,直到条件不成立为止。

    C语言中提供了多种循环语句:

    1)goto语句和if构成循环(已经被摒弃)

    2)while语句

    3)do-while语句

    4)for语句

    构成循环的几个条件:

    一般来说一个循环需要以下几部分构成

    1)循环控制条件

    循环退出主要依据

    2)循环体

    循环过程中重复执行的代码块。

    3)能够让循环结束的语句(递增、递减、真、假等)

    --1-- 结构循环

    1.1 while循环

    1)语法格式

    while(条件)

    {

    语句1;

    语句2;

    语句n;

    }

    2)while循环执行特点

    当条件成立时一直执行程序体。

    3)示例

    从键盘上输入一个数n,计算1+2+3…+n的值。

    //定义变量

    int i = , n = , sum = ;

    //接受键盘输入n并赋值给变量n

    printf("请输入累加上限:\n");

    scanf("%d",&n);

    //while循环条件小于n

    while (i <= n) {

    sum += i; //累加

    i++;

    }

    printf("从1累加到%d的值是:%d\n",n,sum);

    4)补充

    scanf的原理:如果输入缓冲区不为空,则不会让用户再次输入内容,而直接冲缓冲区中继续获取。

    最简单的死循环:while(1);

    1.2 do…while循环

    1)语法格式

    do{

    语句1;

    语句2;

    语句n;

    }while(条件);

    2)do…while循环的特点:

    不管while中的条件是否成立,至少会执行一次循环体。

    3)while和dowhile的循环类型不同

    while循环是一个当型循环,当条件满足时再执行循环体;

    do…while循环是直到型循环,先执行循环体,再判断条件,直到条件为假时结束。

    4)示例

    int x = -;

    do{

    printf("do...while\n");

    x--;

    }while (x > ); //do...while循环 无论条件是否满足,循环体都会执行一次

    1.3 for循环

    1)for语法格式

    C语言中for语句的使用最为灵活,完全可以代替while语句

    一般形式:

    for(表达式1;表达式2;表达式3){

    语句块;

    }

    2)for循环执行过程

    b08498784b5972117a4c8d5e7261e291.png

    执行顺序:

    1)先求表达式1,给i初始化

    2)求解表达式2,若其值为真(非0),则执行for语句中指定的内嵌语句-->表达式3

    3)执行表达式4

    -->循环完一遍之后执行第二步,再依次往下

    注意:步骤1)在整个循环中只执行一次

    3)for循环的其他形式

    1)表达式1省略

    int i = ;

    for (; i < ; i++){

    printf("%d", i);

    }

    2)表达式1、3省略

    int i = ;

    for (; i < ;){

    printf("%d", i);

    i++;

    }

    3)表达式1、2、3省略

    int i = ;

    for(;;){

    if (i < ){

    printf("%d", i);

    i++;

    } else{

    break;

    }

    }

    4)最简单的for循环

    for (; ; );

    5)for循环的嵌套使用

    打印图形

    * * * * *

    * * * * *

    * * * * *

    * * * * *

    * * * * *

    分析:

    内层循环打印一行,外层循环5次打印5行

    for (int j = ; j < ; j++) {

    for (int i = ; i < ; i++) { //内层打印行

    printf("*\t");

    }

    printf("\n");

    }

    --2-- break和continue

    2.1 break关键字

    break和continue都可以用在循环中,用来跳出循环/结束循环

    break用法

    break语句通常用在循环和开关语句中。

    注意:

    1)break对if-else不起作用。

    2)break用于跳出当前循环(结束当前循环)。

    3)break影响的是当前的这个循环,对外层循环不起作用

    示例

    计算r=1到r=10时圆的面积,直到面积大于100为止

    分析:

    圆的面积 area = 3.14 * r * r;

    //计算r=1到r=10时圆的面积,直到面积大于100为止

    for (int r = ; r <= ; r++) {

    double area = 3.14 * r * r;

    if (area > ) {

    break; //面积大于100 结束循环

    }

    printf("area = %.2f\n", area);

    }

    2.2 continue关键字

    continue用于结束本次循环,继续下次循环

    continue只用在for、while、do-while等循环体中,常与if语句一起使用,用来加速循环

    示例

    把100-200之间不能被3整除的数输出。

    分析:

    被3整除时结束本次循环进入下一次循环

    //把100-200之间不能被3整除的数输出

    for (int i = ; i <= ; i++) {

    if (i % == ) {

    continue; //整除则跳出本次循环

    }

    printf("i = %d\n", i);

    }

    总结:

    break跳出循环后循环就结束了,而continue跳出循环后还继续下一次循环。这就是break和continue最大的区别。

    【写在结尾:】

    『下雨了,滴答滴答的...从小最喜欢的,就是听雨的声音...』

    MATLAB循环结构:break&plus;continue&plus;嵌套

    break语句:终止当前循环,继续执行循环语句的下一语句: continue语句:跳过循环体的后面语句,开始下一个循环: 例:求[100,200]之间第一个能被21整除的整数 :200 %循环语句 ) ...

    049 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 11 break语句

    049 01 Android 零基础入门 01 Java基础语法 05 Java流程控制之循环结构 11 break语句 本文知识点:break语句 break语句 break语句前情回顾 1.swi ...

    bash中选择结构、循环结构与break、continue

    if两种选择结构 if 测试条件; then 程序块 else 程序块 fi if 测试条件1; then 程序块 elif 测试条件2; then 程序块 ... elif 程序条件n; then ...

    iOS学习之C语言循环结构

    一.while循环    while (循环条件) {        循环体:    }    // 1.定义循环变量    int time = 1;    // 2.循环条件    while ( ...

    C语言--循环结构

    watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvenVveW91MTMxNA==/font/5a6L5L2T/fontsize/400/fill/I0JBQk ...

    day05-Python运维开发基础&lpar;双层循环、pass&sol;break&sol;continue、for循环&rpar;

    # ### 双层循环练习 # 十行十列小星星 j = 0 while j<10: # 逻辑代码写在下面 # 打印一行十个小星星 i = 0 while i<10: print(" ...

    for循环里的break&comma;continue和return有什么差别

    break: 此语句导致程序终止包含它的循环,并进行程序的下一阶段(整个循环后面的语句),即,不是跳到下一个循环周期而是退出循环.如果break语句包含在嵌套循环里,它只跳出最里面的循环. 如下代码 ...

    循环(for&comma;while&comma;until)与循环控制符(break&comma;continue)

    一.for循环 第一种风格   for ((;;;))(类似C语言风格) do command done 例子:for ((i=0;i<10;i++)) do echo $i done 第二种风 ...

    iOS学习03C语言循环结构

    1.while循环 while (循环条件) {        循环体: } // 1.定义循环变量 ; // 2.循环条件 ) { // 3.循环体 printf("%d\n", ...

    随机推荐

    python 获取日期

    转载   原文:python 获取日期 作者:m4774411wang python 获取日期我们需要用到time模块,比如time.strftime方法 time.strftime('%Y-%m-% ...

    java中实现链表(转)

    分析: 上述节点具备如下特征: 1. 每个节点由两部分组成(存储信息的字段,存储指向下一个节点的指针) 2. 节点之间有着严格的先后顺序. 3. 单链表节点是一种非线性的结构,在内存中不连续分配空间. ...

    POJ 3678--Katu Puzzle(2-SAT)

    感觉这题比较裸,表现出了2-sat的本质. 不过构图我想的还是太简单了,a&b=1我只连了 a1->b1,b1->a1,但其实是不对的.这样连,a0和b0可以同时选到.应该连a0- ...

    App Doc View Frame中指针的获取

    // App中获取其它三项指针 void CSDIApp::OnApp() { // App // Doc CDocument *pDoc = ((CFrameWndEx *)m_pMainWnd)- ...

    Bitmap上下合成图片

    合成两张图片,上下叠加的效果: /** * 把两个位图覆盖合成为一个位图,以底层位图的长宽为基准 * * @param backBitmap 在底部的位图 * @param frontBitmap 盖 ...

    js 实现数据结构 -- 栈

    原文: 在 Javascript 中学习数据结构与算法. 概念: 栈是一种遵从先进后出 (LIFO) 原则的有序集合:新添加的或待删除的元素都保存在栈的末尾,称作栈顶,另一端为栈底.在栈里,新元素都靠 ...

    iOS开发-Tom猫

    // //  ViewController.m //  20-tom猫 // //  Created by hongqiangli on 2017/8/1. //  Copyright © 李洪强. ...

    CVE-2012-0158基于exp分析

    CVE-2012-0158这个洞我之前分析过,漏洞战争这本书里也写过,但是都是用poc分析的,我这次找了一个弹计算器的exp来分析,感觉用poc和用exp还是不一样的,从exp分析要比从poc分析更复 ...

    Set up the environment for driver compiling in Debian

    1.check the kernel version $ uname -r --amd64 2.install the source code $ sudo apt-get install linux ...

    &lbrack;Excel&rsqb;鼠标右键菜单没有新建Word、Excel、PPT怎么办?

    很多朋友在安装好Office(2010或2013等)之后,发现右键新建中没有Word.Excel.PowerPoint等项,但是自己的Office却明明安装好了.这个时候该怎么办呢?这里,本文为大家提 ...

    展开全文
  • 实现数据结构中的栈---后进先出LIFO

    千次阅读 2020-06-18 12:17:21
    = '\0') ) // 循环遍历字符串 { // 如果有不匹配的字符就立即结束循环 if( is_Left(str[i]) ) // 左符号,直接入栈 { stack.push(str[i]); } else if( is_Right(str[i]) ) // 右符号,判断栈是否为...

    栈是什么?如果用生活中最常见的例子,我想到是书本的放置(当然这是部分人喜欢的做法)。但是给人的感觉是非常直接的,书本整齐跨一叠在一起,放在最上面的那本最先拿走,放在最底下那本书就最后拿走,形象吧,生活中有很多后进先出的栗子,就不一一说明了,用图来说明应该很好理解。
    在这里插入图片描述

    放在最上面的那本书的位置叫栈顶,栈顶是可变的,比如说你拿走了西游记,那么栈顶就是红楼梦得位置。相对应的栈底是不可操作的一端。
    栈是一种特殊的线性表,特殊之处在于只能在一端对其进行操作,把元素放到栈中,这操作叫压栈(push),压栈之后,栈顶指针就向上移动。把元素从栈顶弹出,这叫出栈(pop),出栈后栈顶指针向下移动。访问栈只能从栈顶元素进行。栈是很重要的数据结构,在很多算法都有应用,比如图的深度优先遍历算法(DFS),Dijkstra算法的中转站。

    栈的实现分为两种,一是顺序栈,用数组来实现,二是链式栈,用指针将结点串联起来,与链表相似,但仅能在栈顶进行操作。

    先实现简单的顺序栈,顺序栈简直不要太简单,上代码:

    #ifndef STATICSTACK_H
    #define STATICSTACK_H
    
    template <typename T, int N>
    class StaticStack
    {
    protected:
    	T array[N];	// 使用模板参数决定栈的大小
    	int m_top;	// 使用整型作为标记,相当于栈顶指针
    	int m_size;	// 栈中数据元素的个数
    public:
    	StaticStack()	// 初始化操作得做一下
    	{
    		m_top = -1;
    		m_size = 0;
    	}
    	
    	bool push(const T& obj)	// 压栈操作,就是往数组增加一个元素
    	{
    		bool ret = m_size < N;	// 满了就没办法了
    		
    		if( ret )
    		{
    			array[++m_top] = obj;
    			++m_size;
    		}
    		
    		return ret;
    	}
    	
    	bool pop()	// 出栈操作
    	{
    		bool ret = m_size > 0;
    		
    		if( ret )
    		{
    			--m_top;
    			--m_size;
    		}
    		
    		return ret;
    	}
    	
    	T top()	// 获取栈顶元素
    	{
    		return array[m_top];
    	}
    	
    	void clear()	// 把栈清空
    	{
    		m_top = -1;
    		m_size = 0;
    	}
    	
    	int size()	// 获取栈的大小
    	{
    		return m_size;
    	}
    	
    	~StaticStack()
    	{
    		clear();
    	}
    };
    
    #endif

    来用一下这个简单顺序栈。记住,后进先出!

    #include <iostream>
    #include "StaticStack.h"
    
    using namespace std;
    
    int main(int argc, const char* argv[])
    {
    	StaticStack<int, 10> stack;
    
    	for(int i = 0; i < 10; ++ i)
    	{
    		stack.push(i);
    	}
    	// 入栈的时候是 0123456789 的顺序
    	
    	for(int i = 0; i < 10; ++ i)
    	{
    		cout << stack.top() << endl;
    		stack.pop();
    	}
    	
    	return 0;
    }

    在这里插入图片描述

    输出正确。OK,顺序栈就可以跳过了,因为顺序栈的实现依赖于原生数组,所以在定义的时候必须给定大小,并且在使用的过程中不能动态改变其大小,这是顺序栈的一个缺点,另外,当顺序栈存放的元素是类类型,那么在定义顺序栈时就会自动调用类的构造函数,有多少个元素就会调用多少次,这样做显然会降低效率,所以顺序栈的使用相对较少。

    现在重点来实现链式栈吧,有了顺序栈的基础,实现链式栈也相当容易。
    直接上代码:

    #ifndef LINKSTACK_H
    #define LINKSTACK_H
    
    template <typename T>
    class LinkStack
    {
    protected:
    	struct Node
    	{
    		T data;
    		Node* next;
    	};
    	mutable Node header;	// 使用头节点会方便各种操作
    	int m_size;
    	
    public:
    	LinkStack()
    	{
    		header.next = NULL;
    		m_size = 0;
    	}
    	
    	bool push(const T& obj)	// 压栈操作
    	{
    		bool ret = true;	
    		Node* n = new Node();
    		
    		if( n != NULL )
    		{
    			n->data = obj;
    			Node* current = &header;	// 相当于链表的头插
    			n->next = current->next;
    			current->next = n;
    			++m_size;
    		}
    		else
    		{
    			ret = false;
    		}
    		
    		return ret;
    	}
    	
    	bool pop()	// 出栈操作
    	{
    		bool ret = true;
    		
    		if( m_size > 0 )
    		{
    			Node* current = &header;	// 相当于链表的头删
    			Node* todel = current->next;
    			current->next = todel->next;
    			--m_size;
    			delete todel;
    		}
    		else
    		{
    			ret = false;
    		}
    		
    		return ret;
    	}
    	
    	T top() const	// 获取栈顶元素
    	{
    		Node* current = header->next;
    		
    		return current->data;
    	}
    	
    	int size() const
    	{
    		return m_size;
    	}
    	
    	void clear()	// 清空栈
    	{
    		while( m_size > 0 )
    		{
    			pop();
    		}
    	}
    	
    	~LinkStack()
    	{
    		clear();
    	}
    };
    
    #endif

    仅仅是实现一个栈好像没有什么好玩的,顺序栈操作一个数组,链式就几个指针操作。现在用栈来实现一个扫描函数,将字符串中的左右符号进行匹配。举个栗子,“( a { b c [ d < e " f ’ g’ " h > i ] j } k)”,这样一个看起来复杂l凌乱的字符串,怎么知道它的左右符号匹不匹配呢?人工智能嘛,人工来数一下不就可以了吗?Good idea!简单的数几分钟就应该知道结果了,要是一本书那么多的字符串怎么来数?当然是把工作交给计算机!写个程序来检查左右符号是否匹配不就得了。主要注意的地方是左符号、右符号以及引号的处理,其他字符直接忽略。知道重点了,实现就容易了,说干就干,动手!

    #include <iostream>
    #include "LinkStack.h"
    
    // 需要提前准备相应的辅助函数
    bool is_Left(const char c)	// 判断是否为左符号
    {
    	return (c == '(') || (c == '{') || (c == '<') || (c == '[');
    }
    
    bool is_Right(const char c)	// 判断是否为右符号
    {	
    	return (c == ')') || (c == '}') || (c == '>') || (c == ']');
    }
    	
    bool is_Quot(const char c)	// 判断是否为引号
    {
    	return (c == '\'') || (c == '\"');
    }
    
    bool is_Match(const char l,const char r)	// 进行匹配判断
    {
    	bool ret = ( (l == '(') && (r == ')') )   ||
    		   ( (l == '{') && (r == '}') )   ||
    		   ( (l == '[') && (r == ']') )   ||
    		   ( (l == '<') && (r == '>') )   ||
    		   ( (l == '\'') && (r == '\'') ) ||
    		   ( (l == '\"') && (r == '\"') ) ;	
    		   
    	return ret;
    }
    
    bool scan_func(const char* str)	// 扫描字符串的函数
    {
    	bool ret = true;	
    	int i = 0;
    	str = str ? str : "";	// 参数合法性判断,如果参数为空,则用空字符串代替
    	LinkStack<char> stack;	// 看着怎么使用栈吧
    
    	while( ret && (str[i] != '\0') )	// 循环遍历字符串
    	{					// 如果有不匹配的字符就立即结束循环
    		if( is_Left(str[i]) )		// 左符号,直接入栈
    		{
    			stack.push(str[i]);
    		}
    		else if( is_Right(str[i]) )	// 右符号,判断栈是否为空
    		{				// 如果栈为空,结束循环
    			if( (stack.size() > 0) && (is_Match(stack.top(), str[i])) )		
    			{
    				stack.pop();	// 栈不为空,且与栈顶元素能匹配,那就把栈顶中的左符号出栈
    			}
    			else
    			{
    				ret = false;	
    			}
    		}
    		else if( is_Quot(str[i]) )	// 引号判断
    		{				// 如果栈为空或者与栈顶元素不匹配,入栈
    			if( (stack.size() == 0) || (!is_Match(stack.top(), str[i])) )
    			{
    				stack.push(str[i]);
    			}			// 与栈顶元素匹配,那就将栈顶的引号出栈
    			else if( is_Match(stack.top(), str[i]) )
    			{
    				stack.pop();
    			}
    		}
    	}
    	
    	return (ret && (stack.size() == 0) );
    }
    
    int main(int argc, const char* argv[])
    {
    	const char* str1 = " < ( [ { 123 } ] ) > ";
    	const char* str2 = " \" \' 123 \' \" ";
    	const char* str3 = "< 123 ";
    
    	cout << endl;
    	cout << str1 << " result of match : " << ( scan_func(str1) ? " true " : " false " ) << endl;
    	
    	cout << endl;
    	cout << str2 << " result of match : " << ( scan_func(str2) ? " true " : " false " ) << endl;
    	
    	cout << endl;
    	cout << str3 << " result of match : " << ( scan_func(str3) ? " true " : " false " ) << endl;
    	
    	
    	return 0;
    }

    看看输出结果,多easy,要是用人工的智能来数,得花点点点时间。

    在这里插入图片描述

    展开全文
  • 小编所收集到的相关计算机二级考试公共基础知识冲刺复习笔记:栈、队列和循环队列的资料 大家要认真阅读哦!1、栈(Stack)又称堆栈。(1)栈是一种运算受限的线性表,其限制是仅允许在表的一端进行插入和删除运算。人们...
  • 循环队列 + 用队列实现栈 ——纯C

    千次阅读 多人点赞 2022-03-31 14:46:14
    循环队列+用队列实现栈——纯C
  • 循环数组实现队列

    2021-11-16 23:40:33
    又叫后进先出(LIFO)表。 用数组循环实现队列,首先想象数组中的单元排列成一个圆,数组的头部和尾部相邻,而表在占用其中任意连续的一部分数组单元空间(而队尾队首标永远大于0且根据增加和删除的次数自加,所以...
  • Zephyr OS 所有的学习笔记已托管到 Github,CSDN 博客里的内容只是 Github 里内容的拷贝,因此链接会有错误,请...LIFO 是与 FIFO 类似的一种服务,只是它是后进先出的而已。 LIFO 的类型定义 LIFO 的初始化 从 LIFO
  • 列表的LIFO与文件交互

    2017-06-08 01:09:00
    礼拜的LIFO特性: LIFO(Last In First Out) 其实就是堆栈功能,比如搭积木: 第一块在最下面,最后一块在最上面,拆的时候总是最后一块先拆,以此类推(stack) 代码实现: #!/usr/bin/env python3 # -*- ...
  • 单链表 2.2.2 循环链表 循环链表 其实是一种特殊的单链表,和单链表不同的是循环链表的尾结点不是指向null,而是指向链表的头结点。 循环链表 2.2.3 双向链表 双向链表 包含两个指针,一个prev指向前一个节点,一...
  • 循环队列的介绍与实现

    千次阅读 2020-08-06 14:55:52
    而栈是只允许在一端进行插入和删除运算,因而是后进先出表LIFO; 队列是只允许在一端进行插入、另一端进行删除运算,因而是先进先出表FIFO。 ② 用途不同:线性表比较通用;堆栈用于函数调用、递归和简化设计等;...
  • js事件循环

    2021-09-07 09:08:59
    事件循环(Event Loop),是指浏览器或Node的解决JS单线程运行时不会阻塞的一种机制,也就是js实现异步的原理。 2 栈和队列 栈是一种 LIFO(Last In, First Out)的数据结构,特点即后进先出。 (举例:桶装薯片。最...
  • 只允许在一端进行操作,按照后进先出(LIFO, Last In First Out)的原理运作。 特点:只允许在容器的一端(称为栈顶端指标,英语:top)进行加入数据(英语:push)和输出数据(英语:pop)的运算。没有了位置概念,...
  • 在看JDK1.7的HashMap源码是看到了resize()的源代码,当时发现在将old链表中引用数据复制到新的链表中时,新table[]的列表采用LIFO方式,即队头插入。这样做的目的是:避免尾部遍历。(尾部遍历是指新列表插入数据时...
  • 循环链表和双向链表的讲解
  • 将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆 堆是线性数据结构,相当于一维数组,有唯一后继 (最大堆) (最小堆) 栈(stack): 栈是一种 LIFO(Last In, First Out)的数据结构,...
  • 循环取数据,数据可重复使用 模拟3用户登录,有5个账号供测试使用,迭代过程中从第1个数据开始取值,当第5个数据取出后,再从第1个数据开始取值 借助python 队列queue来实现数据的循环取值 queue是python3的...
  • class queue.Queue(maxsize=0) LIFO 类似于堆,即先进后出。 class queue.LifoQueue(maxsize=0) 优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize=0) queue 模块中的常用方法: queue.qsize() 返回...
  • 栈是限定在表尾进行插入删除操作的线性表,表尾又叫栈顶,表头又称栈底,又称后进先出结构(LIFO结构),栈分为顺序栈和链式栈两种` //顺序 typedef struct Snode* stack; struct Snode { int Data[initSize]; int...
  • 栈使用后进先出(LIFO)的规律,其中对于栈来说push的最后一个元素始终是第一个pop的元素。而队列采用更接近于排队的的先进先出(FIFO)模式。栈和队列的接口也非常相似。两个接口的public部分的唯一变化是定义类的...
  • 事件循环 - JavaScript Guidebook (tsejx.github.io) 1;执行上下文: 指当前执行环境中的变量、函数声明,参数(arguments),作用域链,this等信息。分为全局执行上下文、函数执行上下文,其区别在于全局执行上...
  • JAVASCRIPT事件循环

    2020-12-23 03:20:42
    事件循环是用来理解JavaScript的最重要的方面之一。这篇文章旨在解释JavaScript如何与单个线程一起工作的细节,以及它如何处理异步函数。JavaScript代码运行是单线程。一次只执行一件事。这实际上是一个非常有用的...
  • JavaScript的堆、栈、队列、事件循环机制
  • Java递归,递归改循环

    千次阅读 2018-10-17 10:33:03
    Java递归,递归改循环 为什么大家都说不建议用递归? 递归容易造成栈溢出,在jdk1.5前虚拟机给每个栈桢的运行空间128kb,在1.5以后为1m的运行空间.递归是指先进后出,也就是说第一进栈的对象会最后一个出站,然后栈桢...
  • c# 并行计算(大量循环处理的场景下) 并行计算部分 沿用微软的写法,System.Threading.Tasks.::.Parallel类,提供对并行循环和区域的支持。 我们会用到的方法有For,ForEach,Invoke。 一、简单使用 首先...
  • 栈、队列及循环队列

    千次阅读 2018-07-21 22:18:37
    栈,队列及循环队列,是数据结构中的重要的且常用的内容,最近在学习数据结构,于是作一篇笔记记录一下,希望以后复习有帮助  1.栈:  栈是限定仅在表尾进行插入或删除操作的线性表。我们把表尾称作栈顶(top),...
  • JS事件循环机制

    2022-02-27 21:51:34
    其实只需要记住的是,setTimeout(fn, 0)在下一轮“事件循环”开始时执行,顺便说一下,Promise.resolve()在本轮“事件循环”结束时执行,这就涉及到宏任务和微任务的知识点了。 任务 在JS中,任务被分为两种,一种宏...
  • 浅析 JS 中的 EventLoop 事件循环(新手向) 这篇呢则是动图学 JS 系列中的,可以结合之前的文章食用~ 我们都知道 JavaScript 是一门 单线程 的语言:同一时间只能运行一个任务。通常情况下这没什么问题,但是如果你...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,051
精华内容 6,020
关键字:

循环lifo