Csharp/C Sharp/Collections Data Structure/Stack

A stack class for characters

/*
C#: The Complete Reference 
by Herbert Schildt 
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// A stack class for characters.   
  
using System;  
  
class Stack {   
  // these members are private 
  char[] stck; // holds the stack  
  int tos;     // index of the top of the stack  
   
  // Construct an empty Stack given its size.  
  public Stack(int size) {   
    stck = new char[size]; // allocate memory for stack  
    tos = 0;   
  }   
  
  // Push characters onto the stack.  
  public void push(char ch) {   
    if(tos==stck.Length) {   
      Console.WriteLine(" -- Stack is full.");   
      return;   
    }   
       
    stck[tos] = ch;  
    tos++;  
  }   
   
  // Pop a character from the stack.  
  public char pop() {   
    if(tos==0) {   
      Console.WriteLine(" -- Stack is empty.");   
      return (char) 0;    
    }   
     
    tos--;   
    return stck[tos];   
  } 
 
  // Return true if the stack is full. 
  public bool full() { 
    return tos==stck.Length;    
  } 
 
  // Return true if the stack is empty. 
  public bool empty() { 
    return tos==0; 
  } 
 
  // Return total capacity of the stack. 
  public int capacity() { 
    return stck.Length; 
  } 
 
  // Return number of objects currently on the stack. 
  public int getNum() { 
    return tos; 
  } 
}  
// Demonstrate the Stack class.   
 
public class StackDemo31 {   
  public static void Main() {   
    Stack stk1 = new Stack(10);   
    Stack stk2 = new Stack(10);   
    Stack stk3 = new Stack(10);   
    char ch;   
    int i;   
   
    // Put some characters into stk1. 
    Console.WriteLine("Push A through Z onto stk1."); 
    for(i=0; !stk1.full(); i++)   
      stk1.push((char) ("A" + i));   
  
    if(stk1.full()) Console.WriteLine("stk1 is full."); 
 
    // Display the contents of stk1. 
    Console.Write("Contents of stk1: ");   
    while( !stk1.empty() ) {    
      ch = stk1.pop();   
      Console.Write(ch);   
    }   
   
    Console.WriteLine();   
 
    if(stk1.empty()) Console.WriteLine("stk1 is empty.\n"); 
   
    // put more characters into stk1   
    Console.WriteLine("Again push A through Z onto stk1."); 
    for(i=0; !stk1.full(); i++)   
      stk1.push((char) ("A" + i));   
 
    /* Now, pop from stk1 and push the element in stk2. 
       this causes stk2 to hold the elements in  
       reverse order. */ 
    Console.WriteLine("Now, pop chars from stk1 and push " + 
                      "them onto stk2."); 
    while( !stk1.empty() ) {    
      ch = stk1.pop();   
      stk2.push(ch); 
    }   
 
    Console.Write("Contents of stk2: ");   
    while( !stk2.empty() ) {    
      ch = stk2.pop();   
      Console.Write(ch);   
    }   
 
    Console.WriteLine("\n"); 
 
    // put 5 characters into stack 
    Console.WriteLine("Put 5 characters on stk3."); 
    for(i=0; i < 5; i++)   
      stk3.push((char) ("A" + i));   
 
    Console.WriteLine("Capacity of stk3: " + stk3.capacity()); 
    Console.WriteLine("Number of objects in stk3: " + 
                      stk3.getNum()); 
    
  }   
}

Demonstrate the Stack class

/*
C#: The Complete Reference 
by Herbert Schildt 
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Demonstrate the Stack class. 
 
using System; 
using System.Collections; 
  
public class StackDemo5 { 
  static void showPush(Stack st, int a) { 
    st.Push(a); 
    Console.WriteLine("Push(" + a + ")"); 
 
    Console.Write("stack: "); 
    foreach(int i in st) 
      Console.Write(i + " "); 
 
    Console.WriteLine();         
  } 
 
  static void showPop(Stack st) { 
    Console.Write("Pop -> "); 
    int a = (int) st.Pop(); 
    Console.WriteLine(a); 
 
    Console.Write("stack: "); 
    foreach(int i in st) 
      Console.Write(i + " "); 
 
    Console.WriteLine();         
  } 
 
  public static void Main() { 
    Stack st = new Stack(); 
 
    foreach(int i in st) 
      Console.Write(i + " "); 
 
    Console.WriteLine();         
 
    showPush(st, 22); 
    showPush(st, 65); 
    showPush(st, 91); 
    showPop(st); 
    showPop(st); 
    showPop(st); 
 
    try { 
      showPop(st); 
    } catch (InvalidOperationException) { 
      Console.WriteLine("Stack empty."); 
    } 
  } 
}

illustrates the use of a Stack

/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
  Example11_11.cs illustrates the use of a Stack
*/
using System;
using System.Collections;
public class Example11_11
{
  public static void Main()
  {
    // create a Stack object
    Stack myStack = new Stack();
    // add four elements to myStack using the Push() method
    myStack.Push("This");
    myStack.Push("is");
    myStack.Push("a");
    myStack.Push("test");
    // display the elements in myStack
    foreach (string myString in myStack)
    {
      Console.WriteLine("myString = " + myString);
    }
    // get the number of elements in myStack using the
    // Count property
    int numElements = myStack.Count;
    for (int count = 0; count < numElements; count++)
    {
      // examine an element in myStack using Peek()
      Console.WriteLine("myStack.Peek() = " +
        myStack.Peek());
      // remove an element from myStack using Pop()
      Console.WriteLine("myStack.Pop() = " +
        myStack.Pop());
    }
  }
}

Implements the stack data type using an array

using System;
public class Stack {
  private int[] data;
  private int size;
  private int top = -1;
  public Stack() { 
    size = 10;
    data = new int[size];
  }
  public Stack(int size) {
    this.size = size;
    data = new int[size];
  }       
  public bool IsEmpty() {
    return top == -1;
  }
  public bool IsFull() {
    return top == size - 1;
  }
  public void Push(int i){
    if (IsFull())
      throw new ApplicationException("Stack full");
    else
      data[++top] = i;
  }
  public int Pop(){
    if (IsEmpty())
       throw new StackEmptyException("Stack empty");
    else
       return data[top--];
  }
  public int Top(){
    if (IsEmpty()) 
      throw new StackEmptyException("Stack empty");
    else
      return data[top];
  }
  public static void Main() {
    try {
      Stack stack1 = new Stack(); 
      stack1.Push(4);
      stack1.Push(5);
      Console.WriteLine("The top is now {0}", stack1.Top());
      stack1.Push(6);
      Console.WriteLine("Popping stack returns {0}", stack1.Pop());
      Console.WriteLine("Stack 1 has size {0}", stack1.size);
      Console.WriteLine("Stack 1 empty? {0}", stack1.IsEmpty());
      stack1.Pop();
      Console.WriteLine("Throws exception before we get here");
    }catch(Exception e) {
        Console.WriteLine(e);
    }
  }
}

class StackEmptyException : ApplicationException {
  public StackEmptyException(String message) : base(message) {
  }
}

new Stack<AssemblyName>())

 
using System;
using System.Reflection;
using System.Collections.Generic;
class MainClass {
    public static void Main(string[] args) {
        AssemblyName assembly1 = new AssemblyName("com.microsoft.crypto, Culture=en, PublicKeyToken=a5d015c7d5a0b012, Version=1.0.0.0");
        Stack<AssemblyName> assemblyStack = new Stack<AssemblyName>();
        assemblyStack.Push(assembly1);
        AssemblyName ass3 = assemblyStack.Pop();
        Console.WriteLine("\nPopped AssemblyName from stack: {0}", ass3);
    }
}

new Stack(new int[] 6 })

 
using System;
using System.Collections;
public class Starter {
    public static void Main() {
        Stack numbers = new Stack(new int[] { 1, 2, 3, 4, 5, 6 });
        int total = numbers.Count;
        for (int count = 0; count < total; ++count) {
            Console.WriteLine(numbers.Pop());
        }
    }
}

Stack demo

/*
Learning C# 
by Jesse Liberty
Publisher: O"Reilly 
ISBN: 0596003765
*/
 using System;
 using System.Collections;
 namespace StackDemo
 {
    public class TesterStackDemo
    {
       public void Run()
       {
           Stack intStack = new Stack();
           // populate the array
           for (int i = 0;i<8;i++)
           {
               intStack.Push(i*5);
           }
           // Display the Stack.
           Console.Write( "intStack values:\t" );
           DisplayValues( intStack );
           // Remove an element from the stack.
           Console.WriteLine( "\n(Pop)\t{0}",
               intStack.Pop() );
           // Display the Stack.
           Console.Write( "intStack values:\t" );
           DisplayValues( intStack );
           // Remove another element from the stack.
           Console.WriteLine( "\n(Pop)\t{0}",
               intStack.Pop() );
           // Display the Stack.
           Console.Write( "intStack values:\t" );
           DisplayValues( intStack );
           // View the first element in the
           // Stack but do not remove.
           Console.WriteLine( "\n(Peek)   \t{0}",
               intStack.Peek() );
           // Display the Stack.
           Console.Write( "intStack values:\t" );
           DisplayValues( intStack );
       }
        public static void DisplayValues(
            IEnumerable myCollection )
        {
            foreach (object o in myCollection)
            {
                Console.WriteLine(o);
            }
        }
       [STAThread]
       static void Main()
       {
          TesterStackDemo t = new TesterStackDemo();
          t.Run();
       }
    }
 }

Stack to array

/*
Learning C# 
by Jesse Liberty
Publisher: O"Reilly 
ISBN: 0596003765
*/
 using System;
 using System.Collections;
 namespace StackDemo
 {
    public class TesterStackArray
    {
       public void Run()
       {
           Stack intStack = new Stack();
           // populate the array
           for (int i = 1;i<5;i++)
           {
               intStack.Push(i*5);
           }
           // Display the Stack.
           Console.WriteLine( "intStack values:" );
           DisplayValues( intStack );

           const int arraySize = 10;
           int[] testArray = new int[arraySize];
           // populate the array
           for (int i = 1; i < arraySize; i++)
           {
               testArray[i] = i * 100;
           }
           Console.WriteLine("\nContents of the test array");
           DisplayValues( testArray );
           // Copy the intStack into the new array, start offset 3
           intStack.CopyTo( testArray, 3 );
           Console.WriteLine( "\nTestArray after copy:  ");
           DisplayValues( testArray );

           // Copy the entire source Stack
           // to a new standard array.
           Object[] myArray = intStack.ToArray();
           // Display the values of the new standard array.
           Console.WriteLine( "\nThe new  array:" );
           DisplayValues( myArray );
       }
        public static void DisplayValues(
            IEnumerable myCollection )
        {
            foreach (object o in myCollection)
            {
                Console.WriteLine(o);
            }
        }
       [STAThread]
       static void Main()
       {
          TesterStackArray t = new TesterStackArray();
          t.Run();
       }
    }
 }