[已解决]为什么用不了stl库里的栈 啊

2207122216

用了说找不到这个头文件，但是这不是c++自带的吗

1. #include "Stack.h"
   
2. #include <iostream>
   
3. #include <stdlib.h>                //exit函数要用到
   
4. using namespace std;
   
5. struct Box        //将每个迷宫格子看成是一个结构体
   
6. {
   
7.     int x, y, di;
   
8.     //x和y分别代表迷宫格子的横纵坐标，di为当前的方向
   
9. };
   
10. struct Direction        //构建结构体
    
11. {
    
12.     int incX, incY;
    
13. };
    
14. 
    
15. 
    
16. typedef struct Node                //这是栈节点
    
17. {
    
18.     Box data;
    
19.     struct Node* pNext;
    
20. }Node, *PNODE;
    
21. 
    
22. class Stack
    
23. {
    
24.     private:
    
25.     PNODE pTop;
    
26.     PNODE pBottom;
    
27. 
    
28.     public:
    
29.         Stack();
    
30.         void initStack(Stack*);
    
31.         void pushStack(Stack*, Box);
    
32.         
    
33.         //将栈中的栈底元素返回并移除，用递归来实现栈逆序遍历的
    
34.         Box getElement(Stack&, Box&);
    
35.         void reverse(Stack&, Box&);
    
36.         
    
37.         void traverse(Stack*);
    
38.         void pop(Stack*, Box&);
    
39.         bool isEmpty(Stack*);
    
40. };
    
41. 
    
42. 
    
43. 
    
44. Stack::Stack()
    
45. {
    
46.     //ctor
    
47. }
    
48. 
    
49. void Stack::initStack(Stack* pS)
    
50. {
    
51.     pS->pTop = new Node;
    
52.     if(nullptr == pS->pTop){
    
53.         cout << "动态内存分配失败！" << endl;
    
54.         exit(-1);
    
55.     }
    
56.     else{
    
57.         pS->pBottom = pS->pTop;
    
58.         pS->pTop->pNext = nullptr;
    
59.     }
    
60.     return;
    
61. }
    
62. 
    
63. void Stack::pushStack(Stack* pS, Box temp) //temp是将一个结构体整体入栈
    
64. {
    
65.     PNODE pNew = new Node;
    
66.     pNew->data = temp;
    
67.     pNew->pNext = pS->pTop;
    
68.     pS->pTop = pNew;
    
69. }
    
70. /** 这里开始是逆序遍历栈的关键代码，等会详细讲解 */
    
71. Box Stack::getElement(Stack& s, Box& temp)
    
72. {
    
73.     s.pop(&s, temp);
    
74.     Box res = temp;
    
75.     if(s.isEmpty(&s)) return res;
    
76.     else{
    
77.         Box last = getElement(s, temp);
    
78.         s.pushStack(&s, res);
    
79.         return last;
    
80.     }
    
81. }
    
82. 
    
83. void Stack::reverse(Stack& s, Box& temp)
    
84. {
    
85.     if(s.isEmpty(&s)) return;
    
86.     Box i  = getElement(s, temp);
    
87.     s.reverse(s, temp);
    
88.     s.pushStack(&s, i);
    
89. }
    
90. /****************************************/
    
91. void Stack::traverse(Stack* pS)
    
92. {
    
93.     PNODE p = pS->pTop;                //p是移动指针，在栈顶和栈底间上下移动的
    
94.     while(p != pS->pBottom)
    
95.     {
    
96.         cout << "(" << p->data.x << ", " << p->data.y << ")" << endl;
    
97.         p = p->pNext;
    
98.     }
    
99.     cout << endl;
    
100.     return;
     
101. }
     
102. 
     
103. void Stack::pop(Stack* pS, Box& temp)        //这里的temp一定要 采用引用
     
104. {
     
105.     if(isEmpty(pS)) return;
     
106.     else{
     
107.         PNODE r = pS->pTop;
     
108.         temp = r->data;
     
109.         pS->pTop = r->pNext;
     
110.         free(r);
     
111.         r = NULL;
     
112.         return;
     
113.     }
     
114. }
     
115. 
     
116. bool Stack::isEmpty(Stack* pS)
     
117. {
     
118.     if(pS->pTop == pS->pBottom)
     
119.         return true;
     
120.     else
     
121.         return false;
     
122. }
     
123. 
     
124. 
     
125. bool findPath(Stack& s, int M, int N)
     
126. {
     
127.     int **maze = new int*[M+2];                //动态构造二维数组
     
128.     for(int i = 0; i < 10; i++){
     
129.         maze[i] = new int[N+2];
     
130.     }
     
131. 
     
132.     for(int i = 0; i < M+2; i++){        //动态给定迷宫
     
133.         for(int j = 0; j < N+2; j++){
     
134.             if(i == 0 || i == M+1)
     
135.                 maze[i][j] = 1;
     
136.             else if(j == 0 || j == N+1)
     
137.                 maze[i][j] = 1;
     
138.             else
     
139.                 cin >> maze[i][j];
     
140.         }
     
141.     }
     
142. 
     
143.     Direction direct[4];                //方向数组（文章上面有图有说到）
     
144.     direct[0].incX = 0; direct[0].incY = 1;
     
145.     direct[1].incX = 1; direct[1].incY = 0;
     
146.     direct[2].incX = 0; direct[2].incY = -1;
     
147.     direct[3].incX = -1; direct[3].incY = 0;
     
148. 
     
149.     Box temp;
     
150.     int x, y, di;      //当前正在处理的迷宫格子
     
151.     int line, col;    //迷宫格子预移方向后，下一格子的行坐标、列坐标
     
152.     maze[1][1] = -1;
     
153.     temp.x = 1;
     
154.     temp.y = 1;
     
155.     temp.di = -1;                //起始点直接设置为-1代表该格子已访问过了
     
156.     s.pushStack(&s, temp);
     
157.     while(!s.isEmpty(&s))
     
158.     {
     
159.         s.pop(&s, temp);        //这里对遇到走不通的格子进行回退时起到关键作用
     
160.         x = temp.x; y = temp.y; di = temp.di+1;
     
161.         while(di < 4){  //走不通时，四个方向都尝试一遍
     
162.             line = x + direct[di].incX;
     
163.             col = y + direct[di].incY;
     
164.             if(maze[line][col] == 0){        //代表 预走 的格子可以走
     
165.                 temp.x = x; temp.y = y; temp.di = di;
     
166.                 s.pushStack(&s, temp);
     
167.                 x = line; y = col; maze[line][col] = -1;        //标为-1是为了表明该格子已经走过，回溯时不再处理
     
168.                 if(x == M && y == N){
     
169.                         s.reverse(s, temp);
     
170.                         return true;   //迷宫有路
     
171.                     }
     
172.                 else di = 0;
     
173.             }
     
174.             else di++;
     
175.         }
     
176.     }
     
177.     return false;       //迷宫无路
     
178. }
     
179. 
     
180. int main()
     
181. {
     
182.     int M, N;
     
183.     bool res;
     
184.     cout << "请输入迷宫数组行数和列数：";
     
185.     cin >> M >> N;
     
186.     Stack s;
     
187.     s.initStack(&s);
     
188.     res = findPath(s, M, N);
     
189.     cout << boolalpha << res << endl;        //将bool转换为true/false显示
     
190.     cout << endl;
     
191.     if(res)
     
192.         s.traverse(&s);
     
193.     else
     
194.         cout << "你被困在迷宫中了，等着受死吧！" << endl;
     
195.     return 0;
     
196. }
     
197. 
     

复制代码

最佳答案

月排行榜 / 总排行榜

陶远航

2023-7-7 15:07:00

从你的代码中，我看到你自己实现了一个栈，而没有使用C++标准模板库(STL)中的 std::stack 。如果你想使用STL中的栈，你需要包含 <stack> 头文件，并使用 std::stack 。下面是一个使用STL中的 std::stack 的简化版代码：

1. #include <iostream>
2. #include <stack>
3. #include <vector>
5. using namespace std;
7. struct Box {
8.     int x, y, di;
9. };
11. struct Direction {
12.     int incX, incY;
13. };
15. bool findPath(stack<Box>& s, int M, int N, const vector<vector<int>>& maze) {
16.     Direction direct[4] = {
17.         {0, 1},
18.         {1, 0},
19.         {0, -1},
20.         {-1, 0}
21.     };
23.     int x, y, di;
24.     vector<vector<int>> visited = maze;
25.     visited[1][1] = -1;
26.     s.push({1, 1, -1});
28.     while (!s.empty()) {
29.         Box temp = s.top();
30.         s.pop();
31.         x = temp.x; y = temp.y; di = temp.di + 1;
33.         while (di < 4) {
34.             int line = x + direct[di].incX;
35.             int col = y + direct[di].incY;
37.             if (visited[line][col] == 0) {
38.                 s.push({x, y, di});
39.                 x = line; y = col; visited[line][col] = -1;
41.                 if (x == M && y == N) {
42.                     return true;
43.                 } else {
44.                     di = 0;
45.                 }
46.             } else {
47.                 di++;
48.             }
49.         }
50.     }
51.     return false;
52. }
54. int main() {
55.     int M, N;
56.     cout << "请输入迷宫数组行数和列数：";
57.     cin >> M >> N;
59.     vector<vector<int>> maze(M + 2, vector<int>(N + 2, 1));
60.     for (int i = 1; i <= M; ++i) {
61.         for (int j = 1; j <= N; ++j) {
62.             cin >> maze[i][j];
63.         }
64.     }
66.     stack<Box> s;
67.     bool res = findPath(s, M, N, maze);
68.     cout << boolalpha << res << endl;
70.     if (res) {
71.         while (!s.empty()) {
72.             Box temp = s.top();
73.             s.pop();
74.             cout << "(" << temp.x << ", " << temp.y << ")" << endl;
75.         }
76.     } else {
77.         cout << "你被困在迷宫中了，等着受死吧！" << endl;
78.     }
79.     return 0;
80. }

复制代码

请注意，我已经删除了你自定义的栈类，并用 std::stack 替换了它。同时，我还将原来的二维数组替换为 vector<vector<int>> ，这是一个更现代且易于使用的数据结构。

跳转到最佳答案楼层

陶远航

从你的代码中，我看到你自己实现了一个栈，而没有使用C++标准模板库(STL)中的 std::stack 。如果你想使用STL中的栈，你需要包含 <stack> 头文件，并使用 std::stack 。下面是一个使用STL中的 std::stack 的简化版代码：

1. #include <iostream>
2. #include <stack>
3. #include <vector>
5. using namespace std;
7. struct Box {
8.     int x, y, di;
9. };
11. struct Direction {
12.     int incX, incY;
13. };
15. bool findPath(stack<Box>& s, int M, int N, const vector<vector<int>>& maze) {
16.     Direction direct[4] = {
17.         {0, 1},
18.         {1, 0},
19.         {0, -1},
20.         {-1, 0}
21.     };
23.     int x, y, di;
24.     vector<vector<int>> visited = maze;
25.     visited[1][1] = -1;
26.     s.push({1, 1, -1});
28.     while (!s.empty()) {
29.         Box temp = s.top();
30.         s.pop();
31.         x = temp.x; y = temp.y; di = temp.di + 1;
33.         while (di < 4) {
34.             int line = x + direct[di].incX;
35.             int col = y + direct[di].incY;
37.             if (visited[line][col] == 0) {
38.                 s.push({x, y, di});
39.                 x = line; y = col; visited[line][col] = -1;
41.                 if (x == M && y == N) {
42.                     return true;
43.                 } else {
44.                     di = 0;
45.                 }
46.             } else {
47.                 di++;
48.             }
49.         }
50.     }
51.     return false;
52. }
54. int main() {
55.     int M, N;
56.     cout << "请输入迷宫数组行数和列数：";
57.     cin >> M >> N;
59.     vector<vector<int>> maze(M + 2, vector<int>(N + 2, 1));
60.     for (int i = 1; i <= M; ++i) {
61.         for (int j = 1; j <= N; ++j) {
62.             cin >> maze[i][j];
63.         }
64.     }
66.     stack<Box> s;
67.     bool res = findPath(s, M, N, maze);
68.     cout << boolalpha << res << endl;
70.     if (res) {
71.         while (!s.empty()) {
72.             Box temp = s.top();
73.             s.pop();
74.             cout << "(" << temp.x << ", " << temp.y << ")" << endl;
75.         }
76.     } else {
77.         cout << "你被困在迷宫中了，等着受死吧！" << endl;
78.     }
79.     return 0;
80. }

复制代码

请注意，我已经删除了你自定义的栈类，并用 std::stack 替换了它。同时，我还将原来的二维数组替换为 vector<vector<int>> ，这是一个更现代且易于使用的数据结构。

isdkz

根据你给出的代码，你已经实现了一个自定义的 Stack 类，而这个 Stack 类并不是 C++ Standard Template Library (STL) 中的标准库。实际上，你的 Stack 类是基于链表的数据结构实现的。

如果你想使用 C++ STL 中的 stack ，你应该使用如下的方式包含头文件：

1. #include <stack>
   

复制代码

然后你就可以像这样使用 STL 中的 stack：

1. std::stack<int> s;  // 创建一个整数类型的栈
   
2. s.push(10);         // 把一个整数压入栈
   
3. int top = s.top();  // 获取栈顶元素
   
4. s.pop();            // 弹出栈顶元素
   

复制代码

所以如果你看到 "找不到这个头文件" 的错误，可能是因为你错误地包含了 "Stack.h"，而不是  <stack> 。确保你在代码中使用正确的库。

另外，值得注意的是，STL 中的  stack  是一个容器适配器，实际的底层数据结构可以是  deque （默认）或者  vector ， list  等其他序列容器。如果你想用链表实现的栈，也可以选择 STL 中的  list 。

2207122216

陶远航 发表于 2023-7-7 15:07
从你的代码中，我看到你自己实现了一个栈，而没有使用C++标准模板库(STL)中的 std::stack 。如果你想使用ST ...

谢谢，但是有个小问题就是 vector<vector<int>>中间少了空格应该是 vector<vector<int> >

歌者文明清理员

isdkz 发表于 2023-7-7 15:09
根据你给出的代码，你已经实现了一个自定义的 Stack 类，而这个 Stack 类并不是 C++ Standard Template Lib ...

算了，我也加入gpt大军吧

isdkz

歌者文明清理员 发表于 2023-7-7 15:20
算了，我也加入gpt大军吧

zhangjinxuan

歌者文明清理员 发表于 2023-7-7 15:20
算了，我也加入gpt大军吧