public void PushPopRangeTest()
{
//arrange
Stack1 stack = new Stack1();
int result;
stack.Push(10);
Assert.AreEqual(stack.Max(), 10, "Value should be 10");
stack.Push(15);
Assert.AreEqual(stack.Max(), 15, "Value should be 15");
stack.Push(3);
Assert.AreEqual(stack.Max(), 15, "Value should be 15");
stack.Push(100);
Assert.AreEqual(stack.Max(), 100, "Value should be 100");
stack.Pop();
Assert.AreEqual(stack.Max(), 15, "Value should be 15");
stack.Pop();
Assert.AreEqual(stack.Max(), 15, "Value should be 15");
stack.Pop();
Assert.AreEqual(stack.Max(), 10, "Value should be 10");
}
public void TestPeek()
{
Stack1 S = new Stack1();
S.Push("1");
S.Push("2");
S.Push("3");
Assert.AreEqual("3", S.Peek());
Assert.AreEqual("2", S.Peek());
}
public void TestClear()
{
Stack1 S = new Stack1();
S.Push("1");
S.Push("2");
S.Push("3");
Assert.AreEqual("3", S.Clear());
Assert.AreEqual("3", S.Count());
}
public void TestMethod1()
{
Stack1 S = new Stack1();
S.Push("1");
S.Push("2");
S.Push("3");
Assert.AreEqual("3", S.Pop());
Assert.AreEqual("2", S.Pop());
}
public void TestMaxWithMaxToSmallest()
{
//arrange
Stack1 stack = new Stack1();
int expected = 10;
int result;
//act
stack.Push(10);
stack.Push(5);
stack.Push(1);
result = stack.Max();
//assert
Assert.AreEqual(result, expected);
}
public void EnQueue2(T data)
{
if (Stack1 == null)
{
Stack1 = new StackLinkedList <T>();
}
Stack1.Push(new StackNodeSingly <T>(data));
}
public static void Print()
{
while (Stack1.Count > 0)
{
var element = Stack1.Pop();
Stack2.Push(element);
}
Console.WriteLine("Element at the head of the queue: {0}", Stack2.Peek());
while (Stack2.Count > 0)
{
var element = Stack2.Pop();
Stack1.Push(element);
}
}
public void TestPushPopWithOneValue()
{
//arrange
Stack1 stack = new Stack1();
int val = 5;
int expected = 5;
int result;
//act
stack.Push(val);
result = stack.Pop();
//assert
Assert.AreEqual(result, expected);
}
public static void Dequeue()
{
while (Stack1.Count > 1)
{
var element = Stack1.Pop();
Stack2.Push(element);
}
var dequed = Stack1.Pop();
Console.WriteLine("Dequed element: {0}", dequed);
while (Stack2.Count > 0)
{
var element = Stack2.Pop();
Stack1.Push(element);
}
}
/// <summary>
/// Mimic a Queue object's enqueue method with stacks,
/// and returns the value what would be the front object
/// </summary>
/// <param name="value"> value to enqueue </param>
/// <returns></returns>
public T Enqueue(T value)
{
Stack1.Push(value);
while (!Stack1.IsEmpty())
{
Stack2.Push(Stack1.Pop());
}
T frontValue = Stack2.Peek();
while (!Stack2.IsEmpty())
{
Stack1.Push(Stack2.Pop());
}
return(frontValue);
}
/// <summary>
/// emulates the "dequeue" method using 2 stacks
/// </summary>
/// <returns>the node that was "dequeued" from the stack</returns>
public Node Dequeue()
{
if (Stack1.Top.Next == null)
{
return(Stack1.Pop());
}
while (Stack1.Top.Next != null)
{
Stack2.Push(Stack1.Pop());
}
Node tmpNode = Stack1.Pop();
while (Stack2.Top.Next != null)
{
Stack1.Push(Stack2.Pop());
}
return(tmpNode);
}
//Dequeue() returns the first value that was placed into stack1
public Node Dequeue()
{
//keep going through stack1 until we reach the bottom
while (Stack1.Top.Next != null)
{
Stack2.Push(Stack1.Pop());
//this looping mechanism will only leave one node behind...
}
//which is this node, so it'll be popped off
//Since this method returns a node, we init a Node that references it
//so we can return this node. This is the node WE WANT
Node returnNode = Stack1.Pop();
//this will put all the guts of stack1 back from stack2
while (Stack2.Top != null)
{
Stack1.Push(Stack2.Pop());
}
return(returnNode);
}
/// <summary>
/// Removes a node from the queue
/// </summary>
/// <returns>returns the node that was dequeued</returns>
public Node Dequeue()
{
if (Stack2.Peek() == null)
{
return(null);
}
while (Stack2.Peek().Next != null)
{
Stack1.Push(Stack2.Pop());
}
Node temp = Stack2.Pop();
while (Stack1.Peek() != null)
{
Stack2.Push(Stack1.Pop());
}
return(temp);
}
/// <summary>
/// Add a new item to the "rear" of the queue, which is actually the bottom of the primary stack
/// </summary>
/// <param name="val">Value to be enqueued</param>
public void Enqueue(string val)
{
if (Stack1.Top == null)
{
Stack1.Push(val);
Front = Stack1.Top;
}
else
{
while (Stack1.Top != null)
{
Stack2.Push(Stack1.Pop());
}
Stack1.Push(val);
while (Stack2.Top != null)
{
Stack1.Push(Stack2.Pop());
}
Front = Stack1.Top;
}
}
public void TestMaxWhenWasAndPoped()
{
//arrange
Stack1 stack = new Stack1();
int[] values = new int[] { 1, 2, 10, 5, 20 };
int expected = 10;
int result;
//act
foreach (int val in values)
{
stack.Push(val);
}
stack.Pop();
stack.Pop();
result = stack.Max();
//assert
Assert.AreEqual(result, expected);
}
public void EnQueue1(T data)
{
if (Stack1 == null)
{
Stack1 = new StackLinkedList <T>();
}
if (Stack2 == null)
{
Stack2 = new StackLinkedList <T>();
}
var newData = new StackNodeSingly <T>(data);
while (Stack1.HeadStackNodeSingly != null)
{
Stack2.Push(new StackNodeSingly <T>(Stack1.Pop()));
}
Stack1.Push(newData);
while (Stack2.HeadStackNodeSingly != null)
{
Stack1.Push(new StackNodeSingly <T>(Stack2.Pop()));
}
}
/// <summary>
/// Mimic a Queue object's dequeue method with stacks.
/// Pop() what would be the front node and return the value
/// </summary>
/// <returns></returns>
public T Dequeue()
{
try
{
while (!Stack1.IsEmpty())
{
Stack2.Push(Stack1.Pop());
}
T frontValue = Stack2.Pop();
while (!Stack2.IsEmpty())
{
Stack1.Push(Stack2.Pop());
}
return(frontValue);
}
catch (NullReferenceException e)
{
throw new NullReferenceException($"Your stack is empty, womp womp\n{e}");
}
}
public static void Enqueue(int x)
{
Stack1.Push(x);
}
//Enqueue(value) inserts a value to the top of the stack
public void Enqueue(Node node)
{
Stack1.Push(node);
Console.WriteLine($"THe return node is {node.Value}");
}
/// <summary>
/// the new node in the Queue is whatever was on top of Stack1.
/// </summary>
/// <param name="value">value is whatever value in the stack you want
/// to add to the queue
/// </param>
/// <returns></returns>
public Node Enqueue(int value)
{
Stack1.Push(new Node(value));
return(Stack1.Top);
}
public void Enqueue(Node node)
{
Stack1.Push(node);
Console.WriteLine(node.Value);
}
/// <summary>
/// This method takes in a value and then adds it to the "rear" of the queue; which is the top of stack1.
/// </summary>
/// <param name="value">This is the value that is added to the "rear" of the queue</param>
public void Enqueue(int value)
{
Node node = new Node(value);
Stack1.Push(node);
}
