Linear Data Structures

Lists, Stacks, Queues

Svetlin Nakov
Telerik Corporation
www.telerik.com

Table of Contents
1. 2.

Abstract Data Types (ADT) Lists The List<T> Class List<T>

Static and Linked

3.

Stacks The Stack<T> Class

Static and Linked

4.

Queues The Queue<T> Class

Circular and Linked

Priority Queue
C# Implementation

Abstract Data Types

Basic Data Structures

Abstract Data Types

An Abstract

Data Type (ADT) is a data type together with the operations, whose properties are specified independently of any particular implementation
ADT are set of definitions of operations (like the interfaces in C#) Can have several different implementations Different implementations can have different efficiency

Basic Data Structures

Linear structures

Lists: fixed size and variable size Stacks: LIFO (Last In First Out) structure Queues: FIFO (First In First Out) structure
Trees

Binary, ordered, balanced, etc.

Dictionaries (maps)

Contain pairs (key, value) Hash tables: use hash functions to search/insert

Lists
Static and Dynamic Implementations

The List ADT

Data structure

(container) that contains a sequence of elements

Can have variable size Elements are arranged linearly, in sequence

Can be implemented in several

ways

Statically (using array fixed size) size) Dynamically (linked implementation) Using resizable array (the List<T> class)

Static List
Implemented by an array

Provides direct access by index Has fixed capacity Insertion, deletion and resizing are slow operations
0 1 2 3 4 5 6 7

2 18 7 12 3

6 11 9

Linked List
Dynamic (pointer-based) implementation (pointer Different forms

Singly-linked and doubly-linked Singlydoubly Sorted and unsorted

Singly-linked list Singly-

Each item has 2 fields: value and next

2 head next 7 next 4 next 5 next null

Linked List (2)

Doubly-linked List Doubly-

Each item has 3 fields: value, next and prev value,

head 2 next prev null 7 next prev 4 next prev tail 5 next prev null

The List<T> Class List<T>

AutoAuto-Resizable Indexed Lists

The List<T> Class

Implements the abstract

data structure list

using an array
All elements are of the same type T T can be any type, e.g. List<int>, e.g. List<int>, List<string>, List<DateTime> List<string>, Size is dynamically increased as needed
Basic functionality:

Count returns the number of elements Add(T) appends given element at the end

List<T> Simple Example

static void Main() { List<string> list = new List<string>() { "C#", "Java" }; list.Add("SQL"); list.Add("Python"); foreach (string item in list) { Console.WriteLine(item); } // Result: // C# // Java // SQL // Python }

Inline initialization: the compiler adds specified elements to the list.

List<T> Simple Example

Live Demo

List<T> Functionality

list[index] access element by index Insert(index, T) inserts given element to the Insert(index, list at a specified position Remove(T) removes the first occurrence of given element RemoveAt(index) removes the element at the specified position Clear() removes all elements Contains(T) determines whether an element Contains(T) is part of the list

List<T> Functionality (2)

IndexOf() returns the index of the first occurrence of a value in the list (zero-based) zero-based) Reverse() reverses the order of the elements in Reverse() the list or a portion of it Sort() Sort() sorts the elements in the list or a portion of it ToArray() converts the elements of the list to ToArray() an array TrimExcess() sets the capacity to the actual number of elements

Primes in an Interval Example

static List<int> FindPrimes(int start, int end) { List<int> primesList = new List<int>(); List<int> for (int num = start; num <= end; num++) { bool prime = true; for (int div = 2; div <= Math.Sqrt(num); div++) Math.Sqrt(num); { if (num % div == 0) { prime = false; break; break; } } if (prime) (prime) { primesList.Add(num); } } return primesList; }

Primes in an Interval
Live Demo

Union and Intersection Example

int[] Union(int[] firstArr, int[] secondArr) { List<int> union = new List<int>(); union.AddRange(firstArray); foreach (int item in secondArray) if (! union.Contains(item)) union.Add(item); return union.ToArray(); } int[] Intersection(int[] firstArr, int[] secondArr) { List<int> intersect = new List<int>(); foreach (int item in firstArray) if (Array.IndexOf(secondArray, item) != -1) intersect.Add(item); return intersect.ToArray(); }

Union and Intersection

Live Demo

Stacks
Static and Dynamic Implementation

The Stack ADT

LIFO (Last

In First Out) structure Elements inserted (push) at top Elements removed (pop) from top Useful in many situations
E.g. the execution stack of the program
Can be implemented in several

ways

Statically (using array) Dynamically (linked implementation) Using the Stack<T> class

Static Stack
Static (array-based) (array-

implementation

Has limited (fixed) capacity The current index (top) moves left / right with (top) each pop / push
0 1 2 3 4 5 6 7

2 18 7 12 top

Linked Stack
Dynamic (pointer-based) implementation (pointer-

Each item has 2 fields: value and next Special pointer keeps the top element
top 2 next 7 next 4 next 5 next null

The Stack<T> Class

The Standard Stack Implementation in .NET

The Stack<T> Class

Implements the stack

data structure using an

array
Elements are from the same type T T can be any type, e.g. Stack<int> Size is dynamically increased as needed
Basic functionality:

Push(T) inserts elements to the stack Pop() removes and returns the top element from the stack

The Stack<T> Class (2)

Basic functionality: functionality:

Peek() returns the top element of the stack without removing it Count returns the number of elements Clear() removes all elements Contains(T) determines whether given element is in the stack ToArray() converts the stack to an array TrimExcess() sets the capacity to the actual number of elements

Stack<T> Example

Using Push(), Pop() and Peek() methods Push(),

static void Main() { Stack<string> stack = new Stack<string>(); stack.Push("1. stack.Push("2. stack.Push("3. stack.Push("4. Ivan"); Nikolay"); Maria"); George");

Console.WriteLine("Top = {0}", stack.Peek()); while (stack.Count > 0) { string personName = stack.Pop(); stack.Pop(); Console.WriteLine(personName); Console.WriteLine(personName); } }

Stack<T>
Live Demo

Matching Brackets Example

We are given an arithmetical expression with brackets that can be nested Goal: extract all sub-expressions in brackets subExample: Example:
1 + (2 - (2+3) * 4 / (3+1)) * 5 (3+1))

Result:
(2+3) | (3+1) | (2 - (2+3) * 4 / (3+1))

Algorithm:
For each '(' push its index in a stack '( For each ')' pop the corresponding start index ')

Matching Brackets Solution

string expression = "1 + (2 - (2+3) * 4 / (3+1)) * 5"; Stack<int> stack = new Stack<int>(); for (int index = 0; index < expression.Length; index++) (int 0; expression.Length; { char ch = expression[index]; if (ch == '(') { stack.Push(index); } else if (ch == ')') { int startIndex = stack.Pop(); int length = index - startIndex + 1; string contents = expression.Substring(startIndex, length); expression.Substring(startIndex, Console.WriteLine(contents); Console.WriteLine(contents); } }

Matching Brackets
Live Demo

Queues
Static and Dynamic Implementation

The Queue ADT

FIFO (First In First Out) structure Elements inserted at the tail (Enqueue) (Enqueue) Elements removed from the head (Dequeue) Dequeue) Useful in many situations

Print queues, message queues, etc.

Can be implemented in several

ways

Statically (using array) Dynamically (using pointers) Using the Queue<T> class

Static Queue
Static (array-based) (array-

implementation

Has limited (fixed) capacity Implement as a circular array Has head and tail indices, pointing to the head and the tail of the cyclic queue
0 1 2 3 4 5 6 7

7 12 2 head

5 tail

Linked Queue
Dynamic (pointer-based) implementation (pointer-

Each item has 2 fields: value and next Dynamically create and delete objects
head 2 next 7 next 4 next tail 5 next null

The Queue<T> Class

Standard Queue Implementation in .NET

The Queue<T> Class

Implements the queue

data structure using a

circular resizable array

Elements are from the same type T T can be any type, e.g. Stack<int> Size is dynamically increased as needed
Basic functionality:

Enqueue(T) adds an element to the end of the queue Dequeue() removes and returns the element at the beginning of the queue

The Queue<T> Class (2)

Basic functionality: functionality:

Peek() returns the element at the beginning of the queue without removing it Count returns the number of elements Clear() removes all elements Contains(T) determines whether given element is in the queue ToArray() converts the queue to an array TrimExcess() sets the capacity to the actual number of elements in the queue

Queue<T> Example

Using Enqueue() and Dequeue() methods

static void Main() { Queue<string> queue = new Queue<string>(); queue.Enqueue("Message queue.Enqueue("Message One"); queue.Enqueue("Message queue.Enqueue("Message Two"); queue.Enqueue("Message queue.Enqueue("Message Three"); queue.Enqueue("Message queue.Enqueue("Message Four"); while (queue.Count > 0) { string message = queue.Dequeue(); Console.WriteLine(message); } }

The Queue<T> Class

Live Demo

Sequence N, N+1, 2*N

We are given the sequence:

+1 +1 +1

S = N, N+1, 2*N, N+2, 2*(N+1), 2*N+1, 4*N, N+1, 2*N, N+2, 2*(N+1), 2*N+1, 4*N,
*2

*2

*2

Find the first index of given number P Example: N = 3, P = 16

S = 3, 4, 6, 5, 8, 7, 12, 6, 10, 9, 16, 8, 14, 12, 10, 16, 14, Index of P = 11

Sequence Solution with a Queue

int n = 3, p = 16; Queue<int> queue = new Queue<int>(); queue.Enqueue(n); int index = 0; while (queue.Count > 0) { int current = queue.Dequeue(); queue.Dequeue(); index++; index++; if (current == p) { Console.WriteLine("Index = {0}", index); return; } queue.Enqueue(current+1); queue.Enqueue(2*current); }

Sequence N, N+1, 2*N

Live Demo

Priority Queue

Priority Queue
What is a

Priority Queue

Data type to efficiently support finding the item with the highest priority Basic operations
Enqueue(T element) Enqueue(T Dequeue
There is no build-in build-

Priority Queue in .NET

Can be easily implemented using PowerCollections

Priority Queue Implementation

class PriorityQueue<T> where T:IComparable<T> PriorityQueue<T> { private OrderedBag<T> bag; bag; public int Count Necessary to provide { get { return bag.Count; } bag.Count; comparable elements private set{ } } public PriorityQueue() { bag = new OrderedBag<T>(); OrderedBag<T>(); } public void Enqueue(T element) { bag.Add(element); bag.Add(element); } public T Dequeue() { var element = bag.GetFirst(); bag.RemoveFirst(); bag.RemoveFirst(); return element; } }
47

Priority Queue Additional Notes

The generic type is needed to

implement

IComparable<T>
It is not necessary to

use OrderedBag

Other Data Structures also can be used

Adding and Removing Element in the Priority

Queue is with complexity logN

Keeps the elements Sorted

Always returns the best element that fulfills some condition

E.g. the smallest or the biggest element
48

Priority Queue
Live Demo

49

Summary
ADT are defined by list of operations independent of their implementation The basic linear data structures in the computer programming are:

List (static, linked)

Implemented by the List<T> class in .NET List<T>

Stack (static, linked)

Implemented by the Stack<T> class in .NET Stack<T>

Queue (static, linked)

Implemented by the Queue<T> class in .NET Queue<T> .NET

Priority Queue
Implemented by the OrderedBag<T> class

Linear Data Structures

Questions?
http://academy.telerik.com

Exercises
1.

Write a program that reads from the console a sequence of positive integer numbers. The sequence ends when empty line is entered. Calculate and print the sum and average of the elements of the sequence. sequence. Keep the sequence in List<int>. List<int>. Write a program that reads N integers from the console and reverses them using a stack. Use the Stack<int> class. Write a program that reads a sequence of integers List<int>) (List<int>) ending with an empty line and sorts them in an increasing order. order.

2.

3.

Exercises (2)
4.

Write a method that finds the longest subsequence of equal numbers in given List<int> and returns the result as new List<int>. Write a program to List<int>. test whether the method works correctly. Write a program that removes from given sequence all negative numbers. Write a program that removes from given sequence all numbers that occur odd number of times. Example:
{4, 2, 2, 5, 2, 3, 2, 3, 1, 5, 2} {5, 3, 3, 5}

5.

6.

Exercises (3)
7.

Write a program that finds in given array of integers (all belonging to the range [0..1000]) how many times each of them occurs.
Example: array = {3, 4, 4, 2, 3, 3, 4, 3, 2}
2 2 times 3 4 times 4 3 times

8.

* The majorant of an array of size N is a value that occurs in it at least N/2 + 1 times. Write a program to find the majorant of given array (if exists). Example:
{2, 2, 3, 3, 2, 3, 4, 3, 3} 3

Exercises (4)
9.

We are given the following sequence:

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. N. Example: Example: N=2 2, 3, 5, 4, 4, 7, 5, 6, 11, 7, 5, 9, 6, ...

Exercises (5)
10.

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. Hint: use a queue.
Example: N = 5, M = 16 Sequence: 5 7 8 16

Exercises (6)
11.

Write a class Student, that has three fields: name Student, (String), age(Integer) and age(Integer) paidSemesterOnline(Boolean). When in a queue paidSemesterOnline(Boolean). the students who paid online are with higher priority than those who are about to pay the semester. Write a program which with a given queue of student determine whose turn it is. Hint: use priority queue

57

Exercises (6)
12.

Implement the data structure linked list. Define a list. class ListItem<T> that has two fields: value (of type T) and nextItem (of type ListItem<T>). ListItem<T>). Define additionally a class LinkedList<T> with a single field firstElement (of type ListItem<T>). ListItem<T>). Implement the ADT stack as auto-resizable array. autoarray. Resize the capacity on demand (when no space is available to add / insert a new element). Implement the ADT queue as dynamic linked list. LinkedQueue<T>) Use generics (LinkedQueue<T>) to allow storing different data types in the queue. queue.

13.

14.

Exercises (7) (7)

15.

* We are given a labyrinth of size N x N. Some of its cells are empty (0) and some are full (x). We can (0 (x move from an empty cell to another empty cell if they share common wall. Given a starting position (*) calculate and fill in the array the minimal distance from this position to any other cell in the array. Use "u" for all unreachable cells. Example: "u
0 0 0 0 0 0 0 x * x 0 0 0 0 x 0 0 0 x x 0 0 x x 0 0 x 0 x 0 x x 0 0 0 x 3 2 1 2 3 4 4 x * x 4 5 5 6 x 6 5 6 x x 8 7 x x u x u x x 10 8 9 x 10 u x