Question

我有以下程序。检查两个堆栈是否等于它们包含的值的最佳，最有效的方法是什么？

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<form action="">
    <div>
      <label for="name"></label>
      <input type="text" id="name" name="user_name" placeholder="  Full Name">
    </div>
    <div>
      <label for="mail"></label>
      <input type="email" id="mail" name="user_mail" placeholder="  Email Address">
    </div>
    <div>
      <label for="message"></label>
      <textarea name="user_message" id="message" cols="30" rows="10" placeholder="  Let me know what's on your mind"></textarea>
    </div>
    <div class="sendButton">
      <button class="btn" type="submit" disabled="disabled">Send</button>
    </div>
  </form>

如果堆栈包含相同的数字但顺序不同，那么该方法应该返回true ..如果你能给我一些指导，我将非常感谢。谢谢你的建议。

Answer 1

考虑

如果堆栈包含等效数字但顺序不同，则该方法应返回true

我认为最佳解决方案是通过排序和比较。

从每个堆栈中提取数据

k1 = {data of lhs}     -> O(n)
k2 = {data of rhs}     -> O(n)

对两个数组进行排序

k1_sorted = sort(k1)   -> O(n log(n))
k2_sorted = sort(k2)   -> O(n log(n))

现在您可以比较O（n）中的两个排序数组。请记住k1_sorted和k2_sorted中可能重复的数字。

Answer 2

除了排序方法，您还可以采用计数方法：

#include <string>
#include <iostream>
#include <vector>
#include <map>


/**
 * Returns true iff the two vectors contain the same elements
 * (including number of duplicates) in any order.
 *  
 * Alternatively std::sort both vectors and just compare them
 * for equality, which may or may not be faster.
 */
bool sortOfEquivalent(const std::vector<int>& lhs, const std::vector<int>& rhs)
{
    std::map<int, std::pair<int,int>> accumulator;

    for (const auto x : lhs) {
        accumulator[x].first++;
    }

    for (const auto x : rhs) {
        accumulator[x].second++;

        if (accumulator[x].second > accumulator[x].first) {
            // Can bail early here; the RHS already has
            // more x's than the LHS does
            return false;
        }
    }

    for (const auto& y : accumulator) {
        if (y.second.first != y.second.second)
            return false;
    }

    return true;
}

int main()
{
    std::vector<int> lhs{3,5,5,7,1};
    std::vector<int> rhs{1,2,3,4,5,6,7};

    std::cout << sortOfEquivalent(lhs, rhs);
}

根据您的数据，这可能会或可能不会快于排序方法。它也可能会或可能不会比排序方法占用更少的存储空间。

实际上，您可能会在第二个循环中引用accumulator[x]而不是三次查找该元素。

但是，如果将堆栈视为非堆栈，即使用其基础数据存储（需要转发迭代），则只能将此解决方案应用于您的情况。这可能允许也可能不允许。

Answer 3

在外部，您的函数处理堆栈，但实现堆栈的实际结构是一个简单的链表。

比较两个链接列表是通过逐个比较每个元素来完成的，当列表用完或者你发现元素不同时停止。

比较堆栈数据结构c ++

3 个答案: