#include <iostream> #include <stack> using namespace std; int main() { stack<int> s; int arr[] = {1, 2, 3, 4, 5}; // 原数据序列 int n = sizeof(arr) / sizeof(int); // 将所有元素连续压入栈 for (int i = 0; i < n; i++) { s.push(arr[i]); } // 将栈中的所有元素依次出栈并输出 while (!s.empty()) { cout << s.top() << " "; s.pop(); } return 0; }将这段代码中的序列改成可自己输入

好的，你可以参考以下代码，其中cin输入的数字需要自己输入，每输入一个数字按回车键确认，输入完毕后输入-1结束输入。

#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;
    int num;
    cout << "Please enter the numbers: " << endl;
    while (cin >> num && num != -1) {
        s.push(num);
    }
    while (!s.empty()) {
        cout << s.top() << " ";
        s.pop();
    }
    return 0;
}

希望能够帮到你！

相关问题

用递归函数或使用堆栈生成排列组合数。测试用例： 1) {A, B, C, D, E, F, G, H}中任取三个元素的组合数

递归函数实现：

#include <iostream>
#include <vector>
using namespace std;

void combination(vector<char>& arr, vector<char>& res, int pos, int num)
{
    if (num == 0) {
        // 输出组合结果
        for (char c : res) {
            cout << c << " ";
        }
        cout << endl;
        return;
    }
    for (int i = pos; i <= arr.size() - num; i++) {
        res.push_back(arr[i]);
        combination(arr, res, i + 1, num - 1);
        res.pop_back();
    }
}

int main()
{
    vector<char> arr = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
    int num = 3;
    vector<char> res;
    combination(arr, res, 0, num);
    return 0;
}

使用堆栈实现：

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

void combination(vector<char>& arr, int num)
{
    stack<int> s;
    s.push(0);
    while (!s.empty()) {
        int pos = s.top();
        s.pop();
        if (num == 0) {
            // 输出组合结果
            for (int i = 1; i < s.size(); i++) {
                cout << arr[s.top()] << " ";
                s.pop();
            }
            cout << endl;
        }
        for (int i = pos; i < arr.size(); i++) {
            s.push(i + 1);
            combination(arr, num - 1);
        }
    }
}

int main()
{
    vector<char> arr = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
    int num = 3;
    combination(arr, num);
    return 0;
}

（次大值之和）给定一个 1 到 n 的数字各出现一次的排列 a[1]、a[2]、···、 a[n],定义 f(1,r)表示 a[1]、a[1+1]、a[1+2]···、a[r]中的次大值，你需要求 出对于所有的 1<=i<j<=n(n<=100000),f(i,j)的和

首先，我们可以观察到次大值会在每个元素被选作最大值后出现。因此，我们可以遍历数组，对于每个元素 a[i]，找到它右边第一个比它大的元素位置 j，那么 f(i, j-1) 就是 a[i] 的次大值。

算法的关键在于如何高效地找到这个位置 j。我们可以使用一个栈来辅助计算。我们遍历数组，对于每个元素 a[i]，我们将其与栈顶元素比较，如果 a[i] 大于栈顶元素，那么栈顶元素的次大值就是 a[i]，我们将栈顶元素出栈，并计算 f(stack[top-1]+1, i-1) 的贡献，然后继续比较 a[i] 和新的栈顶元素。如果 a[i] 小于等于栈顶元素，我们将 a[i] 入栈，继续遍历下一个元素。

这样，我们可以通过一次遍历找到所有 f(i, j) 的值，并将它们累加起来。

以下是使用 C++ 实现的代码：

#include <iostream>
#include <stack>
using namespace std;

long long calculateSum(int arr[], int n) {
    stack<int> st;
    long long sum = 0;
    
    for (int i = 0; i < n; i++) {
        while (!st.empty() && arr[i] > arr[st.top()]) {
            int top = st.top();
            st.pop();
            
            if (!st.empty()) {
                sum += arr[st.top()];
            }
        }
        st.push(i);
    }
    
    return sum;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    long long sum = calculateSum(arr, n);
    
    cout << "Sum of f(i, j) for all 1 <= i < j <= n: " << sum << endl;
    
    return 0;
}

该代码的时间复杂度为 O(n)，其中 n 是数组的长度。