C# стек с Push & Pop примери

по: Бенджамин Уокър Бенджамин Уокър
Hours Обновено

⚡ Умно обобщение

Stack в C# е колекция от именуването System.Collections, която следва принципа „последен влязъл, първи излязъл“ (LIFO), където методът Push добавя елемент отгоре, а методът Pop го премахва.

  • ???? Концепция LIFO: Стекът работи като купчина книги, така че последният избутан елемент е първият, който се премахва.
  • ➕ Натиснете и попнете: Методът Push добавя елемент към върха на стека, а методът Pop премахва и връща този най-горен елемент.
  • 👀 Преглед, Броене, Съдържа: Методът Peek чете най-горния елемент, без да го премахва, докато Count и Contains отчитат размера и членството.
  • 🧪 Разработени примери: Две конзолни програми демонстрират Push с Count и Contains, след което Pop, така че можете tracд. поръчката LIFO.
  • 🛠️ Общ стек: Стекът Класът в System.Collections.Generic добавя безопасност на типа по време на компилация и избягва „боксирането“ за нов C# код.
  • 🤖 AI помощ: GitHub Copilot скефълира C# Stack операции, а ML.NET чете данни чрез типизирани колекции, вместо чрез негенеричен стек.
Прочетете повече

C# стек

Какво е стек в C#?

Стекът е колекция от специални случаи, която представлява концепцията „последен влязъл, първи излязъл“ (LIFO). За да разберем първо LIFO, нека вземем пример. Представете си купчина книги, всяка една върху друга.

Концепцията „последна влязла първа излязла“ в случай на книги означава, че само най-горната книга може да бъде премахната от купчината книги. Не е възможно да премахнете книга между тях, защото тогава това би нарушило настройката на стека.

Следователно в C#, стекът също работи по същия начин. Елементите се добавят към стека, един върху друг. Процесът на добавяне на елемент към стека се нарича push операция. За да премахнете елемент от стек, можете също да премахнете най-горния елемент от стека. Тази операция е известна като pop.

Нека разгледаме по-подробно операциите, налични за колекцията Stack.

Декларация на стека

Стекът се създава с помощта на типа Stack Data. Ключовата дума „нов“ се използва за създаване на обект от стек. След това обектът се присвоява на променливата st.

Stack st = new Stack()

Добавяне на елементи към стека

Методът push се използва за добавяне на елемент към стека. Общият синтаксис на израза е даден по-долу.

Stack.push(element)

Премахване на елементи от стека

Методът pop се използва за премахване на елемент от стека. Операцията pop ще върне най-горния елемент на стека. Общият синтаксис на израза е даден по-долу

 Stack.pop()

Броя

Това свойство се използва за получаване на броя на елементите в стека. По-долу е общият синтаксис на този израз.

Stack.Count

Съдържа

Този метод се използва, за да се види дали даден елемент присъства в стека. По-долу е общият синтаксис на този израз. Изявлението ще върне true, ако елементът съществува, в противен случай ще върне стойността false.

Stack.Contains(element)

Сега нека видим как това работи на ниво код. Целият код, споменат по-долу, ще бъде написан на нашия Конзолно приложение. Кодът ще бъде записан в нашия файл Program.cs.

В програмата по-долу ще напишем кода, за да видим как можем да използваме гореспоменатите методи.

Пример 1: Метод Stack.Push().

В този пример ще видим

  • Как се създава стек.
  • Как да покажете елементите на стека и да използвате методите Count и Contain.

Стек в C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);

   foreach (Object obj in st)
   {
    Console.WriteLine(obj);
   }
    Console.WriteLine(); Console.WriteLine();
    Console.WriteLine("The number of elements in the stack " +st.Count);
    Console.WriteLine("Does the stack contain the elements 3 "+st.Contains(3));
    Console.ReadKey();
  }
 }
}

Code Обяснение:

  1. Първата стъпка се използва за деклариране на стека. Тук декларираме „st“ като променлива за съхранение на елементите на нашия стек.
  2. След това добавяме 3 елемента към нашия стек. Всеки елемент се добавя чрез метода Push.
  3. Сега, тъй като елементите на стека не могат да бъдат достъпни чрез позицията на индекса като списък с масиви, трябва да използваме различен подход за показване на елементите на стека. Обектът (obj) е временна променлива, която е декларирана за съхранение на всеки елемент от стека. След това използваме оператора foreach, за да преминем през всеки елемент от стека. За всеки елемент на стека стойността се присвоява на променливата obj. След това използваме командата Console.Writeline, за да покажем стойността на конзолата.
  4. Ние използваме свойството Count (ст.брой), за да получите броя на елементите в стека. Това свойство ще върне число. След това показваме тази стойност на конзолата.
  5. След това използваме метода Contains, за да видим дали стойността на 3 присъства в нашия стек. Това ще върне стойност true или false. След това показваме тази върната стойност на конзолата.

Ако горният код е въведен правилно и програмата се изпълнява, ще се покаже следният изход.

Изход:

Стек в C#

От изхода можем да видим, че елементите на стека са показани. Също така, стойността на True се показва, за да каже, че стойността на 3 е дефинирана в стека.

Забележка: Забелязахте, че последният елемент, избутан в стека, се показва първи. Това е най-горният елемент на стека. Броят на елементите на стека също се показва в изхода.

Пример 2: Метод Stack.Pop().

Сега нека да разгледаме функцията „премахване“. Ще видим кода, необходим за премахване на най-горния елемент от стека.

Стек в C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);
   
   st.Pop();

   foreach (Object obj in st)
   {
    Console.WriteLine(obj);
   }
    Console.ReadKey();
  }
 }
}

Code Обяснение:

  1. Тук просто издаваме метода pop, който се използва за премахване на елемент от стека.

Ако горният код е въведен правилно и програмата се изпълнява, ще се покаже следният изход.

Изход:

Стек в C#

Виждаме, че елемент 3 е премахнат от стека.

СВЪРЗАНИ СТАТИИ

C# метод Stack Peek()

Методите Push и Pop работят с върха на стека, но понякога е необходимо само да погледнете най-горния елемент, без да го премахвате. Методът Peek прави точно това. Той връща най-горната стойност на стека, като оставя колекцията непроменена, което е полезно, когато искате да тествате следващия елемент, преди да решите да го извадите.

Стъпка 1) Създайте стек и поставете три елемента върху него, така че стойността 3 да е отгоре.

Стъпка 2) Извикайте метода Peek, за да прочетете горния елемент, след което проверете свойството Count, за да потвърдите, че нищо не е премахнато.

using System;
using System.Collections;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);
   Console.WriteLine(st.Peek());
   Console.WriteLine(st.Count);
   Console.ReadKey();
  }
 }
}

Code Обяснение:

  1. Декларира се стек с име st и стойностите 1, 2 и 3 се сумират с метода Push, така че 3 става най-горният елемент.
  2. Методът Peek връща най-горния елемент, без да го премахва, а свойството Count все още отчита пълния брой елементи в стека.

Когато програмата се изпълни, тя отпечатва стойността 3 от Peek и след това броят 3, което доказва, че елементът остава в стека. Ако стекът е празен, Peek хвърля InvalidOperationException, така че е безопасно да проверите Count преди да го извикате.

Общ стек в C#

Горните примери използват негенеричния клас Stack от System.Collections, който съхранява всеки елемент като обект. Съвременният C# код обикновено предпочита генеричния Stack. клас от пространството от имена System.Collections.Generic. Той свързва стека с един деклариран тип, така че компилаторът проверява всяко Push и Pop и не е необходимо преобразуване или боксиране.

Основните предимства на генеричния Stack са изброени по-долу.

  • Безопасност на типа: Типът е фиксиран при декларацията, така че само стойности от този тип могат да бъдат изпращани, а грешките се улавят по време на компилация.
  • Без бокс: Типовете стойности като int се съхраняват директно, което избягва разходите за опаковане, които плаща негенеричният стек.
  • Чистачът гласи: Pop и Peek връщат декларирания тип директно, така че не се преобразува резултатът обратно от object.
using System;
using System.Collections.Generic;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack<string> st = new Stack<string>();
   st.Push("Java");
   st.Push("Python");
   Console.WriteLine(st.Pop());
   Console.ReadKey();
  }
 }
}

В този пример стекът е деклариран като Stack , така че приема само низови стойности. Методът Pop връща низ директно и отпечатва Python, последната изпратена стойност. За всеки нов проект, общият Stack е препоръчителният избор.

Разлика между стека и опашката в C#

Стек и опашка са и двете колекции, които контролират реда, в който елементите се премахват, но използват противоположни правила. Стекът е „последен влязъл, първи излязъл“, докато опашката е „първа влязла, първа излязла“. Изборът на правилната колекция прави намерението на вашия код ясно за другите разработчици.

Основните разлики са изброени по-долу:

  • Поръчка: Стекът премахва първо най-скоро добавения елемент (LIFO), докато опашката премахва първо най-стария елемент (FIFO).
  • Методи: Стекът използва Push и Pop, докато опашката използва Enqueue за добавяне и Dequeue за премахване.
  • Достъп до най-горния елемент: Стекът чете следващия си елемент с Peek, а опашката чете следващия си елемент с Peek отпред.
  • Типични употреби: Стековете отговарят на функциите за отмяна, оценка на изрази и рекурсия tracкрал, докато опашките отговарят на планиране, буфериране и преминаване в ширина.

И двата вида са налични в обща форма като Stack и опашка в System.Collections.Generic, така че получавате безопасност на типа с всеки от двата избора.

Въпроси и Отговори

Извикването на Pop или Peek на празен стек хвърля Invalid.OperationException. Първо проверете свойството Count или използвайте генеричните методи на Stack TryPop и TryPeek, които връщат false, вместо да хвърлят, когато стекът не съдържа елементи.

Push и Pop се изпълняват за константно време O(1), защото докосват само върха на стека. Когато вътрешният масив трябва да расте, от време на време Push го преоразмерява, но средната цена на операция остава постоянна.

Не. Стекът показва само върха си чрез Peek и Pop, така че няма индексен аксесор като списък. За да прочетете всяка стойност, избройте стека с цикъл foreach или го копирайте, използвайки метода ToArray.

Методът Clear премахва всеки елемент от стека с едно извикване и нулира Count. За да премахвате елементите един по един отгоре, извикайте Pop в цикъл, докато Count достигне нула.

Стандартният клас Stack не е безопасен за нишки при записи, когато няколко нишки го променят едновременно. За едновременен достъп използвайте ConcurrentStack от System.Collections.Concurrent, който предлага атомни методи TryPush и TryPop без външни заключвания.

Извикайте метода ToArray, за да копирате стека в нов масив, подреден отгоре надолу. Можете също така да предадете стека на конструктор на List, за да изградите обобщен списък, докато keeping същия ред.

Да. GitHub Copilot пише декларации на Stack, извиквания на Push и Pop, както и цикли foreach от кратък коментар или име на метод. Често предлага генеричната версия на Stack, тъй като това е препоръчителната колекция за нов C# код.

Стековете рядко съхраняват данни за обучение на ML.NET, които преминават през типизирани колекции и конвейера IDataView. Концепцията за LIFO стек обаче се появява в алгоритмите за машинно обучение за обратно изобразяване.tracкрал, търсене в дълбочина и управление на рекурсивни извиквания на методи.

Обобщете тази публикация с: