static void Main()
{
LinkedQueue<int> linkedQueue = new LinkedQueue<int>();
LinkedQueue<string> anotherLinkedQueue = new LinkedQueue<string>(
new List<string> { "pesho", "gosho", "sasho", "misho" });
Console.WriteLine(anotherLinkedQueue);
Console.WriteLine("First: " + anotherLinkedQueue.First.Value);
Console.WriteLine("Last: " + anotherLinkedQueue.Last.Value);
Console.WriteLine();
linkedQueue.Enqueue(15);
linkedQueue.Enqueue(20);
Console.WriteLine(linkedQueue);
linkedQueue.Enqueue(50);
linkedQueue.Enqueue(100);
Console.WriteLine(linkedQueue);
anotherLinkedQueue.Dequeue();
Console.WriteLine(anotherLinkedQueue);
linkedQueue.Dequeue();
Console.WriteLine(linkedQueue);
Console.WriteLine(linkedQueue.Peek());
anotherLinkedQueue.Clear();
Console.WriteLine(anotherLinkedQueue.Count == 0 && anotherLinkedQueue.First == null && anotherLinkedQueue.Last == null);
}
static void Main()
{
var test = new LinkedQueue<int>();
test.Enqueue(1);
Console.WriteLine(string.Join(" ", test.ToArray()));
test.Enqueue(2);
Console.WriteLine(string.Join(" ", test.ToArray()));
test.Enqueue(3);
Console.WriteLine(string.Join(" ", test.ToArray()));
test.Enqueue(4);
Console.WriteLine(string.Join(" ", test.ToArray()));
test.Enqueue(5);
Console.WriteLine(string.Join(" ", test.ToArray()));
test.Enqueue(6);
Console.WriteLine(string.Join(" ", test.ToArray()));
test.Enqueue(7);
Console.WriteLine(string.Join(" ", test.ToArray()));
Console.WriteLine("The queue count: {0}", test.Count);
test.Dequeue();
test.Dequeue();
Console.WriteLine(string.Join(" ", test.ToArray()));
Console.WriteLine("The queue count: {0}", test.Count);
Console.WriteLine(test.Peek());
Console.WriteLine(string.Join(" ", test.ToArray()));
Console.WriteLine("The queue count: {0}", test.Count);
test.Clear();
Console.WriteLine(string.Join(" ", test.ToArray()));
Console.WriteLine("The queue count: {0}", test.Count);
//test.Dequeue(); //if uncommented this line should throw exception
}
/*
* Implement the ADT queue as dynamic linked list.
* Use generics (LinkedQueue<T>) to allow storing different data types in the queue.
*/
static void Main(string[] args)
{
ILinkedQueue<int> sample = new LinkedQueue<int>();
sample.Enqueue(1);
sample.Enqueue(2);
sample.Enqueue(3);
int[] sampleAsArray = sample.ToArray();
Console.WriteLine("Queue as array:");
for (int index = 0; index < sampleAsArray.Length; index++)
{
Console.WriteLine(sampleAsArray[index]);
}
Console.WriteLine("Dequeue + Peek");
Console.WriteLine(sample.Dequeue() + " Dequeue");
Console.WriteLine(sample.Dequeue() + " Dequeue");
Console.WriteLine(sample.Peek() + " Peek");
Console.WriteLine(sample.Dequeue() + " Dequeue");
sample.Enqueue(4);
Console.WriteLine("Does Contains 4? " + sample.Contains(4));
sample.Enqueue(5);
sample.Enqueue(6);
sample.Clear();
Console.WriteLine("Count after clear: " + sample.Count);
// Console.WriteLine(sample.Dequeue()); // exception expected
}
private static void Main(string[] args)
{
var myQueue = new LinkedQueue<int>();
myQueue.Enqueue(1);
myQueue.Enqueue(2);
myQueue.Enqueue(3);
foreach (var val in myQueue)
{
Console.WriteLine(val);
}
Console.WriteLine("------------------------");
var num = myQueue.Dequeue();
Console.WriteLine("Dequeued value: " + num);
Console.WriteLine("------------------------");
foreach (var val in myQueue)
{
Console.WriteLine(val);
}
var arr = myQueue.ToArray();
Console.WriteLine("To Array:\n" + string.Join(",", arr));
myQueue.Clear();
Console.WriteLine("-------------Cleared-------------");
myQueue.Enqueue(5);
myQueue.Enqueue(6);
myQueue.Enqueue(7);
myQueue.Enqueue(8);
foreach (var val in myQueue)
{
Console.WriteLine(val);
}
}
static void Main()
{
// TODO: Epxlain the tests
Console.WriteLine("Testing custom queue class.");
Console.WriteLine("Class features:");
Console.WriteLine(" - linked list implementation");
Console.WriteLine(" - methods Enqueue, Dequeue, Peek, Contains and property Count.");
Console.WriteLine();
Console.WriteLine("Creating a LinkedQueue.");
LinkedQueue <int> queue = new LinkedQueue <int>();
Console.WriteLine("DONE!" + Environment.NewLine);
Console.WriteLine("Enqueuing numbers from 1 to 10");
for (int i = 1; i <= 10; i++)
{
queue.Enqueue(i);
}
Console.WriteLine("DONE!" + Environment.NewLine);
Console.WriteLine("Printing queue using custom enumerator:");
Print(queue);
Console.WriteLine("Peeking: " + queue.Peek());
Console.WriteLine();
Console.WriteLine("Dequeuing 7 elements");
for (int i = 0; i < 7; i++)
{
queue.Dequeue();
}
Console.Write("Press any key to continue testing.");
Console.ReadKey();
Console.WriteLine();
Console.WriteLine("Printing queue:");
Print(queue);
Console.WriteLine("Enqueuing numbers from 1 to 10");
for (int i = 1; i <= 10; i++)
{
queue.Enqueue(i);
}
Console.WriteLine("Peeking: " + queue.Peek());
Console.WriteLine();
Console.WriteLine("Printing queue:");
Print(queue);
Console.WriteLine("Cheking if queue contains the number 5: " + queue.Contains(5));
Console.WriteLine("Cheking if queue contains the number -15: " + queue.Contains(-15));
Console.WriteLine();
Console.WriteLine("Clearing the queue");
queue.Clear();
Console.WriteLine("Cleared");
Console.WriteLine();
Console.WriteLine("Printing queue:");
Print(queue);
try
{
Console.WriteLine("Peeking: ");
queue.Peek();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void EnqueuingAfterClearingCollection()
{
var stack = new LinkedQueue <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
stack.Enqueue(i);
}
stack.Clear();
for (int i = 0; i < itemCount; i++)
{
stack.Enqueue(i);
}
int trueCount = 0;
int lastItem = int.MinValue;
foreach (var item in stack)
{
if (lastItem > item)
{
Assert.Fail();
}
lastItem = item;
trueCount++;
}
Assert.IsTrue(stack.Count == itemCount &&
stack.Count == trueCount);
}
static void Main()
{
// TODO: Epxlain the tests
Console.WriteLine("Testing custom queue class.");
Console.WriteLine("Class features:");
Console.WriteLine(" - linked list implementation");
Console.WriteLine(" - methods Enqueue, Dequeue, Peek, Contains and property Count.");
Console.WriteLine();
Console.WriteLine("Creating a LinkedQueue.");
LinkedQueue<int> queue = new LinkedQueue<int>();
Console.WriteLine("DONE!" + Environment.NewLine);
Console.WriteLine("Enqueuing numbers from 1 to 10");
for (int i = 1; i <= 10; i++)
{
queue.Enqueue(i);
}
Console.WriteLine("DONE!" + Environment.NewLine);
Console.WriteLine("Printing queue using custom enumerator:");
Print(queue);
Console.WriteLine("Peeking: " + queue.Peek());
Console.WriteLine();
Console.WriteLine("Dequeuing 7 elements");
for (int i = 0; i < 7; i++)
{
queue.Dequeue();
}
Console.Write("Press any key to continue testing.");
Console.ReadKey();
Console.WriteLine();
Console.WriteLine("Printing queue:");
Print(queue);
Console.WriteLine("Enqueuing numbers from 1 to 10");
for (int i = 1; i <= 10; i++)
{
queue.Enqueue(i);
}
Console.WriteLine("Peeking: " + queue.Peek());
Console.WriteLine();
Console.WriteLine("Printing queue:");
Print(queue);
Console.WriteLine("Cheking if queue contains the number 5: " + queue.Contains(5));
Console.WriteLine("Cheking if queue contains the number -15: " + queue.Contains(-15));
Console.WriteLine();
Console.WriteLine("Clearing the queue");
queue.Clear();
Console.WriteLine("Cleared");
Console.WriteLine();
Console.WriteLine("Printing queue:");
Print(queue);
try
{
Console.WriteLine("Peeking: ");
queue.Peek();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void Constructor_int(int count)
{
var queue = new LinkedQueue <T>();
Assert.Equal(new T[0], queue.ToArray());
queue.Clear();
Assert.Equal(new T[0], queue.ToArray());
}
public void TestClear_EmptyQueue()
{
LinkedQueue <int> queue = new LinkedQueue <int>();
queue.Clear();
Assert.AreEqual(0, queue.Count);
}
public void When_clearing_items()
{
ILinkedQueue <int> queue = new LinkedQueue <int>(new[] { 1, 2, 3 });
queue.Enqueue(4);
queue.ShouldBe(new [] { 1, 2, 3, 4 });
queue.Clear();
queue.ShouldBeEmpty();
}
public void Clear_ShouldRemove_AllElements()
{
var queue = new LinkedQueue<int>();
int expectedLinkedQueueCount = 0;
queue.Enqueue(3);
queue.Enqueue(5);
queue.Enqueue(7);
queue.Clear();
Assert.AreEqual(expectedLinkedQueueCount, queue.Count, "Clear isn't working correctly.");
}
public void ClearQueue_Queue_Should_Be_Empty()
{
// arrange
var start_node_value = 1;
var node = 2;
IQueue <int> TestQueue = new LinkedQueue <int>(start_node_value);
TestQueue.Enqueue(node);
// act
TestQueue.Clear();
// assert
Assert.IsTrue(TestQueue.IsEmpty());
//Assert.AreEqual(null, TestQueue.First());
}
public void TestClear_NonEmptyQueue()
{
LinkedQueue <int> queue = new LinkedQueue <int>();
int queueCount = 10;
for (int i = 0; i < queueCount; i++)
{
queue.Enqueue(i);
}
queue.Clear();
Assert.AreEqual(0, queue.Count);
}
private static void Main()
{
LinkedQueue <int> testQueue = new LinkedQueue <int>();
testQueue.Enqueue(5);
testQueue.Enqueue(7);
testQueue.Enqueue(15);
testQueue.Enqueue(23);
testQueue.Enqueue(11);
testQueue.Enqueue(455);
testQueue.Enqueue(5855);
testQueue.Enqueue(5);
Console.WriteLine("Enqueued: " + string.Join(", ", testQueue));
Console.WriteLine(new string('-', 48));
testQueue.Dequeue();
Console.WriteLine("Dequeued: " + string.Join(", ", testQueue));
Console.WriteLine(new string('-', 48));
Console.WriteLine("Peek: " + testQueue.Peek());
Console.WriteLine(new string('-', 48));
Console.WriteLine("Count: " + testQueue.Count);
Console.WriteLine(new string('-', 48));
Console.WriteLine("Contains: " + testQueue.Contains(455));
Console.WriteLine("Contains: " + testQueue.Contains(455));
int[] testArray = new int[testQueue.Count];
testArray = testQueue.ToArray();
Console.WriteLine(new string('-', 48));
Console.WriteLine("To array: " + string.Join(", ", testArray));
Console.WriteLine(new string('-', 48));
testQueue.Clear();
Console.WriteLine("Cleared: " + string.Join(", ", testQueue));
Console.WriteLine("Cleared count: " + testQueue.Count);
Console.WriteLine(new string('-', 48));
}
private static void Main()
{
LinkedQueue<int> testQueue = new LinkedQueue<int>();
testQueue.Enqueue(5);
testQueue.Enqueue(7);
testQueue.Enqueue(15);
testQueue.Enqueue(23);
testQueue.Enqueue(11);
testQueue.Enqueue(455);
testQueue.Enqueue(5855);
testQueue.Enqueue(5);
Console.WriteLine("Enqueued: " + string.Join(", ", testQueue));
Console.WriteLine(new string('-', 48));
testQueue.Dequeue();
Console.WriteLine("Dequeued: " + string.Join(", ", testQueue));
Console.WriteLine(new string('-', 48));
Console.WriteLine("Peek: " + testQueue.Peek());
Console.WriteLine(new string('-', 48));
Console.WriteLine("Count: " + testQueue.Count);
Console.WriteLine(new string('-', 48));
Console.WriteLine("Contains: " + testQueue.Contains(455));
Console.WriteLine("Contains: " + testQueue.Contains(455));
int[] testArray = new int[testQueue.Count];
testArray = testQueue.ToArray();
Console.WriteLine(new string('-', 48));
Console.WriteLine("To array: " + string.Join(", ", testArray));
Console.WriteLine(new string('-', 48));
testQueue.Clear();
Console.WriteLine("Cleared: " + string.Join(", ", testQueue));
Console.WriteLine("Cleared count: " + testQueue.Count);
Console.WriteLine(new string('-', 48));
}
static void Main()
{
LinkedQueue<int> queue = new LinkedQueue<int>();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(5);
Console.WriteLine("Queue count: " + queue.Count());
Console.WriteLine("Top: " + queue.Peek());
queue.Dequeue();
Console.WriteLine("First deleted");
Console.WriteLine("Queue count: " + queue.Count());
Console.WriteLine("Top: " + queue.Peek());
queue.Clear();
Console.WriteLine("Queue cleared");
Console.WriteLine("Queue count: " + queue.Count());
}
public override bool UseItem(Player player)
{
if (Main.myPlayer == player.whoAmI)
{
if (player.altFunctionUse == 2)
{
p.Clear();
if (player.controlSmart)
{
mode = (mode + modeCount - 1) % modeCount;
}
else
{
mode = (mode + 1) % modeCount;
}
}
else
{
if (player.controlSmart)
{
Apply();
}
else if (player.controlDown)
{
if (p.Count > 0)
{
p.RemoveAt(p.Count - 1);
}
}
else
{
SetParameter();
}
}
return(true);
}
return(false);
}
public void Execute()
{
Double[] _d = new Double[] { 2d, 4d, 6d, 1d, 3d, 5d, 7d, 3d, 5d, 10d };
ArrayList <Double> data = new ArrayList <Double>(_d); //CSharpDataStructures.Structures.Lists;
foreach (Double elem in data)
{
Console.Write(elem);
Console.Write(" ");
}
data.Clear();
data.Add(2d);
data.Add(5d);
data.Add(6d);
data.Add(2d);
data.Add(7d);
data.Add(5d);//256275 -> 2567
Console.Write("\n");
Console.WriteLine(data.Count);
Console.WriteLine(data);
data.Purge();
Console.WriteLine(data);
LinkedList <string> linkedList = new LinkedList <string>();
// добавление элементов
linkedList.Add("Tom");
linkedList.Add("Alice");
linkedList.Add("Bob");
linkedList.Add("Sam");
// выводим элементы
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
// удаляем элемент
linkedList.Remove("Alice");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
// проверяем наличие элемента
bool isPresent = linkedList.Contains("Sam");
Console.WriteLine(isPresent == true ? "Sam присутствует" : "Sam отсутствует");
Console.WriteLine(linkedList.Count);
Console.WriteLine(linkedList);
Console.WriteLine(linkedList[1]); //Tom.
linkedList.Insert(3, "Duke"); //Tom Bob->Duke->Sam
Console.WriteLine(linkedList);
LinkedQueue <Int32> queue = new LinkedQueue <Int32>();
queue.Clear();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Dequeue();
Console.WriteLine(queue);
Console.WriteLine(queue.Front().ToString());
//Linq methods.
LinkedList <Int32> li1 = new LinkedList <Int32>();
LinkedList <Int32> li2 = new LinkedList <Int32>();
for (Int32 i = 0; i < 10; i++)
{
li1.Add(i);
li2.Add(i * 3);
if (i % 2 == 0)
{
li2.Add(i);
}
}
Console.WriteLine("Li1: " + li1);
Console.WriteLine("Li2: " + li2);
IE li3 = ((IE)li1).Intersect(li2); //IEnumerable<Int32>
Console.WriteLine("Li3 = Li1 AND Li2");
foreach (Int32 iii in li3)
{
Console.Write(iii + " ");
}
Console.WriteLine("Li4 = Li3");
LinkedList <Int32> li4 = Intersect(li1, li2);
IE li5 = (IE)li4;
LinkedList <Int32> li6 = li5 as LinkedList <Int32>;//li4 WAS LinkedList. li5 is IEnumerable. Can Cast it.
Console.WriteLine(li6 == null);
Console.WriteLine("Li4");
Console.WriteLine(li6);
foreach (Int32 iiii in li4)
{
Console.Write(iiii + " ");
}
}
static void Main()
{
var listQueue = new ListQueue <int>();
listQueue.Enqueue(1);
listQueue.Enqueue(3);
listQueue.Enqueue(4);
listQueue.Enqueue(6);
listQueue.Enqueue(9);
DisplayQueue(listQueue);
Console.WriteLine("Добавим в очередь элемент '7'");
listQueue.Enqueue(7);
DisplayItem(listQueue);
listQueue.Clear();
DisplayQueue(listQueue);
var arrayQueue = new ArrayQueue <string>(10);
arrayQueue.Enqueue("1");
arrayQueue.Enqueue("2");
arrayQueue.Enqueue("5");
arrayQueue.Enqueue("6");
arrayQueue.Enqueue("ten");
DisplayQueue(arrayQueue);
Console.WriteLine("Добавим в очередь элемент 'seven'");
arrayQueue.Enqueue("seven");
DisplayItem(arrayQueue);
arrayQueue.Clear();
DisplayQueue(arrayQueue);
var linkedListQueue = new LinkedQueue <int>();
linkedListQueue.Enqueue(1);
linkedListQueue.Enqueue(3);
linkedListQueue.Enqueue(4);
linkedListQueue.Enqueue(6);
linkedListQueue.Enqueue(9);
DisplayQueue(linkedListQueue);
Console.WriteLine("Добавим в очередь элемент '7'");
linkedListQueue.Enqueue(7);
DisplayItem(linkedListQueue);
linkedListQueue.Clear();
DisplayQueue(linkedListQueue);
var listDeque = new ListDeque <int>();
listDeque.AddFirst(1);
listDeque.AddFirst(3);
listDeque.AddFirst(4);
listDeque.AddLast(6);
listDeque.AddLast(9);
DisplayItem(listDeque);
DisplayQueue(listDeque);
Console.WriteLine();
listDeque.AddLast(5);
DisplayItem(listDeque);
Console.WriteLine(listDeque.RemoveFirst());
DisplayItem(listDeque);
var linkedDeque = new LinkedListDeque <int>();
linkedDeque.AddFirst(1);
linkedDeque.AddFirst(3);
linkedDeque.AddFirst(4);
linkedDeque.AddLast(6);
linkedDeque.AddLast(9);
DisplayItem(linkedDeque);
DisplayQueue(linkedDeque);
Console.WriteLine();
linkedDeque.AddLast(5);
DisplayItem(linkedDeque);
Console.WriteLine(linkedDeque.RemoveFirst());
DisplayItem(linkedDeque);
}
