Stack adalah struktur data yang mengikuti prinsip LIFO (terakhir, pertama keluar). Dalam erti kata lain, elemen terakhir yang kita tambahkan pada timbunan adalah yang pertama dikeluarkan. Apabila kita menambah (atau menolak) unsur ke timbunan, mereka diletakkan di atas; iaitu di atas semua elemen tambah sebelumnya.

Mungkin ada senario tertentu di mana kita perlu menambah elemen di bahagian bawah timbunan. Terdapat pelbagai cara untuk menambah elemen ke bahagian bawah timbunan. Mereka adalah -

• Menggunakan timbunan tambahan
• menggunakan rekursi
• menggunakan pembolehubah sementara
• menggunakan barisan

Menggunakan timbunan tambahan

kita boleh memasukkan elemen di bahagian bawah timbunan menggunakan timbunan tambahan (timbunan sekunder dengan menggunakan operasi) di Java. Di sini, kami akan menggunakan dua susunan (timbunan utama dan timbunan tambahan) untuk memasukkan elemen di bahagian bawah timbunan utama.

timbunan utama akan mempunyai unsur -unsur asal, sementara timbunan tambahan akan membantu kita menyusun semula unsur -unsur. Kaedah ini mudah difahami.

Langkah

berikut adalah langkah -langkah untuk memasukkan elemen di bahagian bawah timbunan menggunakan timbunan tambahan:

• Inisialisasi dua susunan: Buat timbunan utama tolak beberapa elemen di dalamnya dan kemudian buat timbunan tambahan.
• Pop semua elemen: kemudian keluarkan semua elemen dari timbunan utama dan tolak mereka ke dalam timbunan tambahan kedua. Ini akan membantu kita membalikkan urutan elemen.
• Tolak elemen baru: Apabila timbunan utama kosong, kita perlu menolak elemen baru ke dalam timbunan utama atau anda juga boleh menolak elemen di atas timbunan tambahan jika anda mahu.
• Pulihkan urutan asal: pop semua elemen dari timbunan tambahan dan tolak mereka kembali ke timbunan utama. Ini akan memulihkan urutan elemen asal.

Contoh

berikut adalah contoh bagaimana kita boleh menggunakan timbunan tambahan untuk menambah elemen di bahagian bawah -

import java.util.Stack;
public class InsertAtBottomUsingTwoStacks {    
   public static void insertElementAtBottom(Stack<Integer> mainStack, int x) {
      // Create an extra auxiliary stack
      Stack<Integer> St2 = new Stack<>();
      
      /* Step 1: Pop all elements from the main stack 
      and push them into the auxiliary stack */
      while (!mainStack.isEmpty()) {
         St2.push(mainStack.pop());
      }

      // Step 2: Push the new element into the main stack
      mainStack.push(x);

      /* Step 3: Restore the original order by popping each 
      element from the auxiliary stack and push back to main stack */
      while (!St2.isEmpty()) {
         mainStack.push(St2.pop());
      }
   }
   public static void main(String[] args) {
      Stack<Integer> stack1 = new Stack<>();
      stack1.push(1);
      stack1.push(2);
      stack1.push(3);
      stack1.push(4);

      System.out.println("Original Stack: " + stack1);
      insertElementAtBottom(stack1, 0);
      System.out.println("Stack after inserting 0 at the bottom: " + stack1);
   }
}

Dalam program di atas, kita mulakan dengan menolak unsur -unsur 1, 2, 3, dan 4 ke dalam timbunan. Kemudian, kami memindahkan unsur -unsur ini ke timbunan lain. Selepas itu, kami memasukkan elemen sasaran ke dalam timbunan utama. Akhirnya, kami mengambil semua elemen dari timbunan tambahan.

menggunakan rekursi

rekursi adalah satu lagi cara untuk memasukkan elemen di bahagian bawah timbunan. Dalam pendekatan ini, kami akan menggunakan fungsi rekursif untuk memunculkan semua elemen dari timbunan kami sehingga ia menjadi kosong, dan apabila ia menjadi kosong, kami akan memasukkan elemen baru ke dalam timbunan, dan kemudian menolak unsur -unsur kembali ke dalam timbunan.

Langkah

Berikut adalah langkah -langkah untuk memasukkan elemen di bahagian bawah timbunan menggunakan rekursi:

• Kes asas: Semak jika timbunan kosong. Jika ia kosong, kami akan menolak elemen baru ke dalam timbunan.
• kes rekursif: Jika timbunan tidak kosong, kami akan memaparkan elemen teratas dan memanggil fungsi secara rekursif.
• memulihkan unsur -unsur: Setelah selesai dengan memasukkan elemen baru, kita perlu menolak unsur -unsur yang muncul sebelumnya ke dalam timbunan.

Contoh

import java.util.Stack;
public class InsertAtBottomUsingTwoStacks {    
   public static void insertElementAtBottom(Stack<Integer> mainStack, int x) {
      // Create an extra auxiliary stack
      Stack<Integer> St2 = new Stack<>();
      
      /* Step 1: Pop all elements from the main stack 
      and push them into the auxiliary stack */
      while (!mainStack.isEmpty()) {
         St2.push(mainStack.pop());
      }

      // Step 2: Push the new element into the main stack
      mainStack.push(x);

      /* Step 3: Restore the original order by popping each 
      element from the auxiliary stack and push back to main stack */
      while (!St2.isEmpty()) {
         mainStack.push(St2.pop());
      }
   }
   public static void main(String[] args) {
      Stack<Integer> stack1 = new Stack<>();
      stack1.push(1);
      stack1.push(2);
      stack1.push(3);
      stack1.push(4);

      System.out.println("Original Stack: " + stack1);
      insertElementAtBottom(stack1, 0);
      System.out.println("Stack after inserting 0 at the bottom: " + stack1);
   }
}

Dalam program di atas, kami menentukan fungsi rekursif yang memasukkan elemen baru di bahagian bawah timbunan, kami terus memaparkan unsur -unsur dari timbunan sehingga timbunan menjadi kosong, maka kami memasukkan elemen baru dan selepas itu , kami memulihkan unsur -unsur sebelumnya ke dalam timbunan.

menggunakan pembolehubah sementara

kita juga boleh mencapai tugas yang diberikan menggunakan pemboleh ubah sementara. Kami menggunakan pembolehubah ini untuk menyimpan unsur -unsur semasa kami memanipulasi timbunan. Kaedah ini mudah dan kita boleh melaksanakan menggunakan gelung mudah. ??

Langkah

berikut adalah langkah -langkah untuk memasukkan elemen di bahagian bawah timbunan menggunakan pembolehubah sementara & lt;

• Mulakan pembolehubah sementara: Buat pembolehubah untuk sementara memegang unsur -unsur seperti yang anda lalui melalui timbunan.
• elemen pemindahan: kemudian gunakan gelung untuk elemen pop dari timbunan dan simpan unsur -unsur tersebut dalam pembolehubah sementara.
• Masukkan elemen baru: Setelah timbunan kita kosong, maka kita perlu menolak elemen baru ke dalam timbunan.
• Pulihkan Elemen: Setelah memasukkan elemen, tolak unsur -unsur dari pembolehubah sementara kembali ke timbunan.

Contoh

import java.util.Stack;
public class InsertAtBottomUsingRecursion {
   public static void insertAtElementBottom(Stack<Integer> st, int x) {
      // Base case: If the stack is empty, push the new element
      if (st.isEmpty()) {
         st.push(x);
         return;
      }
      // Recursive case: Pop the top element
      int top = st.pop();
      
      // Call the function recursively
      insertAtElementBottom(st, x);
      
      // Restore the top element into the stack
      st.push(top);
   }
   
   public static void main(String[] args) {
      Stack<Integer> st = new Stack<>();
      st.push(1);
      st.push(2);
      st.push(3);
      st.push(4);
   
      System.out.println("Original Stack: " + st);
      insertAtElementBottom(st, 0);
      System.out.println("Stack after inserting 0 at the bottom: " + st);
   }
}

Dalam program ini, kami menggunakan array sementara untuk memegang unsur -unsur sambil memanipulasi timbunan. Kami kemudian memasukkan elemen baru ke dalam timbunan dan memulihkan unsur -unsur asal ke dalam timbunan.

menggunakan barisan

Dalam pendekatan ini, kami akan menggunakan barisan untuk memegang unsur -unsur sementara semasa memasukkan elemen baru di bahagian bawah timbunan. Kaedah ini adalah cara yang lebih baik untuk menguruskan susunan elemen. Menggunakan giliran kita boleh elemen baru ke timbunan tanpa mengganggu elemen yang sedia ada.

Langkah

berikut adalah langkah -langkah untuk memasukkan elemen di bahagian bawah timbunan menggunakan barisan -

• Inisialisasi barisan: Buat giliran untuk memegang unsur -unsur dari timbunan.
• elemen pemindahan: pop elemen dari timbunan dan enqueue mereka ke dalam barisan.
• Masukkan elemen baru: tolak elemen baru ke dalam timbunan.
• memulihkan unsur -unsur: menanggung unsur -unsur dari barisan dan menolaknya kembali ke dalam timbunan.

Contoh

import java.util.Stack;
public class InsertAtBottomUsingTempVar {
public static void insertAtElementBottom(Stack<Integer> st, int x) {
   // Temporary variable to hold elements
   int[] temp = new int[st.size()];
   int index = 0;

   // Transfer elements to temporary variable
   while (!st.isEmpty()) {
      temp[index++] = st.pop();
   }

   // Push the new element into the stack
   st.push(x);

   // Restore elements from temporary variable
   for (int i = 0; i < index; i++) {
      st.push(temp[i]);
   }
}
public static void main(String[] args) {
   Stack<Integer> st = new Stack<>();
   st.push(1);
   st.push(2);
   st.push(3);
   st.push(4);

   System.out.println("Original Stack: " + st);
   insertAtElementBottom(st, 0);
   System.out.println("Stack after inserting 0 at the bottom: " + st);
}
}

output

berikut adalah output kod di atas -

import java.util.Stack;
public class InsertAtBottomUsingTwoStacks {    
   public static void insertElementAtBottom(Stack<Integer> mainStack, int x) {
      // Create an extra auxiliary stack
      Stack<Integer> St2 = new Stack<>();
      
      /* Step 1: Pop all elements from the main stack 
      and push them into the auxiliary stack */
      while (!mainStack.isEmpty()) {
         St2.push(mainStack.pop());
      }

      // Step 2: Push the new element into the main stack
      mainStack.push(x);

      /* Step 3: Restore the original order by popping each 
      element from the auxiliary stack and push back to main stack */
      while (!St2.isEmpty()) {
         mainStack.push(St2.pop());
      }
   }
   public static void main(String[] args) {
      Stack<Integer> stack1 = new Stack<>();
      stack1.push(1);
      stack1.push(2);
      stack1.push(3);
      stack1.push(4);

      System.out.println("Original Stack: " + stack1);
      insertElementAtBottom(stack1, 0);
      System.out.println("Stack after inserting 0 at the bottom: " + stack1);
   }
}

Dalam pelaksanaan ini, kami menggunakan barisan untuk memegang unsur -unsur untuk masa sementara. Kami mula -mula memindahkan unsur -unsur sedia ada dari timbunan ke barisan. Kemudian, kami menolak elemen baru ke dalam timbunan dan memulihkan unsur -unsur asal dari barisan kembali ke timbunan

NOTA: kita boleh menggunakan struktur data lain seperti array, linkedlist, arraylist, dan lain -lain. Bukannya giliran.

Atas ialah kandungan terperinci Program Java untuk memasukkan elemen di bahagian bawah timbunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!