1 / 51

Exam1 Review

Exam1 Review. Dr. Bernard Chen Ph.D. University of Central Arkansas Spring 2010. Software Development Phases. Problem Analysis and Specification Design Coding Testing, Execution, and Debugging Maintenance. Software Development Model.

zander
Download Presentation

Exam1 Review

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Exam1 Review Dr. Bernard Chen Ph.D. University of Central Arkansas Spring 2010

  2. Software Development Phases • Problem Analysis and Specification • Design • Coding • Testing, Execution, and Debugging • Maintenance

  3. Software Development Model • One of the earliest strategies for development software is known as the Waterfall Model

  4. Waterfall Model

  5. Realistic Waterfall Model

  6. Software Development Phases • Problem Analysis and Specification • Design • Coding • Testing, Execution, and Debugging • Maintenance

  7. Testing, Execution, and Debugging • Errors happen all the time!!! • There are three different points at which errors can be introduced: • Syntax errors • Run-time errors • Logic errors

  8. The "V" Life Cycle Model

  9. Two major types of testing • Black box testing: Outputs produced for various inputs • Checked for correctness • Do not consider structure of program component itself. (so basically, it just test a lot of different inputs and match with the expected outputs )

  10. Two major types of testing • White box testing: examine code’s internal structure (Test for every loop, if statement, functions…) • Test data is carefully selected

  11. What is Algorithm Analysis? • Algorithm: A clearly specified finite set of instructions a computer follows to solve a problem. • Algorithm analysis: a process of determining the amount of time, resource, etc. required when executing an algorithm.

  12. Big O Notation • Big O notation is used to capture the most dominant term in a function, and to represent the growth rate. • Also called asymptotic upper bound. Ex: 100n3 + 30000n =>O(n3) 100n3 + 2n5+ 30000n =>O(n5)

  13. Sequential Search • A sequential search steps through the data sequentially until an match is found. • A sequential search is useful when the array is not sorted. • A sequential search is linear O(n) (i.e. proportional to the size of input) • Unsuccessful search --- n times • Successful search (worst) --- n times • Successful search (average) --- n/2 times

  14. Binary Search • If the array has been sorted, we can use binary search, which is performed from the middle of the array rather than the end. • We keep track of low_end and high_end, which delimit the portion of the array in which an item, if present, must reside. • If low_end is larger than high_end, we know the item is not present.

  15. Binary Search 3-ways comparisons int binarySearch(vector<int> a[], int x){ int low = 0; int high = a.size() – 1; int mid; while(low < high) { mid = (low + high) / 2; if(a[mid] < x) low = mid + 1; else if( a[mid] > x) high = mid - 1; else return mid; } return NOT_FOUND; // NOT_FOUND = -1 }//binary search using three-ways comparisons

  16. The Max. Contiguous Subsequence • Given (possibly negative) integers A1, A2, .., An, find (and identify the sequence corresponding to) the max. value of sum of Ak where k = i -> j. The max. contiguous sequence sum is zero if all the integer are negative. • {-2, 11, -4, 13, -5, 2} =>20 • {1, -3, 4, -2, -1, 6} => 7

  17. O(N) Algorithm template <class Comparable> int maxSubsequenceSum(int a[]){ int n = a.size(); int thisSum = 0, maxSum = 0; int i=0; for( int j = 0; j < n; j++){ thisSum += a[j]; if( thisSum > maxSum){ maxSum = thisSum; seqStart = i; seqEnd = j; }else if( thisSum < 0) { i = j + 1; thisSum = 0; } } return maxSum; }//figure 6.8

  18. Introduction to Stacks • This type of last-in-first-out processing occurs in a wide variety of applications • This last-in-first-out (LIFO) data structure is called a Stack • Adding an item to a stack is referred to as pushing that item onto the stack • Removing an item from the stack is referred to as popping the stack

  19. Designing and Building a Stack class • The basic functions are: • Constructor: construct an empty stack • Empty(): Examines whether the stack is empty or not • Push(): Add a value at the top of the stack • Top(): Read the value at the top of the stack • Pop(): Remove the value at the top of the stack • Display(): Displays all the elements in the stack

  20. Select position 0 as bottom of the stack • A better approach is to let position 0 be the bottom of the stack • Thus our design will include • An array to hold the stack elements • An integer to indicate the top of the stack

  21. Implementing Linked Stack Operations • Constructor • Simply assign null pointer to myTop • Empty • Check for myTop == null • Push • Insertion at beginning of list • Top • Return data to which myToppoints

  22. Implementing Linked Stack Operations • Pop • Delete first node in the linked listptr = myTop;myTop = myTop->next;delete ptr; • Output • Traverse the listfor (ptr = myTop; ptr != 0; ptr = ptr->next) out << ptr->data << endl;

  23. Functions related to Stack • Constructor: vector<int> L; • Empty(): L.size() == 0? • Push(): L.push_back(value); • Top(): L.back(); • Pop(): L.pop_back(); • Display(): Write your own

  24. Introduction to Queues • A queue is a waiting line • It’s in daily life: • A line of persons waiting to check out at a supermarket • A line of persons waiting to purchase a ticket for a film • A line of planes waiting to take off at an airport • A line of vehicles at a toll booth

  25. Introduction to Queues • Difference between Stack and Queues: • Stack exhibits last-in-first-out (LIFO) • Queue exhibits first-in-first-out (FIFO)

  26. Queue ADT • Basic operations • Construct a queue • Check if empty • Enqueue (add element to back) • Front (retrieve value of element from front) • Dequeue (remove element from front)

  27. Designing and Building a Queue Class Array-Based • Consider an array in which to store a queue • Note additional variables needed • myFront, myBack • Picture a queueobject like this

  28. Circular Queue • Problems • We quickly "walk off the end" of the array • Possible solutions • Shift array elements • Use a circular queue • Note that both emptyand full queuegives myBack == myFront

  29. Circular Queue • Using a static array • QUEUE_CAPACITY specified • Enqueue increments myBack using mod operator, checks for full queue • Dequeue increments myFront using mod operator, checks for empty queue

  30. Circular Example Both Front and Back wraparound as needed. b c d e f Front Back g b c d e f Back Front

  31. Queue Full Situation • If an item were stored in the last position, and an Enqueure() occurred • myBack would be incremented by 1, giving it the same value as myFront • However, myFront == myBack indicates the queue is empty • Thus, we cannot distinguish between empty and full • We may avoid this situation by maintaining one empty position, so that myFront will never equal to myBack unless the queue is empty

  32. Algorithm for Enqueue(value) • 1. Set newBack == (myBack+1)%Queue_capacity • 2. If newBack == myFront Signal “Queue Full” otherwise: Set Array[myBack] == value Set myBack == newBack

  33. Algorithm for Dequeue() • If queue is empty signal “Queue Empty” Otherwise Set myFront=(myFront+1)%Queue_capacity

  34. Enqueue and Front Enqueue (add element to back) This is the same with push(), therefore: L.push_back(value); Front (retrieve value of element from front) L.begin();

  35. Dequeue Dequeue (remove element from front) L.erase(L.begin()); L.begin() is an iterator, in erase(), you cannot just gives the location

  36. Queue + Stack SCROLL: a queue-stack hybrid model Thus, you may have functions in both— Push(value)=Enqueue(value) Pop(); Top() --- top of stack Dequeue(); Front()

  37. Consider Every Day Lists • Groceries to be purchased • Job to-do list • List of assignments for a course • Dean's list • Can you name some others??

  38. LIST ADT • Collection of data elements • A sequence with a finite number of data items, all of the same type • Basic operations • Construction---create a empty list • Empty---check if the list is empty • Insert---insert an item • Delete---remove a item • Traverse---go through the list or part of it

  39. Static Array based • Insert: we need to do • Check the capacity • Need to move array elements to make room for the new element

  40. Static Array based • Algorithm for insert: If size is equal to capacity: display error due to limit space If pos < 0 or pos > size: display error due to error position Else: for i in rangeing from size to pos+1: array[i]=array[i-1] //C++ starts index from 0 array[pos]=item size++

  41. Static Array based • The efficiency of this insert algorithm obviously depends on the number of array elements that must be shifted to make room for the new item • In worst case, the new item must be inserted at the beginning of the list O(n) • The best case occurs when the new item is inserted at the end of it O(1) • Two important special kinds of lists for which are stacks and queues

  42. Static Array based • Delete: also requires shifting array elements • For example, to delete the second item in: 23, 25, 34, 48, 56, 61, 79, 82, 89, 91, 99

  43. Static Array based • Algorithm for delete: If size is zero: issue a error message If pos <0 or pos >=size: issue an error message Otherwise: for index i ranging from pos to size-2: array[i]=array[i+1] size--

  44. Linked List • Linked list nodes contain • Data part – stores an element of the list • Next part – stores link/pointer to next element (when no next element, null value)

  45. Traverse • We begin by initializing an auxiliary variable ptr to point to the first node: • Initialize a variable ptr to point to first node • Process data where ptr points

  46. Insertion • To insert a new data value into a linked list, we must first obtain a new node and store the value in its data part • The second step is to connect this new node to existing list • Two cases in this situation: (1) insertion after some element in the list and (2) insertion at the beginning of the list

  47. predptr 20 newptr Insertion • Insertion • To insert 20 after 17 • Need address of item before point of insertion • predptr points to the node containing 17 • Get a new node pointed to by newptr and store 20 in it • Set the next pointer of this new node equal to the next pointer in its predecessor, thus making it point to its successor. • Reset the next pointer of its predecessor to point to this new node

  48. Deletion • For deletion, there are also two cases to consider: • Deleting an element that has a predecessor • Delete the first element in the list

  49. predptr To free space Deletion ptr • Delete node containing 22 from list. • Suppose ptr points to the node to be deleted • predptr points to its predecessor (the 17) • Do a bypass operation: • Set the next pointer in the predecessor to point to the successor of the node to be deleted • Deallocate the node being deleted.

  50. Array-Based Implementation of Linked Lists • Given a list with names • Implementation would look like this

More Related