![time space tradeoff
A time space tradeoff is a situation where the memory use
can be reduced at the cost of slower program execution
(and, conversely, the computation time can be reduced at
the cost of increased memory use).
As the relative costs of CPU cycles, RAM space, and hard
drive space change—hard drive space has for some time
been getting cheaper at a much faster rate than other
components of computers[citation needed]—the
appropriate choices for time space tradeoff have changed
radically.
Often, by exploiting a time space tradeoff, a program can
be made to run much faster.](https://image.slidesharecdn.com/ds1-basicdatastructure-180827163430/85/Data-Structure-and-Algorithms-12-320.jpg)
Data Structure and Algorithms
- 1. Introduction: Basic Concepts and Notations Complexity analysis: time space tradeoff Algorithmic notations, Big O notation Introduction to omega, theta and little o notation
- 2. Basic Concepts and Notations Algorithm: Outline, the essence of a computational procedure, step-by-step instructions Program: an implementation of an algorithm in some programming language Data Structure: Organization of data needed to solve the problem
- 3. Classification of Data StructuresData Structures Primitive Data Structures Non-Primitive Data Structures Linear Data Structures Non-Linear Data Structures • Integer • Real • Character • Boolean • Array • Stack • Queue • Linked List • Tree • Graph
- 4. Data Structure Operations Data Structures are processed by using certain operations. 1.Traversing: Accessing each record exactly once so that certain items in the record may be processed. 2.Searching: Finding the location of the record with a given key value, or finding the location of all the records that satisfy one or more conditions. 3.Inserting: Adding a new record to the structure. 4.Deleting: Removing a record from the structure.
- 5. Special Data Structure- Operations • Sorting: Arranging the records in some logical order (Alphabetical or numerical order). • Merging: Combining the records in two different sorted files into a single sorted file.
- 6. Algorithmic Problem Infinite number of input instances satisfying the specification. For example: A sorted, non-decreasing sequence of natural numbers of non-zero, finite length: 1, 20, 908, 909, 100000, 1000000000. 3. Specification of input ? Specification of output as a function of input
- 7. Algorithmic Solution Algorithm describes actions on the input instance Infinitely many correct algorithms for the same algorithmic problem Specification of input Algorithm Specification of output as a function of input
- 8. What is a Good Algorithm? Efficient: Running time Space used Efficiency as a function of input size: The number of bits in an input number Number of data elements(numbers, points)
- 9. Complexity analysis Why we should analyze algorithms? Predict the resources that the algorithm requires Computational time (CPU consumption) Memory space (RAM consumption) Communication bandwidth consumption The running time of an algorithm is: The total number of primitive operations executed (machine independent steps) Also known as algorithm complexity
- 10. Time Complexity Worst-case An upper bound on the running time for any input of given size Average-case Assume all inputs of a given size are equally likely Best-case The lower bound on the running time
- 11. Time Complexity – Example Sequential search in a list of size n Worst-case: n comparisons Best-case: 1 comparison Average-case: n/2 comparisons
- 12. time space tradeoff A time space tradeoff is a situation where the memory use can be reduced at the cost of slower program execution (and, conversely, the computation time can be reduced at the cost of increased memory use). As the relative costs of CPU cycles, RAM space, and hard drive space change—hard drive space has for some time been getting cheaper at a much faster rate than other components of computers[citation needed]—the appropriate choices for time space tradeoff have changed radically. Often, by exploiting a time space tradeoff, a program can be made to run much faster.
- 13. Asymptotic notations Algorithm complexity is rough estimation of the number of steps performed by given computation depending on the size of the input data Measured through asymptotic notation O(g) where g is a function of the input data size Examples: Linear complexity O(n) – all elements are processed once (or constant number of times) Quadratic complexity O(n2 ) – each of the elements is processed n times
- 15. Example The running time is O(n2 ) means there is a function f(n) that is O(n2 ) such that for any value of n, no matter what particular input of size n is chosen, the running time of that input is bounded from above by the value f(n). 3 * n2 + n/2 + 12 ∈ O(n2 ) 4*n*log2(3*n+1) + 2*n-1 ∈ O(n * log n)
- 16. Ω notation Asymptotic lower bound
- 17. Example When we say that the running time (no modifier) of an algorithm is Ω (g(n)). we mean that no matter what particular input of size n is chosen for each value of n, the running time on that input is at least a constant times g(n), for sufficiently large n. n3 + 20n ∈ Ω(n2 )
- 18. Θ notation g(n) is an asymptotically tight bound of f(n)
- 19. Example
- 21. ω-notation
- 22. 22 Notes on o-notation O-notation may or may not be asymptotically tight for upper bound. 2n2 = O(n2 ) is tight, but 2n = O(n2 ) is not tight. o-notition is used to denote an upper bound that is not tight. 2n = o(n2 ), but 2n2 ≠ o(n2 ). Difference: for some positive constant c in O- notation, but all positive constants c in o- notation. In o-notation, f(n) becomes insignificant relative to g(n) as n approaches infinitely.
- 23. Big O notation f(n)=O(g(n)) iff there exist a positive constant c and non-negative integer n0 such that f(n) ≤ cg(n) for all n≥n0. g(n) is said to be an upper bound of f(n).
- 24. Basic rules 1. Nested loops are multiplied together. 2. Sequential loops are added. 3. Only the largest term is kept, all others are dropped. 4. Constants are dropped. 5. Conditional checks are constant (i.e. 1).
- 25. Example 1 //linear for(i = 1 to n) { display i; }
- 26. Ans: O(n)
- 27. Example 2 //quadratic for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++){ //do swap stuff, constant time } }
- 28. Ans O(n^2)
- 29. Example 3 for(int i = 0; i < 2*n; i++) { cout << i << endl; }
- 30. At first you might say that the upper bound is O(2n); however, we drop constants so it becomes O(n)
- 31. Example 4 //linear for(int i = 0; i < n; i++) { cout << i << endl; } //quadratic for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++){ //do constant time stuff } }
- 32. Ans : In this case we add each loop's Big O, in this case n+n^2. O(n^2+n) is not an acceptable answer since we must drop the lowest term. The upper bound is O(n^2). Why? Because it has the largest growth rate
- 33. Example 5 for(int i = 0; i < n; i++) { for(int j = 0; j < 2; j++){ //do stuff } }
- 34. Ans: Outer loop is 'n', inner loop is 2, this we have 2n, dropped constant gives up O(n)
- 35. Example 6 for(int i = 1; i < n; i *= 2) { cout << i << endl; }
- 36. There are n iterations, however, instead of simply incrementing, 'i' is increased by 2*itself each run. Thus the loop is log(n).
- 37. Example 7 for(int i = 0; i < n; i++) { //linear for(int j = 1; j < n; j *= 2){ // log (n) //do constant time stuff } }
- 38. Ans: n*log(n)
- 39. Comp 122
- 40. Thank You
Editor's Notes
- #4: 목차 자바의 생성배경 자바를 사용하는 이유 과거, 현재, 미래의 자바 자바의 발전과정 버전별 JDK에 대한 설명 자바와 C++의 차이점 자바의 성능 자바 관련 산업(?)의 경향
- #5: 목차 자바의 생성배경 자바를 사용하는 이유 과거, 현재, 미래의 자바 자바의 발전과정 버전별 JDK에 대한 설명 자바와 C++의 차이점 자바의 성능 자바 관련 산업(?)의 경향
- #6: 목차 자바의 생성배경 자바를 사용하는 이유 과거, 현재, 미래의 자바 자바의 발전과정 버전별 JDK에 대한 설명 자바와 C++의 차이점 자바의 성능 자바 관련 산업(?)의 경향