There is a simple shortcut to understanding the performance of searching and sorting algorithms, if that is what you're looking for.
First, sorting is basically repeated search. For each of N items, you are searching for where to insert it in the list, and then inserting it, so it takes N times the big-O of the search procedure.
To understand big-O of search, a simple way is to think of it as a series of decisions (usually binary) with a certain probability of taking each branch.
Suppose your table has N = 1024 entries. That means it takes 10 bits to index the table, because log(1024) = 10 (base 2). Searching is a process of learning those 10 bits.
If a decision point has roughly equal probability of going either way, then it has an entropy of -0.5 log(0.5) - 0.5 log(0.5) (base 2) which is 1 bit, so it learns 1 bit of information on each decision. Voila! It takes roughly 10 decisions, or log(N). So the sorting is O(N log(N)). All the NlogN sorting algorithms are based on binary decisions having roughly equally likely outcomes.
Suppose you are doing linear search (as in bubble sort). On the first decision, the chance of being right is 1/1024 vs 1023/1024. The entropy is 1/1024 * log(1024/1) + 1023/1024 * log(1024/1023) or roughly 10/1024 + 0 (i.e. about .01). So on the first decision you only learn about .01 bit because the outcomes are so skewed. That is why linear search is inefficient. It takes on the order of N operations, so sorting takes O(N*N).
(Aside: linear search is actually exponential. If you define the information content of a problem as n = log(N), then linear search takes O(2^n) steps. That's why things like unguided game-tree search are exponential in number of moves.)
On the other hand, suppose rather than making binary decisions, you are indexing. You take some or all of the bits of the word that you're looking for, and use them as an index into an array, where you've pre-stored answers. If that indexing operation has 1024 equally likely outcomes, then it learns 10 bits, so it only takes roughly 1 operation to get the answer. That is the basic idea behind hash coding. If your hash function happens to perserve order, it can be used to make an O(N) sorting algorithm.
There are fancy ways to analyze algorithms, and maybe that's what you need, but looking at them as learning bits of information serves 99% of my needs.
