Data Structures Exam 1

What are the two main issues related to algorithms?

*1. How should you design them?* -Brute force (trial and error) -Divide and conquer -Etc. *2. How do you analyze algorithm efficiency?* -How good is the algorithm? (space efficiency, time efficiency) -Does there exist a better algorithm? (lower bounds, optimality)

Why should you study algorithms?

*1. Theoretical Importance* -the core of computer science *2. Practical importance* - framework of designing and analyzing algorithms for new problems

*COME BACK TO BIG O HERE IF NEEDED*

*COME BACK TO BIG O HERE IF NEEDED*

Example of Runtime Stack:

*main ( ) -> f1 ( ) -> f2 ( ) -> f3 ( )* (this represents functions calling other functions) Stack Snapshot: Activation Record of f3( ) Activation Record of f2( ) Activation Record of f1( ) Activation Record of main( ) - Empty Once f3 is completed, the record will be popped and f2 will resume. If f3 calls another function, the new function has its activation record pushed onto the stack and f3 will be suspended.

What are some applications of stacks?

-Evaluating expressions and parsing syntax -Balancing delimiters (brackets) in a program code -Converting numbers between bases -Processing financial data -Backtracking algorithms

What pointers are used in a queue?

-Head -Tail

What are the special cases associated with deletion?

-If the node being deleted is the only node in the list: head and tail need to be set to NULL. -If the list is empty: an attempt to delete a node should be handled and reported to the user

To implement linked lists, which classes should you use?

-IntSLLNode - define the nodes of the list -IntSLList - define two pointers (head and tail)

Stack

-Restricted access *linear data structure* -Follows a last-in-first-out (LIFO) structure

Queue

-Restricted access linear data structure -Follows a first-in-first-out (FIFO) structure -When you add an item, it will be added to the *rear* and when you delete an item, it will be deleted from the *front*

What are some disadvantages of circular lists?

-Similar to singly linked lists, it can be hard to delete the last node of the list. You would require a loop to locate the predecessor of the tail node. -It can be inefficient to process the list in the reverse because it travels with one pointer in one direction. Solution: Doubly Linked Circular Lists

What is included in an Activation Record? (Long Answer)

-Values of the function's parameters, addresses of reference variables (including arrays) -Copies of local variables -The return address of the calling function -A dynamic link to the calling function's activation record -The function's return value if it is not void

What are some restrictions on stacks?

-You can only remove items that are available. -You can't add any more items if there is no room.

What are some of the limitations of arrays?

-You must know the size of the array at the time the code is compiled -Consecutive - the elements of the array are required potentially extensive shifting when inserting a new element. Therefore, it can be hard to add something to the middle.

What are some queue operations?

-clear( ) - clears the queue -isEmpty( ) - determines if the queue is empty -enqueue(el) - adds the data item el to the end of the queue *-dequeue( )* - removes the element from the front of the queue *-firstEl( )* - returns the value of the first element of the queue without removing it.

Stack Operations:

-clear( ) - clears the stack -isEmpty( ) - determines if the stack is empty -push(el) - pushes the data item el onto the top of the stack *-pop( )* - removes the top element from the stack *-topEl( )* - returns the value of the top element of the stack without removing it

Data structures are implemented by...

...algorithms.

Repeated application of the inductive step will eventually lead to the...

...base case.

When you pop, the stack pointer is...

...decremented by 1.

When you push, the stack pointer is...

...incremented by 1.

If you have one node in a circular list, it's 'next' pointer will indicate...

...itself.

Data structures will be accessed by...

...our algorithms.

When the program arrives at the base case it will...

...pop activation records and return values.

As the amount of data and frequency of access increases...

...structures other than simple linking should be employed.

The return address will tell the program...

...where to resume execution after the called function has completed.

Example of a recursive definition:

0 ε N - Base Case if n ε N, then (n + 1) ε N - Inductive Clause

Provide the recursive definition of the factorial function:

1 if n = 0 n(n-1) if n > 0

What steps are taken when a function calls itself recursively?

1. *push* a new activation record of itself on the stack 2. *suspend* the calling instance of the function 3. *allow* the new activation to carry on the process

What are the two parts of a recursive definition?

1. Base case 2. Inductive clause

Suppose we have two algorithms, how can we tell which is better?

1. Implement both and compare - expensive and error prone 2. *Algorithm Analysis* - preferably, analyze them mathematically

What are the two data members that exist within a node?

1. Info - stores the node's data 2. Next - points to the next node in the list

What are the 4 different dynamic re-organizing techniques for lists?

1. Move-to-front 2. Transpose 3. Count 4. Ordering

What is included in an Activation Record? (Short Answer)

1. Return Address 2. Local Variables 3. Link 4. Return Value

What are the two measures of efficiency?

1. Time complexity 2. Space complexity

Tables

A data structure of choice in many applications due to their ease of implementation, use, and access.

Priority Queues

A queue where the priorities of the elements can affect the order of processing. Elements are removed based on priority and position

Algorithm

A series of instructions. A sequence of unambiguous instructions for solving a problem. Input -> *"computer"* -> output problem -> algorithm -> *"computer"*

Activation Record

A set of information that characterizes the state of the function.

Runtime Stack

A stack that stores information about the active subroutines of a computer program. The size will be determined at runtime. It will essentially be a compilation of activation records and will always contain the current state of the function.

Sparse Table

A table that is mostly unoccupied.

Data Structures

A technique of storing and organizing data so it can be used efficiently. Describe the data structure by the Abstract Data Type. Fundamental Data Structures: -List (array, linked list, string) -Stack/queue -Graph -Tree

What do we need to keep track of when a function is called?

Activation Record

What is a disadvantage of two two-dimensional arrays?

Although less wasteful than a single table, it is still wasteful and will be inflexible if conditions change. Solution: Two Arrays of Linked Lists

What are some disadvantages of skip lists?

Although you can search more efficiently, you are doing it at the expense of your insertion and deletion functions. Solution: Dynamically re-ordering the lists as they are used

Abstract Data Types

An item defined by a *series of operations*. Can be implemented through class definitions in an object-oriented language. Ex. Stack - based on a stack data structure, which operations should we use? (push, pop, top, etc.)

What is a disadvantage of single-linked lists?

As the list gets longer, you would need to add more and more 'next' pointers that need to be followed to a given node. This is not *scalable* (will become more and more inefficient as the number of data grows). Ex. p -> next -> next -> info; (add another node) p -> next -> next -> next -> info; Solution: Head and Tail Pointers

What are some more drawbacks to linked lists?

Because linked lists are sequential in nature, it can take a long time to search for a specific node (you must travel node by node). Even if you order the elements on frequency, you still would need sequential access. Solution: skip lists

How do we know recursion will be implemented and handled correctly?

Because of the use of activation records on the runtime stack.

Why do we use linked lists instead of arrays?

Because they are more flexible.

Why do we need to keep track of our *Return Address* when a function is called?

Because this is where you will resume the calling function once the called function is complete.

Why do we need to keep track of the *Stack* when a function is called?

Because we don't know how many calls will occur and the stack is a great place to save this information.

How does the program know how much space to reserve for return values?

By the data type of the return value

For which kind of list do the nodes form a ring?

Circular Lists

Linked Lists

Collections of independent memory locations (nodes) that store data and links to other nodes.

What is Big-O Notation used for?

Comparing the efficiency of two algorithms (determining asymptotic analysis).

Recursive Call

Creates a series of activation records for different instances of the *same* function

Algorithm Complexity

Efficiency depending on the amount of data the algorithm must process.

Inductive Clause

Establishes rules for the creation of new elements in the set.

Base case

Establishes the basis for all the other elements of the set.

Machine-Independent

Fairly compare algorithms regardless of what machine it is running on (some machines will run slower).

Why can it be difficult to implement a priority queue?

It can be difficult to accommodate priorities all while maintaining efficient enqueuing and dequeuing.

What is a disadvantage of singly linked lists?

It can be difficult to delete a node from the end of a singly linked list. You must continually scan to the node just before the end in order to delete it correctly. Solution: Doubly Linked Lists

What happens every time a function is called?

It's activation record is created and placed on the runtime stack.

What is a disadvantage of self-ordering lists?

It's fine for a small amount of input, but as your input increases you can see scalability problems.

What kind of linear structure does a Stack have?

Last-in-first-out (LIFO) (items can only be added and removed from one end)

Big-O Notation Definition

Let f(n) and g(n) be functions where n is a positive integer. We write *f(n) = O(g(n))* if and only if there exists a real number c and a positive integer N satisfying *0 ≤ f(n) ≤ cg(n)* for all n ≥ N.

When searching, do we modify the list?

No

Skip Lists

Non-Sequential searching of a linked list. They can have different patterns to them. *read more on skip lists*

How many permanent pointers do circular lists require?

One (tail)

Define program behavior in terms of __________ to be performed on data.

Operations

How can you implement linked lists?

Pointers. They allow us great flexibility.

*Links* to other nodes contain:

The addresses of the nodes. You can follow the links to move between the different nodes.

Space Complexity

The amount of *memory (space)* an algorithm takes in terms of the amount of input.

Time Complexity

The amount of *time* an algorithm takes in terms of the amount of input.

Ordering

The list is ordered based on the natural nature of the data.

Count

The list is ordered by frequency of access.

How are doubly linked lists different from singly linked lists?

The node structure of a DLL includes a second pointer that points to the previous node.

Circular Lists

The nodes will form a ring. Circular lists require only one permanent pointer (which is usually referred to as tail).

Why would we use a recursive function as opposed to a non-recursive function providing the same result?

The recursive function is more intuitive, closer to the specification, and simpler to code.

What does it mean to say that a data structure has a "restricted access linear data structure"?

The structure can only be accessed at one of its ends for adding and removing data elements.

What is a disadvantage of a two-dimensional array?

There are too many open spaces. Solution: Two two-dimensional arrays

What is a pro of using two arrays of linked lists to create a sparse table?

There is no wasted space and the lists are extensible (therefore flexible).

What are some advantages of skip lists?

They speed up the searching process in lists.

What will the List class define?

Two pointers: head and tail.

Applications of Queues:

Used in a large variety - especially used in studies of service simulations. Also can be found in *queuing theory* (a very advanced body of mathematical theory).

How is a queue implemented?

Using an array (ex. vector)

Are we more interest in space or time complexity?

Usually, time complexity.

Why do we need to keep track of *Local Variables* when a function is called?

We need them for scope purposes because functions can be called from other functions.

Why do we need to keep track of *Parameters* when a function is called?

We need to initialize them to their corresponding arguments.

Asymptotic Complexity

When *n (number of input items)* goes to infinity, what happens to the algorithm's performance?

When are stacks useful?

When data has to be stored and processed in reverse order.

When do we end our searching?

When either... The info member of the node tmp points to matches the target OR tmp -> next is NULL (reached the end of list and the search fails)

Move-to-Front

When found, the target is moved to the front of the list.

When does the program know to return values?

When it reaches the base case.

Transpose

When the element is found, it is swapped with its predecessor in the list.

When would you use an array to implement a stack?

When you have a fixed size before your operations. Ex. a[10]

When would you use a vector to implement a stack?

When you want to dynamically allocate your memory. A vector is essentially an array that can grow.

Stack Pointer

Will indicate the top element of a stack.

How can you implement a stack?

With either an array or a vector.

Doubly Linked Circular Lists

You will form two rings. You can move forward through the *next pointers* or you can move backwards through the *prev pointers*.