数据结构 station

问题描述

　　一天，小 L 突然对列车的进出站问题产生了兴趣，如下图所示：
列车只能从 A 进站，或从 B 出站。
列车从 A 进站，进站顺序为 1, 2, 3, 4, 5
列车从 B 出站，出站顺序为 5, 4, 3, 2, 1
现在，小 L 想知道：
列车从 A 进站，进站顺序为 1~n
列车从 B 出站，给定出站的顺序，判断是否可能按照这个顺序出站

★数据输入
　　第一行一个正整数 n（1<=n<=1000）。
　　第二行包含 n 个正整数，为 1~n 的某个排列

★数据输出
　　若能够按照给定的顺序出站，输出”YES” （没有引号）
　　否则，输出” NO” （没有引号）

 

解题思路

　　思路一：判断出栈序列中，比本数小的数是否按降序排列

　　　　　　时间复杂度O(n^2)，本题1<=n<=1000，可用

　　　　　　易写，不易错，效率低

　　思路二：使用栈模拟进栈出栈

　　　　　　时间复杂度O(n)

　　　　　　易写错，效率高

 

code

　　solve 1

 1 #include 
 2 #include 
 3 
 4 bool popAble(int *p,int len)
 5 {
 6     int i,j;
 7     for(i=0; i1; i++)
 8     {
 9         int last = p[i];
10         for(j=i+1;j)
11         {
12             if(p[j]<p[i])
13             {
14                 if(p[j]<last)
15                     last = p[j];
16                 else
17                     return false;
18             }
19         }
20     }
21     return true;
22 }
23 
24 int main()
25 {
26     int n,i;
27     scanf("%d", &n);
28     int *p = (int *)malloc(sizeof(int)*n);
29     for(i=0; i)
30         scanf("%d", p+i);
31     
32     if(popAble(p,n))
33         printf("YES\n");
34     else
35         printf("NO\n");
36     
37     free(p);
38     return 0;
39 } 

　　

　　 solve 2

 1 #include 
 2 #include 
 3 
 4 #define ERROR 0x7fffffff 
 5 #define TYPE int
 6 
 7 class MyStack//std::stack
 8 {
 9 public:
10     MyStack(int _maxsize):maxsize(_maxsize),size(0){arr = (TYPE *)malloc(sizeof(TYPE)*maxsize);}
11     ~MyStack() { free(arr); }
12     bool empty() { return size==0; }
13     TYPE top() { return arr[size-1]; }//每次用top()前应先调用empty()，判断是否为空 
14     void pop() { --size; }//本题掉pop()前都有调top()与empty()，可保证不为空 
15     void push(TYPE num) { arr[size++] = num; }//构造传入maxsize，保证不爆栈 
16 private:
17     int maxsize;
18     int size;
19     TYPE *arr;
20 };
21 
22 
23 
24 int main()
25 {
26     int n,i,j;
27     scanf("%d", &n);
28     int *p = (int *)malloc(sizeof(int)*n);//若想再省空间，此数组可省，但可读性降低 
29     MyStack s(n);
30     
31     
32     for(i=0; i)
33         scanf("%d", p+i);
34     
35     for(i=1,j=0;i<=n;)
36     {
37         if(i==p[j])
38         {
39             i++;
40             j++;
41         }
42         else if(!s.empty() && s.top()==p[j])
43         {
44             s.pop();
45             j++;
46         }
47         else
48         {
49             s.push(i);
50             i++;
51         }
52     }
53     
54     while(!s.empty())
55     {
56         if(s.top()==p[j])
57         {
58             j++;
59             s.pop();
60         }
61         else
62         {
63             printf("NO\n");
64             free(p);
65             return 0;
66         }
67     }
68     printf("YES\n");
69     
70     free(p);
71     return 0;
72 } 

 

转载于:https://www.cnblogs.com/cbattle/p/7633423.html