public void ShowVertexGraphWithDepth(GraphVertex vertexStart)
{
Console.Write(vertexStart + "부터 탐색 : ");
GraphVertex vertexVisit = vertexStart;
VisitVertex(vertexVisit);
ListStack <GraphVertex> stack = new ListStack <GraphVertex>();
stack.Push(vertexVisit);
while (_lists[(int)vertexVisit].ReadFirst())
{
bool visitFlag = false;
var vertexNext = _lists[(int)vertexVisit].CurrentNode.Data;
if (VisitVertex(vertexNext))
{
stack.Push(vertexVisit);
vertexVisit = vertexNext;
visitFlag = true;
}
else
{
while (_lists[(int)vertexVisit].ReadNext())
{
vertexNext = _lists[(int)vertexVisit].CurrentNode.Data;
if (!VisitVertex(vertexNext))
{
continue;
}
stack.Push(vertexVisit);
vertexVisit = vertexNext;
visitFlag = true;
break;
}
}
if (visitFlag)
{
continue;
}
if (stack.IsEmpty())
{
break;
}
vertexVisit = stack.Pop();
}
Console.WriteLine();
InitializeVisitInformation();
}
public void ObjectStackTest()
{
var stack = new ListStack<object>();
stack.Push(1010101);
stack.Push(-Math.PI);
stack.Push("ya");
Assert.AreEqual("ya", stack.Pop());
Assert.AreEqual(-Math.PI, stack.Pop());
Assert.AreEqual(1010101, stack.Pop());
}
public void TestPush()
{
IStack <int> sut = new ListStack <int>();
Assert.Throws <ArgumentOutOfRangeException>(() => sut.Top());
sut.Push(3);
Assert.Equal(3, sut.Top());
sut.Push(4);
sut.Push(5);
Assert.Equal(5, sut.Top());
}
public void ObjectStackTest()
{
var stack = new ListStack <object>();
stack.Push(1010101);
stack.Push(-Math.PI);
stack.Push("ya");
Assert.AreEqual("ya", stack.Pop());
Assert.AreEqual(-Math.PI, stack.Pop());
Assert.AreEqual(1010101, stack.Pop());
}
public void ListStackTest()
{
var stack = new ListStack<int>();
stack.Push(0);
stack.Push(10);
stack.Push(-10);
Assert.AreEqual(-10, stack.Pop());
Assert.IsFalse(stack.IsEmpty());
Assert.AreEqual(10, stack.Pop());
Assert.AreEqual(0, stack.Pop());
Assert.IsTrue(stack.IsEmpty());
}
public void ListStackTest()
{
var stack = new ListStack <int>();
stack.Push(0);
stack.Push(10);
stack.Push(-10);
Assert.AreEqual(-10, stack.Pop());
Assert.IsFalse(stack.IsEmpty());
Assert.AreEqual(10, stack.Pop());
Assert.AreEqual(0, stack.Pop());
Assert.IsTrue(stack.IsEmpty());
}
public void TestPop()
{
IStack <int> sut = new ListStack <int>();
sut.Push(1);
sut.Push(2);
sut.Push(3);
sut.Push(4);
Assert.Equal(4, sut.Pop());
Assert.Equal(3, sut.Top());
sut.Pop();
sut.Pop();
Assert.Equal(1, sut.Pop());
Assert.True(sut.IsEmpty());
}
public void EmptyStackExceptionTest()
{
var stack = new ListStack<int>();
stack.Push(1010101);
stack.Pop();
stack.Pop();
}
public static TreeNode <char> MakeExpressionTree(string expression)
{
ListStack <TreeNode <char> > stack = new ListStack <TreeNode <char> >();
foreach (char character in expression)
{
TreeNode <char> currentNode = new TreeNode <char>();
if (char.IsDigit(character))
{
currentNode.Data = character;
}
else
{
currentNode.RightNode = new TreeNode <char> {
Data = stack.Pop().Data
};
currentNode.LeftNode = new TreeNode <char> {
Data = stack.Pop().Data
};
currentNode.Data = character;
}
stack.Push(currentNode);
}
return(stack.Pop());
}
private void StartActivityExecutionTracking(Activity activity)
{
lock (s_activitiesStackSync)
{
_executingActivitiesStack.Push(activity.Name);
}
var eventArgs = new WorkflowExecutionContextEventArgs(this, activity);
ActivityExecutionStarting.RaiseEvent(this, eventArgs);
if (!Tracking)
return;
if (_restoring)
{
if (_trackingActivitiesStack[_restoredActivitiesCount] != activity.Name)
{
var msg = string.Format(
"Ошибка при восстановлении выполнения потока работ: " +
"действие {0}, которое начинает выполнение, отличается от действия {1}, " +
"которое, согласно информации в контексте, должно начать выполнение",
activity.Name, _trackingActivitiesStack[_restoredActivitiesCount]);
throw new ActivityExecutionException(msg, activity, this);
}
_restoredActivitiesCount++;
if (_restoredActivitiesCount == _trackingActivitiesStack.Count)
_restoring = false;
return;
}
_trackingActivitiesStack.Push(activity.Name);
ExecutionContextChanged.RaiseEvent(this, eventArgs);
}
public void EmptyStackExceptionTest()
{
var stack = new ListStack <int>();
stack.Push(1010101);
stack.Pop();
stack.Pop();
}
public void ListStackPush()
{
var stack = new ListStack <int>();
for (var i = 0; i < operationsCount; ++i)
{
stack.Push(i);
}
}
public void TestIsEmpty()
{
IStack <int> sut = new ListStack <int>();
Assert.True(sut.IsEmpty());
sut.Push(5);
Assert.False(sut.IsEmpty());
}
public void AddElementTo_EmptyStack_ShouldHaveOneCount()
{
// Arrange
ListStack<int> nums = new ListStack<int>();
nums.Push(3);
// Act
int count = nums.Count;
// Assert
Assert.AreEqual(1, count);
}
public void CheckCountWhenPopElement_ShouldSameAsBeforePush()
{
// Arrange
ListStack<int> nums = new ListStack<int>();
nums.Push(4);
nums.Pop();
// Act
int count = nums.Count;
// Assert
Assert.AreEqual(0, count);
}
public static void Main(string[] args)
{
ListStack s = new ListStack();
for (int i = 1; i <= 100; i++)
{
s.Push(i);
}
for (int i = 1; i <= 50; i++)
{
s.Pop();
}
s.print();
}
public IfExprent(int ifType, ListStack <Exprent> stack, HashSet <int> bytecodeOffsets
)
: this(null, bytecodeOffsets)
{
//public static final int IF_CAND = 16;
//public static final int IF_COR = 17;
//public static final int IF_NOT = 18;
if (ifType <= If_Le)
{
stack.Push(new ConstExprent(0, true, null));
}
else if (ifType <= If_Nonnull)
{
stack.Push(new ConstExprent(VarType.Vartype_Null, null, null));
}
if (ifType == If_Value)
{
condition = stack.Pop();
}
else
{
condition = new FunctionExprent(Func_Types[ifType], stack, bytecodeOffsets);
}
}
public static void DisplayListStack()
{
ListStack <int> stack = new ListStack <int>();
for (int i = 1; i <= 5; i++)
{
stack.Push(i);
}
while (!stack.IsEmpty())
{
stack.Pop();
Console.Write(stack.CurrentData + " ");
}
}
/// <summary>
/// Creates a new step block at the specified position / rotation
/// </summary>
/// <param name="position"></param>
/// <param name="rotation"></param>
public void AddNewBlock(Vector3 position, Quaternion rotation)
{
if (StepBlockPrefab != null)
{
var obj = Instantiate(StepBlockPrefab, position, rotation, StepBlockSpawnParent);
// Keep a tally of how many are spawned
spawned++;
// Format the name as this will be shown in the UI
obj.name = obj.name.Substring(0, 4) + " " + (spawnedSteps.items.Count + 1);
// Add to stack
spawnedSteps.Push(obj);
// Update UI
SelectDropdown.AddStep(obj);
SelectSlider.AddStep(obj);
}
}
public static void ListStackTest(int quantity)
{
var stack = new ListStack <int>();
var start = DateTime.Now;
for (var i = 0; i < quantity; i++)
{
stack.Push(i);
}
for (var i = 0; i < quantity; i++)
{
stack.Pop();
}
var duration = DateTime.Now.Ticks - start.Ticks;
Console.WriteLine($"\t ListStack \t {quantity} \t {duration / 10000}ms");
}
public void CheckToArrayMethod_ForStack_ShouldReturnArrayWithReversedNumebrs()
{
// Arrange
int[] arr = new int[] { 1, 2, 3, 4 };
ListStack<int> stack = new ListStack<int>();
// Act
for (int i = 0; i < arr.Length; i++)
{
stack.Push(arr[i]);
}
int[] stackArr = stack.ToArray();
// Assert
for (int i = 0, j = arr.Length - 1; i < stackArr.Length; i++, j--)
{
Assert.AreEqual(arr[j], stackArr[i]);
}
}
private void Visit(Statement stat)
{
lstack.Push(stat);
Sharpen.Collections.Put(dfsnummap, stat, ncounter);
Sharpen.Collections.Put(lowmap, stat, ncounter);
ncounter++;
List <Statement> lstSuccs = stat.GetNeighbours(StatEdge.Type_Regular, Statement.Direction_Forward
);
// TODO: set?
lstSuccs.RemoveAll(setProcessed);
foreach (Statement succ in lstSuccs)
{
int?secvalue;
if (tset.Contains(succ))
{
secvalue = dfsnummap.GetOrNullable(succ);
}
else
{
tset.Add(succ);
Visit(succ);
secvalue = lowmap.GetOrNullable(succ);
}
Sharpen.Collections.Put(lowmap, stat, System.Math.Min(lowmap.GetOrNullable(stat) ?? 0,
secvalue ?? 0));
}
if (lowmap.GetOrNullable(stat) == dfsnummap.GetOrNullable(stat))
{
List <Statement> lst = new List <Statement>();
Statement v;
do
{
v = lstack.Pop();
lst.Add(v);
}while (v != stat);
components.Add(lst);
}
}
/// <summary>
/// 移入当前符号，并将指定状态压栈。
/// </summary>
/// <param name="token">要移入的符号。</param>
/// <param name="state">要压栈的状态。</param>
private void Shift(Token <T> token, int state)
{
stateStack.Push(state);
tokenStack.Push(token);
}
public void TestAutoGrowFunctionality_With1000Elemenets()
{
// Arrange
ListStack<string> words = new ListStack<string>();
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
var random = new Random();
int boundary = 1000;
// Act and Assert
Assert.AreEqual(0, words.Count);
for (int i = 0; i < boundary; i++)
{
var result = new string(
Enumerable.Repeat(chars, 8)
.Select(s => s[random.Next(s.Length)])
.ToArray());
words.Push(result);
Assert.AreEqual(i + 1, words.Count);
}
while (words.Count > 0)
{
Assert.AreEqual(boundary, words.Count);
words.Pop();
boundary--;
}
}
private bool CheckVertexConnection(GraphVertex vertex1, GraphVertex vertex2)
{
GraphVertex visit = vertex1;
ListStack <GraphVertex> stack = new ListStack <GraphVertex>();
VisitVertex(visit);
stack.Push(visit);
while (_lists[(int)visit].ReadFirst())
{
GraphVertex next = _lists[(int)visit].CurrentNode.Data;
bool visited = false;
if (next == vertex2)
{
InitializeVisitInformation();
return(true);
}
if (VisitVertex(next))
{
stack.Push(visit);
visit = next;
visited = true;
}
else
{
while (_lists[(int)visit].ReadNext())
{
next = _lists[(int)visit].CurrentNode.Data;
if (next == vertex2)
{
InitializeVisitInformation();
return(true);
}
if (!VisitVertex(next))
{
continue;
}
stack.Push(visit);
visit = next;
visited = true;
break;
}
}
if (visited)
{
continue;
}
if (stack.IsEmpty())
{
break;
}
visit = stack.Pop();
}
InitializeVisitInformation();
return(false);
}
public void PushPopElement_FromStackWithCapacityOne_CheckCount()
{
// Arrange
ListStack<int> nums = new ListStack<int>();
// Act and Assert
Assert.AreEqual(0, nums.Count);
int expectedElementSecond = 1;
nums.Push(expectedElementSecond);
Assert.AreEqual(1, nums.Count);
int expectedElementFirst = 3;
nums.Push(expectedElementFirst);
Assert.AreEqual(2, nums.Count);
Assert.AreEqual(expectedElementFirst, nums.Pop());
Assert.AreEqual(1, nums.Count);
Assert.AreEqual(expectedElementSecond, nums.Pop());
Assert.AreEqual(0, nums.Count);
}
public AutoIndentWriter(TextWriter writer, string newline)
{
this._writer = writer;
_indents.Push(null); // s oftart with no indent
this._newline = newline;
}
public void PushTest()
{
list.Push(1);
list.Push(2);
list.Push(3);
Assert.IsTrue(list.IsContaining(1));
Assert.IsTrue(list.IsContaining(2));
Assert.IsTrue(list.IsContaining(3));
}
/// <summary>
/// 读取输入流中的下一个词法单元并提升输入流的字符位置。
/// </summary>
/// <param name="state">DFA 的起始状态。</param>
/// <returns>词法单元读入是否成功。</returns>
protected override bool InternalReadToken(int state)
{
stateStack.Clear();
int startIndex = Source.Index;
while (true)
{
state = TransitionState(state, base.Source.Read());
if (state == -1)
{
// 没有合适的转移，退出。
break;
}
IList <int> symbolIndex = base.LexerRule.States[state].SymbolIndex;
if (symbolIndex.Count > 0)
{
// 将接受状态记录在堆栈中。
stateStack.Push(new AcceptState(symbolIndex, Source.Index));
}
}
// 遍历终结状态，执行相应动作。
while (stateStack.Count > 0)
{
AcceptState astate = stateStack.Pop();
for (int i = 0; i < astate.SymbolIndex.Count; i++)
{
int acceptState = astate.SymbolIndex[i];
if (acceptState >= base.LexerRule.SymbolCount)
{
// 跳过向前看的头状态。
break;
}
int lastIndex = astate.Index;
int?trailing = base.LexerRule.Symbols[acceptState].Trailing;
if (trailing.HasValue)
{
// 是向前看状态。
int index = trailing.Value;
if (index > 0)
{
// 前面长度固定。
lastIndex = startIndex + index;
}
else if (index < 0)
{
// 后面长度固定，注意此时 index 是负数。
lastIndex += index;
}
else
{
// 前后长度都不固定，需要沿着堆栈向前找。
int target = int.MaxValue - acceptState;
for (int j = stateStack.Count - 1; j >= 0; j--)
{
if (ContainsTrailingHead(stateStack[j].SymbolIndex, target))
{
lastIndex = stateStack[j].Index;
break;
}
}
}
}
// 将文本和流调整到与接受状态匹配的状态。
Source.Index = lastIndex;
DoAction(base.LexerRule.Symbols[acceptState].Action, acceptState);
if (!base.IsReject)
{
return(true);
}
}
}
return(false);
}
public override int Mark()
{
_realTokens.Push(_realTokens.Peek());
return(base.Mark());
}
