How do I remove duplicates with std::stack?

In C++, if you want to remove duplicates using a std::stack, you typically need to use an additional data structure to track the unique elements. Below is an example of how you can achieve this:

#include #include #include void removeDuplicates(std::stack& inputStack) { std::unordered_set seen; // To keep track of seen elements std::stack tempStack; // Temporary stack to hold unique elements // Transfer elements and filter duplicates while (!inputStack.empty()) { int current = inputStack.top(); inputStack.pop(); if (seen.find(current) == seen.end()) { // If not seen, add to unique stack seen.insert(current); tempStack.push(current); } } // Restore original stack with unique elements while (!tempStack.empty()) { inputStack.push(tempStack.top()); tempStack.pop(); } } int main() { std::stack numbers; numbers.push(1); numbers.push(2); numbers.push(2); numbers.push(3); numbers.push(1); removeDuplicates(numbers); // Print unique elements while (!numbers.empty()) { std::cout << numbers.top() << " "; numbers.pop(); } return 0; }

keywords: C++ std::stack remove duplicates programming data structures

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?