Final Exam CSCI-2540
What are the operations of an ADT list?
- Create an empty list - Determine a list is empty - Determine number of items of a list - Add an item - Remove the item - Remove all items - Retrieve (get) the item
What are the ADT stack operations?
- Create an empty stack - Determine whether a stack is empty - Add an item - Remove from stack - Remove all items - Retrieve from stack
Data items to be sorted can be
- Integers - Character strings - Objects
Encapsulation
- a principle of OOP - used to enforce walls of an ADT - combines ADT's data with its method to form an object - hides implementation details from a programmer
The ADT stack is implemented by using
- an array - ADT list - linked list
Properties of growth rates
- ignore low-order terms - ignore a mulitplicative constant - O(f(n)) + O(g(n)) = O(f(n) + O(g(n))
What is the strategy of a sequential search?
- look at each item in a data collection in turn, beginning with the first one. - Stop when the desired item is found, and reach the end of the data collection
The strategy of insert sort is
- partitioned array into two regions: sorted and unsorted - take each item from unsorted region and insert into the correct order in the sorted region.
If the item in position 1 of a list represents the top of the stack
- push(newItem) implemented as add(1, newItem) - pop() implemented as get(1), remove(1) - peek() operation is implemented as get(1)
Collection.sort() method
- sort a given list - in order to sort, the items must be able to compare orders (with compareTo method)
Average case analysis
A determination of the average amount of time that an algorithm requires to solve problems of size n
worst-case analysis
A determination of the maximum amount of time that an algorithm requires to solve problems of size n
Growth-rate function
A mathematical function used to specify an algorithm's order in terms of the size of the problem
Big O Notation
A notation that uses the capital letter O to specify an algorithm's order Example: O(f(n))
Order of an algorithm
Algorithm A is order f(n) - denoted O(f(n)) - if k and n0 exists that A required no more than k * f(n) time units to solve of size n ≥ n0.
What else about an ADT list?
All items are referenced by their position within the list.
What is the difference between an Iterator and a ListIterator?
An Iterator can be used on Collection types and only go forward, while an ListIterator can be used on list and it go forward and backward
Worst-case and average-case analyses
An algorithm requires different times to solve problems of the same size
What are the private data fields of a stack?
An array Objects called items, and the index top
Options for implementing an ADT is
Array and Linked list
What are the three classes of an ADT List
ArrayList by using arrays, LinkedList by using linked lists, and Vector is by using arrays.
What is an example of a data structure?
Arrays
In an ADT list
Each item has a unique predecessor and a unique successor. While the head or front does not have a unique predecessor and the tail or end does not have a unique successor.
Order of growth of some common functions
O(1) < O(log2n) < O(n) < O(log2n) < O(n2) < O(n3) < O(2n)
The worst case of a merge sort is
O(n log2 n)
The best case of bubble sort is
O(n)
The analysis of selection sort is
O(n2)
The worst case of bubble sort is
O(n2)
The worst case of insertion sort is
O(n2)
Analysis of algorithms
Provides tools for contrasting the efficiency of different methods of solution
What is a reference-based implementation of the stack?
Requires when as stack grows and shrink dynamically.
JCF contains an implementation of a stack class is called?
Stack (generic)
What is an implementation of StackArrayBased class?
StackInterface
What are the instances of a stack?
Stacks
What are the specifications of ADT operations?
They defined contract for the list and doesn't specify how to store lists or how to perform the operations.
A stack class is derived from what?
Vector
The efficiency of a sequential search is
Worst case: O(n) Average case: O(n) Best case: O(1)
external sort
a collection will not fit in the main memory all at once but reside in secondary storage
Data structure
a construct defined with a language that stores collection of data.
An array-based implementation is
a list's items stored in an array and a natural choice
Implementation details should be hidden behind a wall of ADT operations which
a program ability to access data structure using ADT operations.
Top
a reference to the head of a linked list of items
Typical operations on data includes:
add data, remove data, and ask questions in a data collection.
Three difficulties with comparing programs
algorithm coded, computer should use, and data should programs use.
For small arrays, the insertion sort is
appropriate due to its simplicity
The disadvantage of selection sort
appropriate for small n
Data abstraction
asks to thinks what can do to a collection of data independently of how to do it and allows to develop each data structure in relative isolation from the rest of the solution.
ADT operations
can be used in an application without knowledge of how operator will be implemented.
An ADT is composed of
collection of data, and a set of operations on that data
The strategy of a bubble sort is
comparing adjacent elements and exchange if out of order -By comparing the first two, the second and third, so on, and move the largest(or smallest) elements to the end of an array -Repeated the process will sort the array into descending or ascending order.
A module specification should....
detail how module behaves and identify details that hidden with the module
Choosing data structures to represent data is a part of implementation which leads of a data structure depends on
details of the ADT operations and context in which operations will be used.
The strategy of a mergesort is
dividing array into halves, sort each half, and merge the sorted ones into an sorted array
The advantage of selection sort
does not depend on the arrangement of the data
A reference-based implementation of a stack
does not put a limit on the size of the stack
An algorithm growth rate
enables comparison of one algorithm with another, which led algorithm A leds to n^2 and B leds to n
An array-based implementation of a stack uses
fixed-size arrays, that prevents the PUSH operation from adding an item to the stack if the limit has been reached
Iterator
gives ability to cycle through items in a collection and accesses next item by using ITER.NEXT()
Information hiding
hide implementation details within the module and make details accessible from outside module
StackReferenceBased
implements StackInterace
JCF
implements many of commonly used ADTs.
Implement of an ADT
includes choosing a particular data structure.
What are the categories of sorting algorithms?
internal and external sort
Search
is a 1-based position of an object of the stack
An array-based implementation
is a list's items are stored in an array ITEMS, a natural choice that includes both an array and a list identify items by a number, and a list's kth item will be store in ITEMS[K-1]
Sorting
is a process that organizes a collection of data into either ascending or descending order
List interface supports an order collection
is also known as a sequence.
Stack
is an Last-In, First-Out (LIFO) is the last item placed on as stack will be the first one removed
Resizable array
is an array that grows and shrinks as the program executes and an illusion created by using allocate and copy strategy with fixed-size arrays
What is a mergesort?
it is a recursive sorting algorithm that gives the same performance, regardless of the initial order of the array items.
JCF provides two iterator interfaces
java.util.Iterator and java.util.ListIterator
What are the important divide-and-conquer sorting algorithms?
mergesort and quicksort
What are the iterator methods?
next() and hasNext()
For large arrays, the insertion sort is
prohibitively inefficient.
StackInterface
provides a specification for the three implementations such as array, ADT list, and linked list
Stack includes methods like
push, pop, peek, and search
internal sort
requires the collection of data fit entirely in the computer's main memory
Data abstraction also
results in a wall between data structures and a program that accesses data with these data structures
The strategy of selection sort
select the largest item and put it in a correct place
Procedural abstraction
separates the purpose and use of a module from its implementation
A comparison of algorithms
should focus of significant difference in efficieny and not consider reductions in computing due to clever coding tricks.
The isolation of modules is not total when
specficiations, or contracts, govern how they interact with each other.
Sort key
the part of a record that determines the sorted order of the entire record within a collection records
The efficiency of a binary search is
the worst case of O(log2n)
The strategy of a binary search is
to search a sorted array for a item, which repeatedly divide the array in half, and determining which half must be, if it is indeed present, and discard the other half
Examples of an algorithm are
traversal of a linked list, Towers of Hanoi, and nested loops.
Collections framework are
unified architecture for representing and manipulating collections and includes interfaces, implementations, and algorithms.
StackException
used by StackInterface and extends java.lang.runtime
Specifications of an ADT indicates
what operations do, not implementing them.
Counting an algorithm operations in a way to access its efficieny is to...
which an algorithm's execution time is related to the number of operations it requires.