精华内容
下载资源
问答
  • c语言中的栈顶元素为什么有时候用L->top,有时候用L.top这两个有什么区别,的元素从底到栈顶输出的c语言代码怎么写,谢谢各位大神了
  • class Stack: def __init__(self): self.items = [] def isEmpty(self): return self.items == [] def push(self, items): self.items.append(self.items) def pop(self): ...```
  • assume cs:code,ss:stack stack segment db 256 dup('$') stack ends code segment start: mov ax,stack mov ss,ax mov sp,256 mov cx,0 s: mov ah,01 int 21h ... end start
  • 那么怎么解决发车时他们的顺序是怎么样呢?  假设有3个地铁,编号分别是1,2,3.在地铁上的顺序是1,2,3。在停车时他们可以顺序进入停车,停车时也是1,2,3,但是早上发车时必然是3,2,1.显然这是一个典型的先进后出,...

        有这样一个具体问题,假设地铁只能在一条轨道上行驶,一条轨道上有多个地铁,地铁夜晚停车时需要停放在一条轨道上,早上发车时就存在一个出来的顺序问题?那么怎么解决发车时他们的顺序是怎么样呢?

        假设有3个地铁,编号分别是1,2,3.在地铁上的顺序是1,2,3。在停车时他们可以顺序进入停车,停车时也是1,2,3,但是早上发车时必然是3,2,1.显然这是一个典型的先进后出,如何罗列出他们的所有情况呢?

       我的基本思想是这样的,如果有3个,那么他们的停车出车必然会进行2*3=6次,每一个车必然会进去,出来,如果我们把进去标记为1出来标记为0,那么用一个长度为6的整形数组便可以存储他们的情况,但是要注意这个数组第一个元素必然是1进车,而最后一个必然是0出车,并且必然不会是100110这种情况,因为一个车进去,不可能有两个车出来,解决了以上问题,我们得到了所有情况下数组的值,便可以使用堆栈数据结构模拟所有地铁的进车出车过程,以及最后的顺序。

    下面给出代码:

    #include<stdio.h>
    #include<stdlib.h>
    struct train{
     int n;
     int p;
    };
    struct stack{
     train *base;
     train *top;
     int num;
    };
    struct hh{
     int *base;
     int *top;
     int num;
    };
    int n;
    void moni(hh *h);
    void Inith(hh *s){
     s->base=(int*)malloc(20*sizeof(int));
     if(s->base==NULL)exit(0);
     s->top=s->base;
     s->num=20;
    }
    void pushh(hh *s,int e)
    {
     if((s->top-s->base)>=s->num)
     {
      s->base=(int*)realloc(s->base,(s->num+10)*sizeof(int));
      if(s->base==NULL)exit(0);
      s->num=s->num+10;
     }
     *s->top=e;
     s->top++;
    }
    void poph(hh *s,int *e)
    {
     if(s->top==s->base)exit(0);
     *e=*--s->top;
    }
    void Init(stack *s){
     s->base=(train*)malloc(20*sizeof(train));
     if(s->base==NULL)exit(0);
     s->top=s->base;
     s->num=20;
    }
    void push(stack *s,train e)
    {
     if(s->top-s->base>=s->num)
     {
      s->base=(train*)realloc(s->base,(s->num+10)*sizeof(train));
      if(s->base==NULL)exit(0);
      s->num=s->num+10;
     }
     *s->top=e;
     s->top++;
    }
    void pop(stack *s,train *e)
    {
     if(s->top==s->base)exit(0);
     *e=*--s->top;
    }
    void print(hh *h)
    {
     hh *t;
     t=(hh*)malloc(sizeof(hh));
     Inith(t); 
     while(h->base!=h->top)
     {
      int nn;
      poph(h,&nn);
      printf("%d",nn);
      pushh(t,nn);
     }
     printf("\n");
     while(t->base!=t->top)
     {
      int nn;
      poph(t,&nn);
      pushh(h,nn);
     }
    }
    int biaozhun(hh *h)
    {
     hh *t;
     t=(hh*)malloc(sizeof(hh));
     Inith(t);
     int bj=1,i;
     int shu=0;
     shu=h->top-h->base;
     //当堆栈数没有数量装够时,使用堆栈数的个数判断
     if(n>shu)
     {
      for(i=1;i<=shu;i++)
      {
       
       int nn;
       poph(h,&nn);
       if(nn==1){bj=0;}
       pushh(t,nn);
      }
      for(i=1;i<=shu;i++)
      {
       int nn;
       poph(t,&nn);
       pushh(h,nn);
      }
     }
     else
     {
      for(i=1;i<=n;i++)
      {
       
       int nn;
       poph(h,&nn);
       if(nn==1){bj=0;}
       pushh(t,nn);
      }
      for(i=1;i<=n;i++)
      {
       int nn;
       poph(t,&nn);
       pushh(h,nn);
      }

     }
     //返回1代表满足条件,0代表不满足
     if(bj==1)
     {
      return 1;
     }
     else
     {
      return 0;
     }
    }
    void pailei(int n){
     
     int i;
     hh *h;
     h=(hh*)malloc(sizeof(hh));
     Inith(h);
     
     int wz=2;
     int zon=0;
     pushh(h,1);
     //zon判断是否小于0,小于0不能出车
     zon=1;
     do
     {
      for(i=wz;i<=2*n-1;i++)
      {
      
       if(zon>0)
       {
        pushh(h,-1);
        zon--;
       }
       else
       {
        pushh(h,1);
        zon++;
       }

      }
      pushh(h,-1);
      moni(h);
      printf("-------------------------------------------\n");
      //显示标记
      //print(h);
      zon--;
      //bj==1时说明出来了火车,js为计数器
      int bj=0,js=0;
      //这里有问题
      if(biaozhun(h)==0)
      {
       while(1)
       {
        js++;
        int n;
        poph(h,&n);
        if(n==1)
        {
         zon--;
         bj=1;
        }
        if(n==-1)
        {
         zon++;
        }
        if(bj==1&&n==-1)
         break;
       }
       //把最后一个能变成-1变成1;
       pushh(h,1);
       zon++;
       //位置赋值wz;
       wz=2*n-js+2;
      }
      
     }while(biaozhun(h)==0);  
    }
    void moni(hh *h){
     hh *temp=(hh*)malloc(sizeof(hh));
     int i;
     stack *s1,*s2,*s3;
     s1=(stack*)malloc(sizeof(stack));
     s2=(stack*)malloc(sizeof(stack));
     s3=(stack*)malloc(sizeof(stack));
     Init(s1);
     Init(s2);
     Init(s3);
     for(i=n;i>0;i--)
     {
      train t1;
      t1.n=i;
      t1.p=0;
      push(s1,t1);
     }
     //while(!quan(s3,n))
     
     Inith(temp);
     //提取数据
     while(h->base!=h->top)
     {
      int nu;
      poph(h,&nu);
      pushh(temp,nu);
     }
     //压回数据
     while(temp->base!=temp->top)
     {
      int nu;
      poph(temp,&nu);
      //当是1则进车,-1则出车
      if(nu==1){
       train t;
       pop(s1,&t);
       printf("第%d号车进入停车位置\n",t.n);
       push(s2,t);
      }
      else
      {
       train t;
       pop(s2,&t);
       printf("第%d号出车并进入轨道\n",t.n);
       push(s3,t);
      }
      //把进出车标记压回
      pushh(h,nu);
     }
     //显示运行顺序
     stack *st;
     st=(stack*)malloc(sizeof(stack));
     Init(st);
     while(s3->base!=s3->top)
     {
      train trr;
      pop(s3,&trr);
      push(st,trr);   
     }
     printf("最后轨道运行时顺序为:");
     
     while(st->base!=st->top)
     {
      train trr;
      pop(st,&trr);
      printf("%d",trr.n);
     }
     printf("\n");
     //free(st);
     free(s1);
     free(s3);
     free(s2);
     free(temp);
    }
    void main(){
     printf("输入几辆车\n");
     scanf("%d",&n);
     pailei(n);
    }

     

     

    展开全文
  • 代码如下: package DataStrcture.StackDemo; import java.util.Scanner; public class ArrToStack{ ///定义数组以数组的大小, 类的构造方法 ...//怎么能忘了的指针呢? int MAXSIZE; public .

    代码如下:

    package DataStrcture.StackDemo;
    
    import java.util.Scanner;
    
    public class ArrToStack{
        ///定义数组以数组的大小, 类的构造方法
        ///注意 ! 在栈中我们规定top指针除了初始状态为-1外,其余时间都是指向栈顶最开头的那个数据
        int[] arr;
        int top = -1;//怎么能忘了栈的指针呢?
        int MAXSIZE;
    
        public ArrToStack(int size){
            this.MAXSIZE = size;
            arr = new int[MAXSIZE];
        }
        工具方法(判空和判满)
        public boolean isEmpty(){
            return top == -1;
        }
    
        public boolean isFull(){
            return top == MAXSIZE -1;
        }
        ///出栈和入栈主方法
        public void push(int num){
            //入栈要判满!
            if(isFull()){
                System.out.println("栈已经满啦! num "+num+"放不进去啦!");
                return;
            }
            top++;
            arr[top] = num;
            System.out.println("入栈成功! ");
        }
        public int pop(){
            ///出栈要判空!
            if(isEmpty()){
                throw new RuntimeException("当前栈已经空了,无法继续取元素了! ");
            }
            int val = arr[top];
            top--;
            return val;
        }
        遍历并输出栈的内容
        public void list(){
            if(isEmpty()){
                throw new RuntimeException("当前栈已经空了,无法继续取元素了!");
            }
            for (int i=top; i >=0; i--){
                System.out.println(arr[i]);
            }
        }
    
        public static void main(String[] args) {
            ArrToStack stack = null;
            Scanner scanner = new Scanner(System.in);
    
    
            while(true){
    
                System.out.printf("\t ===============菜单=================\n");
                System.out.printf("\t 请输入下面指令执行程序: \n");
                System.out.printf("\t a: 指定栈的长度并对栈进行初始化 \n" );
                System.out.printf("\t b: 往栈中插入数据 \n" );
                System.out.printf("\t c: 出栈一个元素 \n" );
                System.out.printf("\t d: 直接打印出栈中的所有内容 \n" );
                System.out.printf("\t e: 退出程序 \n" );
                System.out.printf("\t ====================================\n");
    
                char res = scanner.next().charAt(0);
                switch(res){
                    case 'a':
                        System.out.println("请输入栈的长度: ");
                        int size = scanner.nextInt();
                        stack = new ArrToStack(size);
                        System.out.println("栈初始化完成! ");
                        break;
    
                    case 'b':
                        System.out.println("请输入要压入栈中的数字: ");
                        int num = scanner.nextInt();
                        stack.push(num);
    
                        break;
    
                    case 'c':
                        System.out.println("当前出栈的元素为: "+stack.pop());
                        break;
    
                    case 'd':
                        System.out.println("栈中的元素如下: ");
                        stack.list();
                        break;
    
                    case 'e':
                        System.out.println("程序已退出 ");
                        System.exit(0);
                }
            }
    
        }
    }
    

    运行结果:

    在这里插入图片描述

    展开全文
  • 经常在笔试的时候会看见这样类似...以一道题目为例给大家讲讲这道题目应该怎么做: 题目:一个的输入顺序是a,b,c,d,e则下列序列中不可能是出栈顺序是() A:e,d,a,c,b B:a,e,d,c,b C:b,c,d,a,e D:b,c,a,d,e 解答...

    经常在笔试的时候会看见这样类似的笔试题,就是关于一个栈的输入顺序是a,b,c,d,e则下列序列中不可能是出栈顺序.很多人都知道栈是先进后出,但是还是做好这道题.

    以一道题目为例给大家讲讲这道题目应该怎么做:

    题目:一个栈的输入顺序是a,b,c,d,e则下列序列中不可能是出栈顺序是()

    A:e,d,a,c,b

    B:a,e,d,c,b

    C:b,c,d,a,e

    D:b,c,a,d,e

    解答这题选择:A

    先从B开始解释,B中,由于输入顺序是a,b,c,d,e所以,B中可以栈先输入a然后a出,然后输入b,c,d,e那么上述出栈顺序就是e,d,c,b;

    C中栈先输如a,b,c则此时c出,b出.这时候d输入,那么a先进所以a后处,此时d出然后a出,最后e进e出.

    D中栈先输入a,b则输出可以是b先出,c近c出,然后是a出,d近d出,最后才是e出.

    A中应该是a,b,c,d,e一起输入,此时e出,d出,a不可能比c先出所以这个错了.正确的出栈顺序应该是e,d,c,b,a.

    当然出栈顺序也可以是a,b,c,d,e这时候是进去一个出栈一个.a进a出,b进b出,c进c出,d进d出,e进e出,所以最后顺序就是a,b,c,d,e.

    转载于:https://www.cnblogs.com/my-blogs-for-everone/p/6183223.html

    展开全文
  • printf("输出为%d\n",q); q--; } } void menu() { printf(" ********************************************* \n"); printf(" * 0.创建 * *1.销毁 * \n"); printf(" *****************************...
  • (1) 构建一定数目(自定)的,用于存储相应社团成员;每一个的容量(自定且固定)为该社团可招收成员的最大数目。 (2) 构建一个等待队列,用于存放尚未被招收的学生;...(7) 输出所有社团及其成员信息。
  • 回溯法与树的遍历 ...我不解的是第一次执行完output函数后该怎么办,如果继续执行下面的语句,即b.length--和递归函数,那第二次输出的集合显然与答案不符,求大神指点,我记得老师说过还有什么出栈的过程,求指导
  • 单调模板

    2020-06-09 09:27:16
    单调 顾名思义就是里的元素是单调的。 但是这个怎么使用呢?怎么就能是单调的呢?看下面的例题 题目 给定一个长度为N的整数数列,输出每个数左边第一个比它小的数,如果不存在则输出-1。 输入样例: 5 3 4 2 7 ...

    单调栈

    顾名思义就是栈里的元素是单调的。

    但是这个怎么使用呢?怎么就能是单调的呢?看下面的例题

    题目
    给定一个长度为N的整数数列,输出每个数左边第一个比它小的数,如果不存在则输出-1
    输入样例:

    5
    3 4 2 7 5

    输出样例:

    -1 3 -1 2 2

    题目意思很容易理解
    那么我们先来看暴力做法,每次取一个数,与前面的数比较

    for(int i=0;i<n;i++{
    	for(int j=1;j=i;j++)
    	{
    		if(a[j]>=a[j-1])
    		{
    			break;
    		}
    	}
    }
    

    我们考虑最坏的情况,当序列为降序序列时,例如:

    5
    5 4 3 2 1

    5的话不进循环
    4的话与5比较
    3与4和5比较
    2与3、4和5进行比较
    1与2、3、4和5进行比较

    观察我们可以发现,我们就需要取出每个数,然后遍历一遍这个数之前的所有数。
    时间复杂度为O(n^2),oj数据范围都是n<=1e5,评测机1s内运算数据量是1e8~1e9,我们对1e10的数据量是不能接受的,因此我们需要对做法进行优化。这个时候我们就引入单调栈。

    以输入样例为例来模拟一下单调栈
    3 4 2 7 5

    我们顺序遍历,从前往后看

    先看3,前面没有比他小的放入栈中
    再看4,然后与栈顶元素比较,发现满足条件,那么输出栈顶元素,然后将4入栈
    再看2,同样与栈顶元素比较,但是栈顶元素比2大,那么我们就需要pop出栈,然后再与栈顶元素比较,直到找到比2小的元素,或者是栈空时结束,然后我们需要判断栈是否为空,栈空就输出-1,栈不空那么就说明找到了比2小的元素,即输出栈顶元素,最后将2入栈
    再看7,比较栈顶元素,小于栈顶元素,那么输入栈顶元素,入栈
    最后看5,比较弹出栈顶元素,然后再比较,发现满足条件,输出栈顶元素

    我们再看一下栈中元素的变化过程
    3
    3 4
    2
    2 7
    2 5

    这个时候就会发现栈中的元素是从栈底到栈顶是单调递增的。这也就是为什么叫做单调栈!!!

    模板代码

    #include<iostream>
    using namespace std;
    const int N=1e5+5;
    int a[N],stk[N],n,tt=0;
    int main()
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++) scanf("%d",a+i);
        for(int i=0;i<n;i++)
        {
            while(tt&&a[i]<=stk[tt]) --tt;
            if(tt) printf("%d ",stk[tt]);
            else printf("-1 ");
            stk[++tt]=a[i];
        }
        return 0;
    }
    
    展开全文
  • python日志记录错误traceback

    千次阅读 2019-01-17 10:03:52
    logging模块是Python内置的标准模块,主要用于输出运行日志,可以设置输出日志的等级、日志保存路径、日志文件回滚等;相比print,具备如下优点:...logging则可以由开发者决定将信息输出到什么地方,以及怎么输出;...
  • 本题可能溢出,辛苦同学们提交语言选择c++,并在代码的第一行加上: `#pragma comment(linker, "/STACK:1024000000,1024000000") ` Output 对于每组数据,首先输出一行”Case #?:”,在问号处应填入当前...
  • 单调萌新讲解

    2018-08-08 09:01:39
    怎么开始介绍这个单调是一个小问题。。。所以就直接讲他的功能了:在入栈时遵循单调原则,可以求出一个元素向左和向右所能扩展的最大长度(&gt;=或者&lt;=这个元素); 具体操作: 例1:求一个元素的右侧...
  • //表示的节点是怎么连接到根节点的? } if(k==2){ st[top].rchild=p; } } } j++; ch=arr[j]; } } public void dispbtree(Node1 b){//输出二叉树...
  • 排序(空间复杂度O(1))

    千次阅读 2018-09-20 00:31:42
    如果要将空间复杂度为O(1),那么就...比如,一个输出栈S,输入R,我们每次将输入的元素push进入输出栈S,但是因为我们的输出栈元素需要排序,假定从底到栈顶按照从小到大的顺序排列,那么我们如果输入的的...
  • 看到一个题,是说用实现队列的效果,我想的是用两个1输出2,再输出,大家帮我看一下,这个程序的最后输出怎么是[b,1],输入的3哪去了? import java.util.Enumeration; import java.util.Stack; ...
  • 不要着急,接下来我们看看是怎么得到后缀表达式的。当遇到数字时,直接输出,遇到符号入栈,在入栈之前需要判断各操作符的优先级大小,判断规则如下。===外&gt;内: 将外操作符入栈===外&lt;内: ...
  • 利用实现进制转换问题

    千次阅读 2019-05-05 13:49:40
    建立顺序或链栈,编写程序实现十进制数到二进制数的转换。 输入 输入只有一行,就是十进制整数。 输出 转换后的二进制数。 样例输入 10 样例输出 1010 十进制怎么转为二进制?十进制转二进制怎么转? ...
  • [51Nod1952]

    2019-10-05 09:39:26
    首先考虑如果没有后端删除怎么做, 直接开一个普通, 一个单调, 一边模拟一边算. 因为没有后端删除, 所以你维护一个单调队列就可以了. 需要用到一些实现上的细节技巧. 就是单调数据结构删除不是很好模拟. 考虑开一...
  • 浅谈的使用:模拟

    2018-01-15 22:32:43
    的存储方式是后进先出,怎么理解后进先出呢?即数据以1 2 3的形式进入,3 2 1的形式输出。正着进倒着出就是,所以我们就可以用来模拟这种过程。以一道例题来讲 Description There is a famous railway ...
  • [数学、] 整数反转

    2020-05-14 17:38:07
    题目描述 给出一个 32 位的有符号整数,你需要...如果是一个字符串,怎么反转?使用思想,字符顺序入栈再出栈,就能得到反转的字符串。 数字也是同理的,使用思想,但是多一步溢出的考虑。 每一位的数字入栈...
  • 文章目录单调什么是单调有什么用怎么办到的例题关键代码输出单调队列什么是单调队列有什么用怎么办到的例题关键代码输出 单调 什么是单调 从栈顶到底的元素是严格递增(or递减) 有什么用 例如,求前i-1项...
  • 括号匹配,是的一个重要的应用,在表达式求值中也应用十分广泛。就是检查左右括号是否匹配。 来看看一道LeetCode问题,你就明白是怎么回事了。 题目简述 给定一个只包含 ‘(’,’)’,’{’,’}’,’[‘和’]'...
  • 如何实现字符串的反转,如:输入abc,输出cba 如何实现字符串的反转...用来实现.利用它的先进后出的特点.  ------解决方案-------------------- Java code String str = "abc"; String reStr = new StringBui
  • poj 3494单调

    2020-03-30 22:45:09
    首先你要明白poj2559是怎么做的,然后如果你只看这个矩阵的第一行,那么他就是poj2559的那个问题,只是每个矩形高度要么是0要么是1。如果你看前两行,那么他也是poj2559的那个问题,以此类推,我相信你...
  • 线性表关心数据怎么样保存 关心数据有什么操作 (stack) 有些地方称为堆栈,是一种容器,可存入数据元素、访问元素、删除元素, 它的特点在于只能允许在容器的一端(称为顶端指标,英语:top)进行加入数据...
  • 今日第二道题,一道我没怎么读懂题意的题。上题: 题目描述 定义的数据结构,请在该类型中实现一个能够得到中所含最小元素的min函数(时间复杂度应为O(1))。 注意:保证测试中不会当为空的时候,对调用...
  • (stack),也可以称成为堆栈,是一种可以存放,访问及删除数据元素的容器。它的特点在于只能允许在容器的一端(栈顶:top)进行加入数据(push)和...与链表和顺序表的区别在于:描述的的对数据元素怎么操作...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 289
精华内容 115
关键字:

栈怎么输出