Linear Data Structures Stacks and Queues Exercises

Exercises: Linear Data Structures – Stacks and Queues
This document defines the exercise assignments for the "Data Structures" course @ Software University. You can
submit your code in the SoftUni Judge System - https://judge.softuni.bg/Contests/567/Linear-Data-Structures-
Stacks-and-Queues-CSharp-Exercise.
Problem 1. Reverse Numbers with a Stack

Write a program that reads N integers from the console and reverses them using a stack. Use the Stack<int>
class from .NET Framework. Just put the input numbers in the stack and pop them. Examples:
Input Output
1 2 3 4 5 5 4 3 2 1
1 1
(empty) (empty)
1 -2 -2 1
Problem 2. Calculate Sequence with a Queue

We are given the following sequence of numbers:
 S1 = N
 S2 = S1 + 1
 S3 = 2*S1 + 1
 S4 = S1 + 2
 S5 = S2 + 1
 S6 = 2*S2 + 1
 S7 = S2 + 2
 …
Using the Queue<T> class, write a program to print its first 50 members for given N. Examples:
Input Output
2 2, 3, 5, 4, 4, 7, 5, 6, 11, 7, 5, 9, 6, …
-1 -1, 0, -1, 1, 1, 1, 2, …
1000 1000, 1001, 2001, 1002, 1002, 2003, 1003, …
Problem 3. Implement an Array-Based Stack

Implement the "stack" data structure Stack<T> that holds its elements in an array:
public class ArrayStack<T>

{
private T[] elements;
public int Count { get; private set; }
private const int InitialCapacity = 16;
public ArrayStack(int capacity = InitialCapacity) { … }
© Software University Foundation (softuni.org). This work is licensed under the CC-BY-NC-SA license.
Follow us: Page 1 of 4
public void Push(T element) { … }
public T Pop() { … }
public T[] ToArray() { … }
private void Grow() { … }
}
Follow the concepts from the CircularQueue<T> class from the exercises in class. The stack is simpler than the
circular queue, so you will need to follow the same logic, but more simplified. Some hints:
 The stack capacity is this.elements.Length
 Keep the stack size (number of elements) in this.Count
 Push(element) just saves the element in elements[this.Count] and increases this.Count
 Push(element) should invoke Grow() in case of this.Count == this.elements.Length
 Pop() decreases this.Count and returns this.elements[this.Count]
 Grow() allocates a new array newElements of size 2 * this.elements.Length and copies the first
this.Count elements from this.elements to newElements. Finally, assign this.elements =
newElements
 ToArray() just creates and returns a sub-array of this.elements[0…this.Count-1]
 Pop() should throw InvalidOperationException (or IllegalArgumentException) if the stack is
empty
Problem 4. Linked Stack

Implement a stack by a "linked list" as underlying data structure:
Use the following code as start:
public class LinkedStack<T>

{
private Node<T> firstNode;
public void Push(T element) { … }
public T Pop() { … }
private class Node<T>
{
private T value;
public Node<T> NextNode { get; set; }
public Node(T value, Node<T> nextNode = null) { … }
}
}
The Push(element) operation should create a new Node<T> and put it as firstNode, followed by the old value
of the firstNode, e.g. this.firstNode = new Node<T>(element, this.firstNode).
The Pop() operation should return the firstNode and replace it with firstNode.NextNode. If the stack is
empty, it should throw InvalidOperationException.
Problem 5. Linked Queue
Implement a queue by a "doubly-linked list" as underlying data structure:
Use the following code as start:
public class LinkedQueue<T>

{
public void Enqueue(T element) { … }
public T Dequeue() { … }
private class QueueNode<T>

{
public T Value { get; private set; }
public QueueNode<T> NextNode { get; set; }
public QueueNode<T> PrevNode { get; set; }
}
}
You may modify and adjust the code from the DoublyLinkedList<T> class from the last lesson. If the queue is
empty, the Dequeue() should throw InvalidOperationException.
Problem 6. * Sequence N  M
We are given numbers n and m, and the following operations:
a) n  n + 1
b) n  n + 2
c) n  n * 2
Write a program that finds the shortest sequence of operations from the list above that starts from n and finishes
in m. If several shortest sequences exist, find the first one of them. Examples:
Input Output
3 10 3 -> 5 -> 10
5 -5 (no solution)
10 30 10 -> 11 -> 13 -> 15 -> 30
Hint: use a queue and the following algorithm:
1. create a queue of numbers
2. queue  n
3. while (queue not empty)
1. queue  e
2. if (e < m)
i. queue  e + 1
ii. queue  e + 2
iii. queue  e * 2
3. if (e == m) Print-Solution; exit
The above algorithm either will find a solution, or will find that it does not exist. It cannot print the numbers
comprising the sequence n  m.
To print the sequence of steps to reach m, starting from n, you will need to keep the previous item as well. Instead
using a queue of numbers, use a queue of items. Each item will keep a number and a pointer to the previous item.
The algorithms changes like this:
Algorithm Find-Sequence (n, m):
1. create a queue of items { value, previous item }

2. queue  { n, null }
3. while (queue not empty)
1. queue  item
2. if (item.value < m)
i. queue  { item.value + 1, item }
ii. queue  { item.value + 2, item }
iii. queue  { item.value * 2, item }
3. if (item.value == m) Print-Solution; exit
Algorithm Print-Solution (item):
1. while (item not null)

1. print item.value
2. item = item.previous

Linear Data Structures Stacks and Queues Exercises

Uploaded by

Copyright:

Available Formats

Linear Data Structures Stacks and Queues Exercises

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Linear Data Structures Stacks and Queues Exercises

Uploaded by

Copyright:

Available Formats

Exercises: Linear Data Structures – Stacks and Queues

Problem 1. Reverse Numbers with a Stack

Problem 2. Calculate Sequence with a Queue

Problem 3. Implement an Array-Based Stack

public class ArrayStack<T>

Problem 4. Linked Stack

Use the following code as start:

public class LinkedStack<T>

Use the following code as start:

public class LinkedQueue<T>

private class QueueNode<T>

Hint: use a queue and the following algorithm:

Algorithm Find-Sequence (n, m):

1. create a queue of items { value, previous item }

Algorithm Print-Solution (item):

1. while (item not null)

You might also like