Toán tử quan hệ

#include <stack>

// Với a và b là hai stack cùng kiểu và cùng underlying container:
template <class T, class Container>
bool operator==(const stack<T, Container>& a, const stack<T, Container>& b);

template <class T, class Container>
bool operator!=(const stack<T, Container>& a, const stack<T, Container>& b);

template <class T, class Container>
bool operator<(const stack<T, Container>& a, const stack<T, Container>& b);

template <class T, class Container>
bool operator>(const stack<T, Container>& a, const stack<T, Container>& b);

template <class T, class Container>
bool operator<=(const stack<T, Container>& a, const stack<T, Container>& b);

template <class T, class Container>
bool operator>=(const stack<T, Container>& a, const stack<T, Container>& b);

So sánh hai std::stack với nhau.

Tham số

a, b

• Hai std::stack cần so sánh. Chúng phải có cùng kiểu phần tử và cùng kiểu underlying container.

Giá trị trả về

Trả về true nếu biểu thức so sánh là đúng, false nếu sai.

Đặc điểm

1. So sánh từ điển: Các toán tử quan hệ thực hiện so sánh từ điển, không phải so sánh giá trị tổng của các phần tử.
2. Phụ thuộc vào toán tử quan hệ của kiểu phần tử và container: Việc so sánh các phần tử của std::stack sử dụng các toán tử quan hệ tương ứng của kiểu phần tử, và việc so sánh dựa trên so sánh các underlying container. Do đó, kiểu phần tử của std::stack phải hỗ trợ các toán tử quan hệ và underlying container cũng cần phải hỗ trợ.
3. Toán tử !=: Toán tử != trả về kết quả ngược lại với toán tử ==.
4. Các toán tử khác được định nghĩa dựa trên < và ==: Các toán tử >, <=, >= được định nghĩa dựa trên kết quả của < và ==.
5. Không làm thay đổi stack: Các toán tử này không thay đổi nội dung của 2 stack đang được so sánh.
6. Độ phức tạp: Độ phức tạp của việc so sánh hai std::stack là O(n), với n là số lượng phần tử của std::stack ngắn hơn.

Giải thích chi tiết về phép so sánh từ điển

1. So sánh từng cặp phần tử: Các toán tử quan hệ sẽ so sánh từng cặp phần tử tương ứng của hai std::stack, bắt đầu từ phần tử ở đỉnh stack.
2. Kết quả của phép so sánh đầu tiên khác nhau: Ngay khi gặp cặp phần tử đầu tiên khác nhau, kết quả của phép so sánh hai std::stack sẽ được quyết định bởi kết quả của phép so sánh hai phần tử đó. Ví dụ, nếu stack1.top() < stack2.top() thì stack1 < stack2 là true, bất kể các phần tử còn lại.
3. Chiều dài khác nhau: Nếu một std::stack là tiền tố (prefix) của std::stack kia (nghĩa là tất cả các phần tử của std::stack ngắn hơn đều bằng các phần tử tương ứng của std::stack dài hơn), thì std::stack ngắn hơn được coi là nhỏ hơn.
4. Bằng nhau: Hai std::stack được coi là bằng nhau nếu chúng có cùng kích thước và tất cả các phần tử tương ứng đều bằng nhau.

Ví dụ

#include <iostream>
#include <stack>
#include <vector>

int main() {
  std::stack<int> stack1;
  stack1.push(1);
  stack1.push(2);
  stack1.push(3);

  std::stack<int> stack2;
  stack2.push(1);
  stack2.push(2);
  stack2.push(3);

  std::stack<int> stack3;
  stack3.push(1);
  stack3.push(2);
  stack3.push(4);

  std::stack<int> stack4;
  stack4.push(1);
  stack4.push(2);

  std::cout << "stack1 == stack2: " << (stack1 == stack2) << '\n'; // Output: stack1 == stack2: 1 (true)
  std::cout << "stack1 != stack3: " << (stack1 != stack3) << '\n'; // Output: stack1 != stack3: 1 (true)
  std::cout << "stack1 < stack3: " << (stack1 < stack3) << '\n';   // Output: stack1 < stack3: 1 (true)
  std::cout << "stack4 < stack1: " << (stack4 < stack1) << '\n';   // Output: stack4 < stack1: 1 (true)
  std::cout << "stack1 > stack4: " << (stack1 > stack4) << '\n';   // Output: stack1 > stack4: 1 (true)
  std::cout << "stack1 >= stack2: " << (stack1 >= stack2) << '\n'; // Output: stack1 >= stack2: 1 (true)
  std::cout << "stack1 <= stack3: " << (stack1 <= stack3) << '\n'; // Output: stack1 <= stack3: 1 (true)

  return 0;
}

Các hàm liên quan

swap	Hoán đổi nội dung của hai std::stack với nhau