|
|
| Line 1: |
Line 1: |
| {{more footnotes|date=March 2010}}
| | The new Gallup-Healthways Well-Being Index introduced its newest findings plus found which Colorado has the lowest weight rate in the nation The Centennial State is truly the only state with an obesity rating lower than 20. Meanwhile, West Virginia reported the highest weight rate inside the nation.<br><br>Raspberries inside addition to blackberries are in the identical genus and are placed directly beneath the went up family. These are typically found inside creating fragrances, cosmetics plus food synthetic additives too. These are generally edible gentle fruits which might be utilized either raw, inside state of notice or in keeps plus jams. Eating usually the raspberries also as blackberries has been said to be an simple way00 of getting the leading compounds the entire body requires.<br><br>raspberry ketone is the newest fad amidst the fat watchers. Unlike additional fat burners and weight reduction medications, it's 1 product which seems to be efficient and secure at the same time.<br><br>Day 3: I continued to drink the Raspberry Leaf tea with lunch plus dinner and also between food. I choose the iced tea over the hot tea considering I reside in a hot climate. It keeps me refreshed all day long. I no longer had headaches from caffeine withdrawal, yet felt moody.<br><br>Two of the supplements featured on his show, nevertheless, [http://safedietplansforwomen.com/raspberry-ketones raspberry ketone] plus saffron extract, have been especially well-received. Dr. Oz views raspberry ketones as a weight loss "miracle" supplement (click here for the original story), because studies show which it will assist to burn fat more effectively. However, it's significant to make sure you're buying the right kind of the advantageous quality. Click here for Dr. Oz's cautions.<br><br>For my supplements - What folks don't realize is the mixture of drinking a great deal of water and raspberry ketone diet working out is fantastic, however; what makes the fat loss amazing plus practically instantaneous is taking supplements to support it.<br><br>Alternatively, you are able to walk briskly for around 30 minutes every day, or swim or cycle for about an hr. These workouts might not just grow your stamina, yet might help you remain inside a advantageous mood despite the mood swings. After the age of 40, this really is one of the primary components of diet plans for ladies to lose fat quick.<br><br>Its extremely tuff task for me to obtain certain strong proofs claim which Raspberry Ketone helps we to lose the fat. So it's greater for you to go from from all bad plus advantageous regarding this formula before begin utilizing it. |
| | |
| In [[computer science]], the '''analysis of algorithms''' is the determination of the amount of resources (such as time and storage) necessary to execute them. Most [[algorithm]]s are designed to work with inputs of arbitrary length. Usually, the efficiency or running time of an algorithm is stated as a function relating the input length to the number of steps ([[time complexity]]) or storage locations (space complexity).
| |
| | |
| Algorithm analysis is an important part of a broader [[computational complexity theory]], which provides theoretical estimates for the resources needed by any algorithm which solves a given computational problem. These estimates provide an insight into reasonable directions of search for efficient algorithms.
| |
| | |
| In theoretical analysis of algorithms it is common to estimate their complexity in the asymptotic sense, i.e., to estimate the complexity function for arbitrarily large input. [[Big O notation]], [[Big-omega notation]] and [[Big-theta notation]] are used to this end. For instance, [[binary search]] is said to run in a number of steps proportional to the logarithm of the length of the list being searched, or in O(log(n)), colloquially "in [[logarithmic time]]". Usually [[Asymptotic analysis|asymptotic]] estimates are used because different [[implementation]]s of the same algorithm may differ in efficiency. However the efficiencies of any two "reasonable" implementations of a given algorithm are related by a constant multiplicative factor called a ''hidden constant''.
| |
| | |
| Exact (not asymptotic) measures of efficiency can sometimes be computed but they usually require certain assumptions concerning the particular implementation of the algorithm, called [[model of computation]]. A model of computation may be defined in terms of an [[abstract machine|abstract computer]], e.g., [[Turing machine]], and/or by postulating that certain operations are executed in unit time.
| |
| For example, if the sorted list to which we apply binary search has ''n'' elements, and we can guarantee that each lookup of an element in the list can be done in unit time, then at most log<sub>2</sub> ''n'' + 1 time units are needed to return an answer.
| |
| <!-- Exact measures of efficiency are useful to the people who actually implement and use algorithms, because they are more precise and thus enable them to know how much time they can expect to spend in execution. To some people (e.g. game programmers), a hidden constant can make all the difference between success and failure.-->
| |
| | |
| == Cost models ==
| |
| Time efficiency estimates depend on what we define to be a step. For the analysis to correspond usefully to the actual execution time, the time required to perform a step must be guaranteed to be bounded above by a constant. One must be careful here; for instance, some analyses count an addition of two numbers as one step. This assumption may not be warranted in certain contexts. For example, if the numbers involved in a computation may be arbitrarily large, the time required by a single addition can no longer be assumed to be constant.
| |
| | |
| Two cost models are generally used:<ref name="AhoHopcroft1974">{{cite book|author1=Alfred V. Aho|author2=John E. Hopcroft|author3=Jeffrey D. Ullman|title=The design and analysis of computer algorithms|year=1974|publisher=Addison-Wesley Pub. Co.}}, section 1.3</ref><ref name="Hromkovič2004">{{cite book|author=Juraj Hromkovič|title=Theoretical computer science: introduction to Automata, computability, complexity, algorithmics, randomization, communication, and cryptography|url=http://books.google.com/books?id=KpNet-n262QC&pg=PA177|year=2004|publisher=Springer|isbn=978-3-540-14015-3|pages=177–178}}</ref><ref name="Ausiello1999">{{cite book|author=Giorgio Ausiello|title=Complexity and approximation: combinatorial optimization problems and their approximability properties|url=http://books.google.com/books?id=Yxxw90d9AuMC&pg=PA3|year=1999|publisher=Springer|isbn=978-3-540-65431-5|pages=3–8}}</ref><ref name=Wegener20>{{Citation|last1=Wegener|first1=Ingo|title=Complexity theory: exploring the limits of efficient algorithms|publisher=[[Springer-Verlag]]|location=Berlin, New York|isbn=978-3-540-21045-0|year=2005|page=20|url=http://books.google.com/books?id=u7DZSDSUYlQC&pg=PA20}}</ref><ref name="Tarjan1983">{{cite book|author=[[Robert Endre Tarjan]]|title=Data structures and network algorithms|url=http://books.google.com/books?id=JiC7mIqg-X4C&pg=PA3|year=1983|publisher=SIAM|isbn=978-0-89871-187-5|pages=3–7}}</ref>
| |
| * the '''uniform cost model''', also called '''uniform-cost measurement''' (and similar variations), assigns a constant cost to every machine operation, regardless of the size of the numbers involved
| |
| * the '''logarithmic cost model''', also called '''logarithmic-cost measurement''' (and variations thereof), assigns a cost to every machine operation proportional to the number of bits involved
| |
| | |
| The latter is more cumbersome to use, so it's only employed when necessary, for example in the analysis of [[arbitrary-precision arithmetic]] algorithms, like those used in [[cryptography]].
| |
| | |
| A key point which is often overlooked is that published lower bounds for problems are often given for a model of computation that is more restricted than the set of operations that you could use in practice and therefore there are algorithms that are faster than what would naively be thought possible.<ref>[http://cstheory.stackexchange.com/questions/608/examples-of-the-price-of-abstraction Examples of the price of abstraction?], cstheory.stackexchange.com</ref>
| |
| | |
| ==Run-time analysis==
| |
| Run-time analysis is a theoretical classification that estimates and anticipates the increase in ''[[DTIME|running time]]'' (or run-time) of an [[algorithm]] as its ''[[Information|input size]]'' (usually denoted as ''n'') increases. Run-time efficiency is a topic of great interest in [[computer science]]: A [[Computer program|program]] can take seconds, hours or even years to finish executing, depending on which algorithm it implements (see also [[Profiling (computer programming)|performance analysis]], which is the analysis of an algorithm's run-time in practice).
| |
| | |
| ===Shortcomings of empirical metrics===
| |
| | |
| Since algorithms are [[platform-independent]] (i.e. a given algorithm can be implemented in an arbitrary [[programming language]] on an arbitrary [[computer]] running an arbitrary [[operating system]]), there are significant drawbacks to using an [[empirical]] approach to gauge the comparative performance of a given set of algorithms.
| |
| | |
| Take as an example a program that looks up a specific entry in a [[collation|sorted]] [[list (computing)|list]] of size ''n''. Suppose this program were implemented on Computer A, a state-of-the-art machine, using a [[linear search]] algorithm, and on Computer B, a much slower machine, using a [[binary search algorithm]]. [[benchmark (computing)|Benchmark testing]] on the two computers running their respective programs might look something like the following:
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| ! ''n'' (list size)
| |
| ! Computer A run-time<br />(in [[nanosecond]]s)
| |
| ! Computer B run-time<br />(in [[nanosecond]]s)
| |
| |-
| |
| | 15
| |
| | 7
| |
| | 100,000
| |
| |-
| |
| | 65
| |
| | 32
| |
| | 150,000
| |
| |-
| |
| | 250
| |
| | 125
| |
| | 200,000
| |
| |-
| |
| | 1,000
| |
| | 500
| |
| | 250,000
| |
| |}
| |
| | |
| Based on these metrics, it would be easy to jump to the conclusion that ''Computer A'' is running an algorithm that is far superior in efficiency to that of ''Computer B''. However, if the size of the input-list is increased to a sufficient number, that conclusion is dramatically demonstrated to be in error:
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| ! ''n'' (list size)
| |
| ! Computer A run-time<br />(in [[nanosecond]]s)
| |
| ! Computer B run-time<br />(in [[nanosecond]]s)
| |
| |-
| |
| | 15
| |
| | 7
| |
| | 100,000
| |
| |-
| |
| | 65
| |
| | 32
| |
| | 150,000
| |
| |-
| |
| | 250
| |
| | 125
| |
| | 200,000
| |
| |-
| |
| | 1,000
| |
| | 500
| |
| | 250,000
| |
| |-
| |
| | ...
| |
| | ...
| |
| | ...
| |
| |-
| |
| | 1,000,000
| |
| | 500,000
| |
| | 500,000
| |
| |-
| |
| | 4,000,000
| |
| | 2,000,000
| |
| | 550,000
| |
| |-
| |
| | 16,000,000
| |
| | 8,000,000
| |
| | 600,000
| |
| |-
| |
| | ...
| |
| | ...
| |
| | ...
| |
| |-
| |
| | 63,072 × 10<sup>12</sup>
| |
| | 31,536 × 10<sup>12</sup> ns,<br />or 1 year
| |
| | 1,375,000 ns,<br />or 1.375 milliseconds
| |
| |}
| |
| | |
| Computer A, running the linear search program, exhibits a [[linear]] growth rate. The program's run-time is directly proportional to its input size. Doubling the input size doubles the run time, quadrupling the input size quadruples the run-time, and so forth. On the other hand, Computer B, running the binary search program, exhibits a [[logarithm]]ic growth rate. Doubling the input size only increases the run time by a [[wiktionary:Constant|constant]] amount (in this example, 25,000 ns). Even though Computer A is ostensibly a faster machine, Computer B will inevitably surpass Computer A in run-time because it's running an algorithm with a much slower growth rate.
| |
| | |
| ===Orders of growth===
| |
| {{main|Big O notation}}
| |
| Informally, an algorithm can be said to exhibit a growth rate on the order of a [[Function (mathematics)|mathematical function]] if beyond a certain input size ''n'', the function ''f(n)'' times a positive constant provides an [[Asymptotic analysis|upper bound or limit]] for the run-time of that algorithm. In other words, for a given input size ''n'' greater than some ''n<sub>0</sub>'' and a constant ''c'', the running time of that algorithm will never be larger than ''c × f(n)''. This concept is frequently expressed using Big O notation. For example, since the run-time of [[insertion sort]] [[quadratic growth|grows quadratically]] as its input size increases, insertion sort can be said to be of order ''O(n²)''.
| |
| | |
| Big O notation is a convenient way to express the [[Best, worst and average case|worst-case scenario]] for a given algorithm, although it can also be used to express the average-case — for example, the worst-case scenario for [[quicksort]] is ''O(n²)'', but the average-case run-time is ''O(n log n)''.<ref>The term ''lg'' is often used as shorthand for log<sub>2</sub></ref>
| |
| | |
| ===Empirical orders of growth===
| |
| | |
| Assuming the execution time follows power rule, ''{{math|≈ k n<sup>a</sup>}}'', the coefficient ''a'' can be found <ref>[http://rjlipton.wordpress.com/2009/07/24/how-to-avoid-o-abuse-and-bribes/ How To Avoid O-Abuse and Bribes], at the blog "Gödel’s Lost Letter and P=NP" by R. J. Lipton, professor of Computer Science at Georgia Tech, recounting idea by Robert Sedgewick</ref> by taking empirical measurements of run time <math>\{t1, t2\}</math> at some problem-size points <math>\{n1, n2\}</math>, and calculating <math>t_2/t_1 = (n_2/n_1)^a</math> so that <math>a = \log(t_2/t_1) / \log(n_2/n_1)</math>. If the order of growth indeed follows the power rule, the empirical value of ''a'' will stay constant at different ranges, and if not, it will change - but still could serve for comparison of any two given algorithms as to their ''empirical local orders of growth'' behaviour. Applied to the above table:
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| ! ''n'' (list size)
| |
| ! Computer A run-time<br />(in [[nanosecond]]s)
| |
| ! Local order of growth<br />(n^_)
| |
| ! Computer B run-time<br />(in [[nanosecond]]s)
| |
| ! Local order of growth<br />(n^_)
| |
| |-
| |
| | 15
| |
| | 7
| |
| |
| |
| | 100,000
| |
| |
| |
| |-
| |
| | 65
| |
| | 32
| |
| | 1.04
| |
| | 150,000
| |
| | 0.28
| |
| |-
| |
| | 250
| |
| | 125
| |
| | 1.01
| |
| | 200,000
| |
| | 0.21
| |
| |-
| |
| | 1,000
| |
| | 500
| |
| | 1.00
| |
| | 250,000
| |
| | 0.16
| |
| |-
| |
| | ...
| |
| | ...
| |
| |
| |
| | ...
| |
| |
| |
| |-
| |
| | 1,000,000
| |
| | 500,000
| |
| | 1.00
| |
| | 500,000
| |
| | 0.10
| |
| |-
| |
| | 4,000,000
| |
| | 2,000,000
| |
| | 1.00
| |
| | 550,000
| |
| | 0.07
| |
| |-
| |
| | 16,000,000
| |
| | 8,000,000
| |
| | 1.00
| |
| | 600,000
| |
| | 0.06
| |
| |-
| |
| | ...
| |
| | ...
| |
| |
| |
| | ...
| |
| |
| |
| |}
| |
| | |
| It is clearly seen that the first algorithm exhibits a linear order of growth indeed following the power rule. The empirical values for the second one are diminishing rapidly, suggesting it follows another rule of growth and in any case has much lower local orders of growth (and improving further still), empirically, than the first one.
| |
| | |
| === Evaluating run-time complexity ===
| |
| The run-time complexity for the worst-case scenario of a given algorithm can sometimes be evaluated by examining the structure of the algorithm and making some simplifying assumptions. Consider the following [[pseudocode]]:
| |
| | |
| 1 ''get a positive integer from input''
| |
| 2 '''if''' n > 10
| |
| 3 '''print''' "This might take a while..."
| |
| 4 '''for''' i = 1 '''to''' n
| |
| 5 '''for''' j = 1 '''to''' i
| |
| 6 '''print''' i * j
| |
| 7 '''print''' "Done!"
| |
| | |
| A given computer will take a [[DTIME|discrete amount of time]] to execute each of the [[Instruction (computer science)|instructions]] involved with carrying out this algorithm. The specific amount of time to carry out a given instruction will vary depending on which instruction is being executed and which computer is executing it, but on a conventional computer, this amount will be [[Deterministic system (mathematics)|deterministic]].<ref>However, this is not the case with a [[quantum computer]]</ref> Say that the actions carried out in step 1 are considered to consume time T<sub>1</sub>, step 2 uses time T<sub>2</sub>, and so forth.
| |
| | |
| In the algorithm above, steps 1, 2 and 7 will only be run once. For a worst-case evaluation, it should be assumed that step 3 will be run as well. Thus the total amount of time to run steps 1-3 and step 7 is:
| |
| | |
| :<math>T_1 + T_2 + T_3 + T_7. \,</math>
| |
| | |
| The [[program loop|loops]] in steps 4, 5 and 6 are trickier to evaluate. The outer loop test in step 4 will execute ( n + 1 )
| |
| times (note that an extra step is required to terminate the for loop, hence n + 1 and not n executions), which will consume T<sub>4</sub>( n + 1 ) time. The inner loop, on the other hand, is governed by the value of i, which [[iteration|iterates]] from 1 to i. On the first pass through the outer loop, j iterates from 1 to 1: The inner loop makes one pass, so running the inner loop body (step 6) consumes T<sub>6</sub> time, and the inner loop test (step 5) consumes 2T<sub>5</sub> time. During the next pass through the outer loop, j iterates from 1 to 2: the inner loop makes two passes, so running the inner loop body (step 6) consumes 2T<sub>6</sub> time, and the inner loop test (step 5) consumes 3T<sub>5</sub> time.
| |
| | |
| Altogether, the total time required to run the inner loop body can be expressed as an [[arithmetic progression]]:
| |
| | |
| :<math>T_6 + 2T_6 + 3T_6 + \cdots + (n-1) T_6 + n T_6</math>
| |
| | |
| which can be [[factorization|factored]]<ref>It can be proven by [[Mathematical induction|induction]] that <math>1 + 2 + 3 + \cdots + (n-1) + n = \frac{n(n+1)}{2}</math></ref> as
| |
| | |
| :<math>T_6 \left[ 1 + 2 + 3 + \cdots + (n-1) + n \right] = T_6 \left[ \frac{1}{2} (n^2 + n) \right] </math>
| |
| | |
| The total time required to run the outer loop test can be evaluated similarly:
| |
| | |
| :<math>2T_5 + 3T_5 + 4T_5 + \cdots + (n-1) T_5 + n T_5 + (n + 1) T_5</math>
| |
| :<br /><math> = T_5 + 2T_5 + 3T_5 + 4T_5 + \cdots + (n-1)T_5 + nT_5 + (n+1)T_5 - T_5</math>
| |
| | |
| which can be factored as
| |
| | |
| :<math>T_5 \left[ 1+2+3+\cdots + (n-1) + n + (n + 1) \right] - T_5 =\left[ \frac{1}{2} (n^2 + n) \right] T_5 + (n + 1)T_5 - T_5 = T_5 \left[ \frac{1}{2} (n^2 + n) \right] + n T_5 = \left[ \frac{1}{2} (n^2 + 3n) \right] T_5</math>
| |
| | |
| Therefore the total running time for this algorithm is:
| |
| | |
| :<math>f(n) = T_1 + T_2 + T_3 + T_7 + (n + 1)T_4 + \left[ \frac{1}{2} (n^2 + n) \right] T_6 + \left[ \frac{1}{2} (n^2+3n) \right] T_5 </math>
| |
| | |
| which [[reduction (mathematics)|reduces]] to
| |
| | |
| :<math>f(n) = \left[ \frac{1}{2} (n^2 + n) \right] T_6 + \left[ \frac{1}{2} (n^2 + 3n) \right] T_5 + (n + 1)T_4 + T_1 + T_2 + T_3 + T_7
| |
| </math>
| |
| | |
| As a [[rule-of-thumb]], one can assume that the highest-order term in any given function dominates its rate of growth and thus defines its run-time order. In this example, n² is the highest-order term, so one can conclude that f(n) = O(n²). Formally this can be proven as follows:<blockquote>Prove that <math>\left[ \frac{1}{2} (n^2 + n) \right] T_6 + \left[ \frac{1}{2} (n^2 + 3n) \right] T_5 + (n + 1)T_4 + T_1 + T_2 + T_3 + T_7 \le cn^2,\ n \ge n_0</math>
| |
| <br /><br />
| |
| <math>\left[ \frac{1}{2} (n^2 + n) \right] T_6 + \left[ \frac{1}{2} (n^2 + 3n) \right] T_5 + (n + 1)T_4 + T_1 + T_2 + T_3 + T_7</math>
| |
| | |
| <br /><math>\le ( n^2 + n )T_6 + ( n^2 + 3n )T_5 + (n + 1)T_4 + T_1 + T_2 + T_3 + T_7</math> (''for n ≥ 0'')
| |
| | |
| <br /><br />Let k be a constant greater than or equal to [T<sub>1</sub>..T<sub>7</sub>]
| |
| <br /><br /><math>T_6( n^2 + n ) + T_5( n^2 + 3n ) + (n + 1)T_4 + T_1 + T_2 + T_3 + T_7 \le k( n^2 + n ) + k( n^2 + 3n ) + kn + 5k</math> | |
| <br /><math>= 2kn^2 + 5kn + 5k \le 2kn^2 + 5kn^2 + 5kn^2</math> (''for n ≥ 1'') <math>= 12kn^2</math>
| |
| | |
| <br /><br />Therefore <math>\left[ \frac{1}{2} (n^2 + n) \right] T_6 + \left[ \frac{1}{2} (n^2 + 3n) \right] T_5 + (n + 1)T_4 + T_1 + T_2 + T_3 + T_7 \le cn^2, n \ge n_0</math> for <math>c = 12k, n_0 = 1</math></blockquote>
| |
| | |
| A more [[elegance|elegant]] approach to analyzing this algorithm would be to declare that [T<sub>1</sub>..T<sub>7</sub>] are all equal to one unit of time greater than or equal to [T<sub>1</sub>..T<sub>7</sub>].{{Clarify|date=April 2011}} This would mean that the algorithm's running time breaks down as follows:<ref>This approach, unlike the above approach, neglects the constant time consumed by the loop tests which terminate their respective loops, but it is [[Trivial (mathematics)|trivial]] to prove that such omission does not affect the final result</ref><blockquote><math>4+\sum_{i=1}^n i\leq 4+\sum_{i=1}^n n=4+n^2\leq5n^2</math> (''for n ≥ 1'') <math>=O(n^2).</math></blockquote>
| |
| | |
| ===Growth rate analysis of other resources===
| |
| The methodology of run-time analysis can also be utilized for predicting other growth rates, such as consumption of [[DSPACE|memory space]]. As an example, consider the following pseudocode which manages and reallocates memory usage by a program based on the size of a [[computer file|file]] which that program manages:
| |
| | |
| '''while''' (''file still open'')
| |
| '''let''' n = ''size of file''
| |
| '''for''' ''every 100,000 [[kilobyte]]s of increase in file size''
| |
| ''double the amount of memory reserved''
| |
| | |
| In this instance, as the file size n increases, memory will be consumed at an [[exponential growth]] rate, which is order O(2<sup>n</sup>). This is an extremely rapid and most likely unmanageable growth rate for consumption of memory [[Resource (computer science)|resources]].
| |
| | |
| ==Relevance==
| |
| Algorithm analysis is important in practice because the accidental or unintentional use of an inefficient algorithm can significantly impact system performance. In time-sensitive applications, an algorithm taking too long to run can render its results outdated or useless. An inefficient algorithm can also end up requiring an uneconomical amount of computing power or storage in order to run, again rendering it practically useless.
| |
| | |
| ==See also==
| |
| * [[Amortized analysis]]
| |
| | |
| * [[Asymptotic computational complexity]]
| |
| * [[Best, worst and average case]]
| |
| * [[Big O notation]]
| |
| * [[Computational complexity theory]]
| |
| * [[Master theorem]]
| |
| * [[NP-Complete]]
| |
| * [[Numerical analysis]]
| |
| * [[Polynomial time]]
| |
| * [[Program optimization]]
| |
| * [[Profiling (computer programming)]]
| |
| * [[Scalability]]
| |
| * [[Smoothed analysis]]
| |
| * [[Time complexity]] — includes table of orders of growth for common algorithms
| |
| | |
| ==Notes==
| |
| {{reflist}}
| |
| | |
| ==References==
| |
| *{{Cite book |authorlink=Thomas H. Cormen |first=Thomas H. |last=Cormen |authorlink2=Charles E. Leiserson |first2=Charles E. |last2=Leiserson |authorlink3=Ronald L. Rivest |first3=Ronald L. |last3=Rivest |lastauthoramp=yes |authorlink4=Clifford Stein |first4=Clifford |last4=Stein |title=[[Introduction to Algorithms]] |edition=Second |publisher=MIT Press and McGraw-Hill |location=Cambridge, MA |year=2001 |isbn=0-262-03293-7 |others=Chapter 1: Foundations |pages=3–122 }}
| |
| *{{Cite book |title=Algorithms in C, Parts 1-4: Fundamentals, Data Structures, Sorting, Searching |edition=3rd |authorlink=Robert Sedgewick (computer scientist) |first=Robert |last=Sedgewick |location=Reading, MA |publisher=Addison-Wesley Professional |year=1998 |isbn=978-0-201-31452-6 }}
| |
| *{{Cite book |title=[[The Art of Computer Programming]] |authorlink=Donald Knuth |first=Donald |last=Knuth |location= |publisher=Addison-Wesley |isbn= |year= }}
| |
| *{{Cite book |first=Daniel A. |last=Greene |first2=Donald E. |last2=Knuth |title=Mathematics for the Analysis of Algorithms |edition=Second |location= |publisher=Birkhäuser |year=1982 |isbn=3-7643-3102-X }}
| |
| *{{Cite book |authorlink=Oded Goldreich |first=Oded |last=Goldreich |title=Computational Complexity: A Conceptual Perspective |location= |publisher=[[Cambridge University Press]] |year=2010 |isbn=978-0-521-88473-0 }}
| |
| | |
| {{Computer science}}
| |
| | |
| {{DEFAULTSORT:Analysis Of Algorithms}}
| |
| [[Category:Computational complexity theory]]
| |
| [[Category:Analysis of algorithms| ]]
| |