public void ResizingArrayStack_Positive()
{
var stack = new ResizingArrayStack <int>();
Assert.IsTrue(stack.IsEmpty());
stack.Push(1);
stack.Push(3);
stack.Push(5);
stack.Push(7);
stack.Push(9);
Assert.AreEqual(5, stack.Size());
Assert.AreEqual(9, stack.Peek());
Assert.AreEqual(9, stack.Pop());
Assert.AreEqual(7, stack.Pop());
Assert.AreEqual(3, stack.Size());
Assert.AreEqual(5, stack.Peek());
stack.Push(66);
var list = new List <int> {
66, 5, 3, 1
};
int index = 0;
foreach (var i in stack)
{
Assert.AreEqual(list[index++], i);
}
}
public void ResizingArrayStackTest()
{
var stack = new ResizingArrayStack <int>();
stack.Push(1);
stack.Push(2);
Assert.IsTrue(stack.ItemCount == 2);
Assert.IsTrue(stack.IsEmpty() == false);
Assert.IsTrue(stack.Peek() == 2);
Assert.IsTrue(stack.Pop() == 2);
Assert.IsTrue(stack.ItemCount == 1);
stack.Pop();
Assert.IsTrue(stack.IsEmpty());
for (int i = 0; i < 1000; i++)
{
stack.Push(i);
}
Assert.IsTrue(stack.ItemCount == 1000);
for (int i = 0; i < 1000; i++)
{
stack.Pop();
}
Assert.IsTrue(stack.ItemCount == 0);
}
public void ConstructorTest()
{
IStack <int> stack = new ResizingArrayStack <int>();
Assert.IsTrue(stack.IsEmpty());
Assert.AreEqual(0, stack.Size());
Assert.IsTrue(string.IsNullOrWhiteSpace(stack.ToString()));
}
public void ResizingArrayStackTest1()
{
ResizingArrayStack <int> stack = new ResizingArrayStack <int>();
Assert.AreEqual(0, stack.Count, "New stack has zero size");
Assert.AreEqual(true, stack.IsEmpty, "New stack is empty");
Assert.AreEqual("", IteratorToString(stack));
}
private string IteratorToString(ResizingArrayStack <int> input)
{
StringBuilder sb = new StringBuilder();
foreach (int i in input)
{
sb.Append(i + " ");
}
return(sb.ToString());
}
public void ToStringTest()
{
IStack <int> stack = new ResizingArrayStack <int>();
for (int i = 0; i < 10; i++)
{
stack.Push(i);
}
Assert.AreEqual("9 8 7 6 5 4 3 2 1 0", stack.ToString());
}
public void DijkstraEval()
{
string expression = "( ( 5 + 10 ) - ( ( 4 / 2 ) * 4 ) )";
var ops = new ResizingArrayStack <string>(1);
var vals = new ResizingArrayStack <double>(1);
var result = DijkstraExpressionEvaluation.Evaluate(ops, vals, expression);
Assert.AreEqual(7, result);
}
private void transferContents(ResizingArrayStack <T> srcStack, ResizingArrayStack <T> destStack)
{
int size = srcStack.Size();
for (int i = 0; i < size; i++)
{
destStack.Push(srcStack.Pop());
}
shouldTransfer = false;
}
public void TestResizingStack() {
var stack = new ResizingArrayStack<string>();
stack.Push("Hello");
stack.Push("World");
stack.Push("how");
stack.Push("are");
stack.Push("you");
foreach (var item in stack) {
Console.WriteLine(item);
}
}
public void ManyPushTest()
{
IStack <int> stack = new ResizingArrayStack <int>();
for (int i = 0; i < 10; i++)
{
stack.Push(i);
Assert.IsFalse(stack.IsEmpty());
Assert.AreEqual(i + 1, stack.Size());
Assert.AreEqual(i, stack.Peek());
}
}
public void PushAndPopTest_ReferenceType()
{
IStack <String> stack = new ResizingArrayStack <String>();
stack.Push("1");
Assert.IsFalse(stack.IsEmpty());
Assert.AreEqual("1", stack.Peek());
Assert.AreEqual(1, stack.Size());
String value = stack.Pop();
Assert.IsTrue(stack.IsEmpty());
Assert.AreEqual(0, stack.Size());
Assert.AreEqual("1", value);
}
public void PushAndPopTest_ValueType()
{
IStack <int> stack = new ResizingArrayStack <int>();
stack.Push(1);
Assert.IsFalse(stack.IsEmpty());
Assert.AreEqual(1, stack.Peek());
Assert.AreEqual(1, stack.Size());
int value = stack.Pop();
Assert.IsTrue(stack.IsEmpty());
Assert.AreEqual(0, stack.Size());
Assert.AreEqual(1, value);
}
private static void StartTest <T>(T[] values)
{
var fixedCapacitystack = new FixedCapacityStack <T>(values.Length);
var resizingArraystack = new ResizingArrayStack <T>();
var chainStack = new ChainStack <T>();
// 多次使用测试
for (int i = 0; i < 100; i++)
{
AssertStack(values, fixedCapacitystack);
AssertStack(values, resizingArraystack);
AssertStack(values, chainStack);
}
}
public void TestResizingStack()
{
var stack = new ResizingArrayStack <string>();
stack.Push("Hello");
stack.Push("World");
stack.Push("how");
stack.Push("are");
stack.Push("you");
foreach (var item in stack)
{
Console.WriteLine(item);
}
}
public void EnumeratingOnFixedStack()
{
var stack = new ResizingArrayStack <int>(1);
stack.Push(10);
stack.Push(15);
stack.Push(20);
stack.Push(30);
stack.Push(40);
var arr = stack.ToArray(); // because this uses the Enumerator
Assert.AreEqual(new int[] { 40, 30, 20, 15, 10 }, arr);
}
public void ManyPopTest()
{
IStack <int> stack = new ResizingArrayStack <int>();
for (int i = 0; i < 10; i++)
{
stack.Push(i);
}
for (int i = 0; i < 10; i++)
{
int value = stack.Pop();
Assert.AreEqual(10 - i - 1, stack.Size());
Assert.AreEqual(10 - i - 1, value);
}
}
void ResizingArrayStackTest()
{
//string[] str = new string[14] { "To", "be", "or", "not", "to", "-", "be", "-", "-", "that", "-", "-", "-", "is" };
int[] array = new int[13] {
00, -1, 22, 33, 44, -1, 66, 77, 88, 99, -1, 110, 120
};
//ResizingArrayStack<string> stringStackTerator = new ResizingArrayStack<string>();
ResizingArrayStack <int> intStackTerator = new ResizingArrayStack <int>();
//for (int i = 0; i < str.Length; i++)
//{
// string item = str[i];
// if (!item.Equals("-"))
// {
// stringStackTerator.Push(item);
// }
// else if (!stringStackTerator.IsEmpty())
// {
// stringStackTerator.POP();
// }
//}
//for (int i = 0; i < array.Length; i++)
//{
// int item = array[i];
// if (item != -1)
// {
// intStackTerator.push(item);
// }else if (!intStackTerator.IsEmpty()) intStackTerator.POP();
//}
//foreach (string item in stringStackTerator)
//{
// print(item);
//}
//for (int i = 0; i < intStackTerator.size(); i++)
//{
// print("For[i] item:" + intStackTerator.values[i]);
//}
foreach (int item in intStackTerator)
{
print("Foreach item:" + item);
}
}
public IEnumerable <int> PathTo(int v)
{
if (HasPathTo(v))
{
var path = new ResizingArrayStack <int>();
for (int i = v; i != _s; i = _pathTo[i])
{
path.Push(i);
}
path.Push(_s);
while (!path.IsEmpty())
{
yield return(path.Pop());
}
}
;
}
private bool MatchParens(string input)
{
var parens = new ResizingArrayStack <char>(1);
foreach (var i in input)
{
switch (i)
{
case '[':
case '(':
case '{':
parens.Push(i);
break;
case ']':
if (parens.IsEmpty() || parens.Pop() != '[')
{
return(false);
}
break;
case ')':
if (parens.IsEmpty() || parens.Pop() != '(')
{
return(false);
}
break;
case '}':
if (parens.IsEmpty() || parens.Pop() != '{')
{
return(false);
}
break;
default:
break;
}
}
return(true);
}
public void ResizingArrayStackTest2()
{
int[] input = { 3, 2, 4, 6, 9 };
ResizingArrayStack <int> stack = new ResizingArrayStack <int>();
stack.Push(3);
Assert.AreEqual("3 ", IteratorToString(stack));
stack.Push(4);
Assert.AreEqual("4 3 ", IteratorToString(stack));
Assert.AreEqual(4, stack.Pop());
Assert.AreEqual(3, stack.Pop());
Assert.AreEqual(0, stack.Count, "New stack has zero size");
foreach (int i in input)
{
stack.Push(i);
}
Assert.AreEqual(input.Length, stack.Count);
Assert.AreEqual("9 6 4 2 3 ", IteratorToString(stack));
}
public double Evaluate(string expression)
{
ResizingArrayStack <char> ops = new ResizingArrayStack <char>();
ResizingArrayStack <double> vals = new ResizingArrayStack <double>();
for (int i = 0; i < expression.Length; i++)
{
char currChar = expression[i];
if (currChar == '(')
{
;
}
else if (currChar == '+')
{
ops.Push(expression[i]);
}
else if (currChar == '*')
{
ops.Push(expression[i]);
}
else if (currChar == ')')
{
char op = ops.Pop();
if (op == '+')
{
vals.Push(vals.Pop() + vals.Pop());
}
else if (op == '*')
{
vals.Push(vals.Pop() * vals.Pop());
}
}
else
{
vals.Push(Char.GetNumericValue(currChar));
}
}
return(vals.Pop());
}
void StackTest()
{
var strArr = FileHandler.ReadFileAsStrArr("words3.txt");
strArr.Show();
var stack = new ResizingArrayStack <string>();
//var stack = new NodeStack<string>();
foreach (var item in strArr)
{
stack.Push(item);
}
foreach (var item in stack)
{
Console.Write(item + " ");
}
Console.WriteLine();
while (!stack.IsEmpty())
{
Console.Write(stack.Pop() + " ");
}
Console.ReadKey();
}
public bool Balanced(string input)
{
if (string.IsNullOrEmpty(input) || input.Length == 1)
{
return(false);
}
ResizingArrayStack <char> stack = new ResizingArrayStack <char>();
for (int i = 0; i < input.Length; i++)
{
if (openingParenthesis(input[i]))
{
stack.Push(input[i]);
}
if (closingParenthesis(input[i]) && !hasMatchingOpeningParenthesis(input[i], stack))
{
return(false);
}
}
return(stack.IsEmpty());
}
public void PopTest_EmptyStack()
{
IStack <int> stack = new ResizingArrayStack <int>();
stack.Pop();
}
public QueueViaTwoStacks()
{
stack1 = new ResizingArrayStack <T>();
stack2 = new ResizingArrayStack <T>();
}
public void ResizingArrayToString()
{
var stack = new ResizingArrayStack();
StackIterateToString(stack);
}
public void ResizingArrayStackToBeTxt()
{
var stack = new ResizingArrayStack();
ToBeTxt(stack);
}
private bool hasMatchingOpeningParenthesis(char openParen, ResizingArrayStack <char> stack)
{
return(!stack.IsEmpty() && stack.Pop() == parenthesesPair[openParen]);
}
public void PushTest_NullItem()
{
IStack <String> stack = new ResizingArrayStack <String>();
stack.Push(null);
}
