There is a lot of detail available on-line. If you google "Dictionary
of Algorithms and Data Structures", and visit there, you'll be amazed
at the depth of the info.

A good book (not too hard, but something that covers the basics), is a
great asset to have. Perhaps someone here can recommend a good one, not
too technical, for a beginner.

What you want to avoid is the "black box" idea, in which you give the
program input, and await the answer, and nothing more.

Because all too often, the computer will be made to do a fantastic
amount of extra work, simply because the program it's running, isn't
smartly designed.

Two algorithms that always fascinate me, are binary search, and
Quicksort. I can remember playing the kid's game "guess a number
between 1 and 10", and here's the algorithm that copied a smart kid's
idea for guessing a number, but now it's so much faster, in the
computer! And so powerful.

I'd start with working through the binary search of a sorted array (or
list), and be sure you understand every aspect of it. Not only because
it's a beautiful algo and still heavily used today, but also because
it's basic strategy of "divide and conquer", repeating as needed, is
used in all kinds of algorithms. It is a very common theme in effective
algorithms.

Then, I'd look at Quicksort, and really dig into it. It's another
"divide and conquer" algo, but it uses the stack for each recursive
call (by all means, study the recursive Quicksort), to remember and
restore the values it needs for it's pointers. To understand the power
of recursion in a simple program, d/l a copy of "The Towers of Hanoi".

A keen appreciation of scale is needed here, alway.. ANY sorting algo
will readily handle a list of 50 items, in almost no time. But when the
number of items has scaled up to 500,000 or 500 million, it's a WHOLE
different matter, isn't it?  :-)

Indeed, you may not see or appreciate the value of a binary search or
quicksort algorithm on a small number of items. It's when you scale it
up into the 100's of thousands or more, that the true power of them
smack you right upside your "aha!" point in your brain.

Sudoku puzzles are another example where a good algorithm is keenly
noticed. A good program will solve most puzzles in less than a second
or two, depending on the amount of output they give to the screen and
file.

A poor algo may cause the same computer system to requires several
minutes or even hours of computation, to solve the very same puzzle.
These programs typically ignore the logical inferences that would
reduce the number of possible solutions, and work to solve the puzzle
by more "brute force" methods. When you have a puzzle with 99 squares,
and 50 of those squares may have unknown values (1-9),  well, what is
50 ^ 9th power?  Breaks my calculator, for sure!

Good luck, and have fun!

Adak


--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Algorithm Geeks" group.
To post to this group, send email to algogeeks@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at http://groups.google.com/group/algogeeks
-~----------~----~----~----~------~----~------~--~---

Reply via email to