add
int
 notations.txt |
what is omega notation? theta notation? big-O?
asymptotic ALGORITHMIC run-time classes
=======================================
the important algorithmic analyses is the asymptotic one
*O notation*
|
overview.txt |
START HERE START HERE MAIN INDEX PAGE START HERE
algorithms notes overview
|
permutations.txt |
add
from probablity class, we know that for a set of n distinct objects, there are n! permutations.
example: 4! = 4 * 3 * 2 * 1 = 24 different combinations
if we want an algorithms which does *lexicographic ordering* the first letter/number is greater than (the previous choice for that slot) and less than (the next choice for that slot). Once the first slot is filled like that, do permutations of the rest of numbers in the set. This will lead to (in the example of n! it will lead to 4 groups of 6 permutations each; the groups will start with 1 the second group will start with 2, the third with 3 and the fourth with 4.
An analysis of the above is like the statistics problems where they state that you don't put the choice back into the set once it's taken out, and here, we take out the first entry; that leaves us with 3*2*1 combinations of the remaining entries, hence it's 4 * 6 (the six is (once again) the number of permutations in each of the four sets.
|
profiling.txt |
add
GENERAL
=======
profiling: a technique which shows where the bottlenecks are
option y axis #1: the time
|
recursives.txt |
add
recursive and non-recursive distinction
=======================================
non-recursive algorithms use summations to find the equation, then solve the equation and use the asymptomatic notations. Not all algorithms lead themselves to recursive solutions!
"as we shall see throughout this book, a great many algorithms are based on the principle of recursively decomposing a large problem into recursively smaller ones...." Those are the "recursive relations" which need to be mathematically analyzed to determine the general or precise solution to categorizing the runtime of the algorithm. Remember, the general method of algorithmic analysis is to write the algorithm in pseudo-code (before actualization of it in a living language) and then sum up the important time considerations (number of comparisons, number of swaps...), then to mathematically solve the resulting equation. Some of these algorithms are reductive. there are a few ways to solve recurrences, meaning, "solve" means "what is the asymptotic run-time class of this algorithm?". For example: solve by the method of forward substitutions, the method of backward substitutions (very often works :), and finally, by using the master theorem, and finally solving via induction.
|
transformations.txt |
add
algorithms notes overview
| --->upload your article
|
User submitted category site links |
|
(None) |
-->submit a page from your site dealing with algorithms to the sirfsup! web directory for listing | |
algorithms_c