STL stack menyediakan fungsionalitas struktur data tumpukan di C++.

Struktur data tumpukan berikut: LIFO (Last In First Out) prinsip. Artinya, elemen yang ditambahkan terakhir akan dihapus terlebih dahulu.

Struktur Data Tumpukan

Untuk mempelajari lebih lanjut tentang tumpukan, kunjungi tutorial kami di Stack Data Structure.

Membuat Stack

Untuk membuat tumpukan di C++, pertama-tama kita harus menyertakan stack berkas kepala.

#include <stack>

Setelah kami mengimpor file ini, kami dapat membuat stack menggunakan sintaks berikut:

stack<type> st;

Di Sini, type menunjukkan tipe data perintah ini perintah ini ingin kita simpan di stack. Misalnya,

// create a stack of integers
 stack<int> integer_stack; 
// create a stack of strings
stack<string> string_stack;

Contoh: C++ STL Stack

#include <iostream>

#include <stack>

using namespace std;

int main {
    // create a stack of strings

stack<string> languages;

    
    // add element to the Stack
    languages.push("C++");
    languages.push("Java");
    languages.push("Python");
    
    // print top element
    cout << languages.top;

    return 0;
}

Output

Python

Dalam contoh di atas, kami telah membuat stack dari string bernama bahasa .

Di sini, kami telah menggunakan push untuk menambahkan elemen ke tumpukan. Kami kemudian menggunakan top untuk menampilkan elemen teratas.

Kami akan belajar lebih banyak tentang push dan top nanti di tutorialnya.

Metode Tumpukan

Dalam C++, stack class menyediakan berbagai metode untuk melakukan operasi yang berbeda pada stack.

Operasi Keterangan
push menambahkan elemen ke dalam tumpukan
pop menghapus elemen dari tumpukan
top mengembalikan elemen di bagian atas tumpukan
size mengembalikan jumlah elemen dalam tumpukan
empty kembali true jika tumpukan kosong

Tambahkan Elemen Ke dalam Tumpukan

Kita gunakan push untuk menambahkan elemen ke dalam tumpukan. Sebagai contoh,

#include <iostream>

#include <stack>

using namespace std;

int main {

  // create a stack of strings
  stack<string> colors;

// mendorong elemen ke dalam tumpukan colors.push(“Red”); colors.push(“Orange”);

  
  cout << "Stack: ";

  // print elements of stack
   while(!colors.empty) {
    cout << colors.top << ", ";
    colors.pop;
  }
 
  return 0;
}

Output

Stack: Orange, Red, 

Dalam contoh di atas, kami telah membuat setumpuk string yang disebut warna. Kemudian, kami telah menggunakan push untuk menambahkan elemen ke tumpukan.

colors.push("Red");
colors.push("Orange");

Alih-alih langsung mencetak konten tumpukan, kami telah menggunakan while loop dan berbagai metode stack.

while(!colors.empty) {
  cout << colors.top << ", ";
  colors.pop;
}

Untuk mencetak semua elemen tumpukan, kami mencetaknya top element lalu pop(hapus) di dalam loop. Proses ini terus berulang hingga tumpukan kosong.

Kita akan belajar tentang pop, top dan empty di bagian-bagian yang akan datang.

Perhatikan juga bahwa kami telah memasukkan elemen dalam urutan ini: {“Red”, “Orange”}.

Tetapi saat mencetak elemen, kami mendapatkan {“Orange”, “Red”}.

Hal ini karena stack merupakan struktur data LIFO, yang berarti elemen yang dimasukkan terakhir akan diambil terlebih dahulu.

Catatan: Tidak seperti vektor atau wadah lainnya, kami tidak dapat menggunakan rentang for loop untuk beralih melalui tumpukan. Ini karena tumpukan STL adalah Adaptor Kontainer STL, yang menyediakan akses terbatas untuk membuatnya berperilaku seperti struktur data tumpukan standar.

Hapus Elemen Dari Stack

Kami dapat menghapus elemen dari tumpukan menggunakan pop. Sebagai contoh,

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

// function prototype this command this command for display_stack utility
void display_stack(stack<string> st);

int main {

  // create a stack of strings
  stack<string> colors;

  // push elements into the stack
  colors.push("Red");
  colors.push("Orange");
  colors.push("Blue");
  
  cout << "Initial Stack: ";
  // print elements of stack
  display_stack(colors);

// menghapus “Blue” seperti yang disisipkan terakhir colors.pop;

  
  cout << "Final Stack: ";

  // print elements of stack
  display_stack(colors);
  
  return 0;
}

// utility function to display stack elements
void display_stack(stack<string> st) {

  while(!st.empty) {
    cout << st.top << ", ";
    st.pop;
  }

  cout << endl;
}

Output

Initial Stack: Blue, Orange, Red, 
Final Stack: Orange, Red,

Dalam contoh di atas, kami telah menggunakan pop untuk menghapus elemen dari tumpukan.

Awalnya, isi tumpukan adalah {“Blue”, “Orange”, “Red”}.

Kemudian kami telah menggunakan pop untuk menghapus elemen.

// removes top element
colors.pop 

Ini menghilangkan elemen di atas stack yaitu elemen yang disisipkan terakhir, yaitu “Blue”.

Oleh karena itu, tumpukan terakhir menjadi {“Orange”, “Red”}.

Akses Elemen Dari Stack

Kami mengakses elemen di bagian atas tumpukan menggunakan top. Sebagai contoh,

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

int main {

  // create a stack of strings
  stack<string> colors;

  // push element into the stack
  colors.push("Red");
  colors.push("Orange");
  colors.push("Blue");
  
  // get top element

string top = colors.top;

  cout << "Top Element: " << top;
  
  return 0;
}

Output

Top Element: Blue

Dalam contoh di atas, kami telah membuat setumpuk string yang disebut warna dan menambahkan elemen berikut: “Red”, “Orange” dan “Blue”.

Kami kemudian menggunakan top untuk mengakses elemen teratas:

string top = colors.top; 

Di Sini, “Blue” dimasukkan terakhir, jadi itu top element.

Dapatkan Ukuran Tumpukan

Kita gunakan size untuk mendapatkan jumlah elemen dalam stack. Sebagai contoh,

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

int main {

  // create a stack of int
  stack<int> prime_nums;

  // push elements into the stack
  prime_nums.push(2);
  prime_nums.push(3);
  prime_nums.push(5);

// dapatkan ukuran tumpukan int size = prime_nums.size;

  cout << "Size of the stack: " << size;

  return 0;
}

Output

Size of the stack: 3

Dalam contoh di atas, kita telah membuat setumpuk bilangan bulat yang disebut prime_nums dan menambahkan tiga elemen ke dalamnya.

Kemudian kami telah menggunakan size untuk menemukan jumlah elemen dalam tumpukan:

prime_nums.size;

Karena kami telah menambahkan 3 elemen ke tumpukan, prime_nums.size kembali 3.

Periksa apakah Stack Kosong

Kita gunakan empty untuk memeriksa apakah tumpukan kosong. Metode ini mengembalikan:

  • 1(true)– jika tumpukan kosong
  • 0(false)– jika tumpukan tidak kosong

Sebagai contoh,

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

int main {

  // create a stack of double
  stack<double> nums;
  
  cout << "Is the stack empty? ";

// periksa apakah tumpukan kosong if (nums.empty) {

    cout << "Yes" << endl;
  }
  else {
    cout << "No" << endl;
  }

  cout << "Pushing elements..." << endl;

  // push element into the stack
  nums.push(2.3);
  nums.push(9.7);
 
  cout << "Is the stack empty? ";

// periksa apakah tumpukan kosong if (nums.empty) {

    cout << "Yes";
  }
  else {
    cout << "No";
  }

  return 0;
}

Output

Is the stack empty? Yes
Pushing elements...
Is the stack empty? No

Dalam contoh di atas, kami telah menggunakan empty untuk menentukan apakah stack kosong,

if(nums.empty) { // returns false
  cout << "Yes" << end;;
}
else {
  cout << "No" << endl; 
}

Awalnya, tumpukan tidak memiliki elemen di dalamnya. Jadi nums.empty kembali true.

Kami kemudian menambahkan elemen ke tumpukan.

Sekali lagi, kami menggunakan nums.empty untuk menentukan apakah tumpukan kosong. Kali ini, ia kembali false.

Di atas adalah informasi tentang Cara Menggunakan C++ Stack Untuk mempelajari lebih lanjut tentang stack [Detailed Guide]. Jika Anda memiliki pertanyaan, silakan bertanya fixsy.org dalam komentar di bawah. Saya senang membantu Anda.