Thuật toán Algorithms (Phần 23)
lượt xem 4
download
Thuật toán Algorithms (Phần 23)
Tham khảo tài liệu 'thuật toán algorithms (phần 23)', khoa học tự nhiên, toán học phục vụ nhu cầu học tập, nghiên cứu và làm việc hiệu quả
Bình luận(0) Đăng nhập để gửi bình luận!
Nội dung Text: Thuật toán Algorithms (Phần 23)
 17. Radix Searching Several searching methods proceed by examining the search keys one bit at a time (rather than using full comparisons between keys at each step). These methods, called radix searching methods, work with the bits of the keys themselves, as opposed to the transformed version of the keys used in hashing. As with radix sorting methods, these methods can be useful when the bits of the search keys are easily accessible and the values of the search keys are well distributed. The principal advantages of radix searching methods are that they provide reasonable worstcase performance without the complication of balanced trees; they provide an easy way to handle variablelength keys; some allow some sav ings in space by storing part of the key within the search structure; and they can provide very fast access to data, competitive with both binary search trees and hashing. The disadvantages are that biased data can lead to degenerate trees with bad performance (and data comprised of characters is biased) and that some of the methods can make very inefficient use of space. Also, as with radix sorting, these methods are designed to take advantage of particular characteristics of the computer’s architecture: since they use digital properties of the keys, it’s difficult or impossible to do efficient implementations in lan guages such as Pascal. We’ll examine a series of methods, each one correcting a problem inherent in the previous one, culminating in an important method which is quite useful for searching applications where very long keys are involved. In addition, we’ll see the analogue to the “lineartime sort” of Chapter 10, a “constanttime” search which is based on the same principle. Digital Search Trees The simplest radix search method is digital tree searching: the algorithm is precisely the same as that for binary tree searching, except that rather than 213
 214 CHAPTER 17 branching in the tree based on the result of the comparison between the keys, we branch according to the key’s bits. At the first level the leading bit is used, at the second level the second leading bit, and so on until an external node is encountered. The code for this is virtually the same as the code for binary tree search. The only difference is that the key comparisons are replaced by calls on the bits function that we used in radix sorting. (Recall from Chapter 10 that bits(x, k, j) is the j bits which appear k from the right and can be efficiently implemented in machine language by shifting right k bits then setting to 0 all but the rightmost j bits.) function digitalsearch(v: integer; x: link) : link; var b: integer; begin zf.key:=v; b:=maxb; repeat if bits(v, b, I)=0 then x:=x1.1 else x:=xt.r; b:=b1; until v=xt .key; digitalsearch:=x end ; The data structures for this program are the same as those that we used for elementary binary search trees. The constant maxb is the number of bits in the keys to be sorted. The program assumes that the first bit in each key (the (maxb+l)st from the right) is 0 (perhaps the key is the result of a call to bits with a third argument of maxb), so that searching is done by setting x:= digitalsearch(v, head), where head is a link to a tree header node with 0 key and a left link pointing to the search tree. Thus the initialization procedure for this program is the same as for binary tree search, except that we begin with headf.l:=z instead of headt.r:=z. We saw in Chapter 10 that equal keys are anathema in radix sorting; the same is true in radix searching, not in this particular algorithm, but in the ones that we’ll be examining later. Thus we’ll assume in this chapter that all the keys to appear in the data structure are distinct: if necessary, a linked list could be maintained for each key value of the records whose keys have that value. As in previous chapters, we’ll assume that the ith letter of the alphabet is represented by the fivebit binary representation of i. That is, we’ll use the following sample keys in this chapter:
 RADLX SEARCHING 215 A 00001 S 10011 E 00101 R 10010 C 00011 H 01000 I 01001 N 01110 G 00111 X 11000 M 01101 P 10000 L 01100 To be consistent with hits, we consider the bits to be numbered O4, from right to left. Thus bit 0 is A’s only nonzero bit and bit 4 is P’s only nonzero bit. The insert procedure for digital search trees also derives directly from the corresponding procedure for binary search trees: function digitaJinsert(v: integer; x: link): link; var f: link; b: integer; begin b:=maxb; repeat f:=x; if bits(v, b, I)=0 then x:=xt.J else x:=xf.r; b:=bf ; until x=z; n e w ( x ) ; xf.key:=v; xf.J:=z; xt.r:=z; if bits(v, b+l, I)=0 then Q.‘.l:=x else ff.r:=x; digitalinsert: =x end ; To see how the algorithm works, consider what happens when a new key Z= 11010 is added to the tree below. We go right twice because the leading two bits of Z are 1, then we go left, where we hit the external node at the left of X, where Z would be inserted.
 216 CRAPTER 17 The worst case for trees built with digital searching will be much better than for binary search trees. The length of the longest path in a digital search tree is the length of the longest match in the leading bits between any two keys in the tree, and this is likely to be relatively short. And it is obvious that no path will ever be any longer than the number of bits in the keys: for example, a digital search tree built from eightcharacter keys with, say, six bits per character will have no path longer than 48, even if there are hundreds of thousands of keys. For random keys, digital search trees are nearly perfectly balanced (the height is about 1gN). Thus, they provide an attractive alternative to standard binary search trees, provided that bit extraction can be done as easily as key comparison (which is not really the case in Pascal). Radix Search Tries It is quite often the case that search keys are very long, perhaps consisting of twenty characters or more. In such a situation, the cost of comparing a search key for equality with a key from the data structure can be a dominant cost which cannot be neglected. Digital tree searching uses such a comparison at each tree node: in this section we’ll see that it is possible to get by with only one comparison per search in most cases. The idea is to not store keys in tree nodes at all, but rather to put all the keys in external nodes of the tree. That is, instead of using a for external nodes of the structure, we put nodes which contain the search keys. Thus, we have two types of nodes: internal nodes, which just contain links to other nodes, and external nodes, which contain keys and no links. (E. Fredkin
 RADlX SEARCHING 217 named this method “trie” because it is useful for retrieval; in conversation it’s usually pronounced “tryee” or just “try” for obvious reasons.) To search for a key in such a structure, we just branch according to its bits, as above, but we don’t compare it to anything until we get to an external node. Each key in the tree is stored in an external node on the path described by the leading bit pattern of the key and each search key winds up at one external node, so one full key comparison completes the search. After an unsuccessful search, we can insert the key sought by replacing the external node which terminated the search by an imternal node which will have the key sought and the key which terminated the search in external nodes below it. Unfortunately, if these keys agree in more bit positions, it is necessary to add some external nodes which do not correspond to any keys in the tree (or put another way, some internal nodes which have an empty external node as a son). The following is the (binary) radix search trie for our sample keys: Now inserting Z=llOlO into this tree involves replacing X with a new internal node whose left son is another new internal node whose sons are X and Z. The implementation of this method in Pascal is actually relatively com plicated because of the necessity to maintain two types of nodes, both of which could be pointed to by links in internal nodes. This is an example of an algorithm for which a lowlevel implementation might be simpler than a highlevel implementation. We’ll omit the code for this because we’ll see an improvement below which avoids this problem. The left subtree of a binary radix search trie has all the keys which have 0 for the leading bit; the right subtree has all the keys which have 1 for the
 218 CHAPTER 17 leading bit. This leads to an immediate correspondence with radix sorting: binary trie searching partitions the file in exactly the same way as radix exchange sorting. (Compare the trie above with the partitioning diagram we examined for radix exchange sorting, after noting that the keys are slightly different.) This correspondence is analogous to that between binary tree searching and Quicksort. An annoying feature of radix tries is the “oneway” branching required for keys with a large number of bits in common, For example, keys which differ only in the last bit require a path whose length is equal to the key length, no matter how many keys there are in the tree. The number of internal nodes can be somewhat larger than the number of keys. The height of such trees is still limited by the number of bits in the keys, but we would like to consider the possibility of processing records with very long keys (say 1000 bits or more) which perhaps have some uniformity, as might occur in character encoded data. One way to shorten the paths in the trees is to use many more than two links per node (though this exacerbates the “space” problem of using too many nodes); another way is to “collapse” paths containing oneway branches into single links. We’ll discuss these methods in the next two sections. Multiway Radix Searching For radix sorting, we found that we could get a significant improvement in speed by considering more than one bit at a time. The same is true for radix searching: by examining m bits at a time, we can speed up the search by a factor of 2m. However, there’s a catch which makes it necessary to be more careful applying this idea than was necessary for radix sorting. The problem is that considering m bits at a time corresponds to using tree nodes with M = 2m links, which can lead to a considerable amount of wasted space for unused links. For example, if M = 4 the following tree is formed for our sample keys: H I L M R S
 RADLX SEARCHTNG Note that there is some wasted space in this tree because of the large number of unused external links. As M gets larger, this effect gets worse: it turns out that the number of links used is about MN/In M for random keys. On the other hand this provides a very efficient searching method: the running time is about log, N. A reasonable compromise can be struck between the time efficiency of multiway tries and the space efficiency of other methods by using a “hybrid” method with a large value of M at the top (say the first two levels) and a small value of M (or some elementary method) at the bottom. Again, efficient implementations of such methods can be quite complicated because of multiple node types. For example, a twolevel 32way tree will divide the keys into 1024 cate gories, each accessible in two steps down the tree. This would be quite useful for files of thousands of keys, because there are likely to be (only) a few keys per category. On the other hand, a smaller M would be appropriate for files of hundreds of keys, because otherwise most categories would be empty and too much space would be wasted, and a larger M would be appropriate for files with millions of keys, because otherwise most categories would have too many keys and too much time would be wasted. It is amusing to note that “hybrid” searching corresponds quite closely to the way humans search for things, for example, names in a telephone book. The first step is a multiway decision (“Let’s see, it starts with ‘A”‘), followed perhaps by some two way decisions (“It’s before ‘Andrews’, but after ‘Aitken”‘) followed by sequential search (“ ‘Algonquin’ . . . ‘Algren’ . . . No, ‘Algorithms’ isn’t listed!“). Of course computers are likely to be somewhat better than humans at multiway search, so two levels are appropriate. Also, 26way branching (with even more levels) is a quite reasonable alternative to consider for keys which are composed simply of letters (for example, in a dictionary). In the next chapter, we’ll see a systematic way to adapt the structure to take advantage of multiway radix searching for arbitrary file sizes. Patricia The radix trie searching method as outlined above has two annoying flaws: there is “oneway branching” which leads to the creation of extra nodes in the tree, and there are two different types of nodes in the tree, which complicates the code somewhat (especially the insertion code). D. R. Morrison discovered a way to avoid both of these problems in a method which he named Patricia (“Practical Algorithm To Retrieve Information Coded In Alphanumeric”). The algorithm given below is not in precisely the same form as presented by Morrison, because he was interested in “string searching” applications of the type that we’ll see in Chapter 19. In the present context, Patricia allows
 220 CHAPTER 17 searching for N arbitrarily long keys in a tree with just N nodes, but requires only one full key comparison per search. Oneway branching is avoided by a simple device: each node contains the index of the bit to be tested to decide which path to take out of that node. External nodes are avoided by replacing links to external nodes with links that point upwards in the tree, back to our normal type of tree node with a key and two links. But in Patricia, the keys in the nodes are not used on the way down the tree to control the search; they are merely stored there for reference when the bottom of the tree is reached. To see how Patrica works, we’ll first look at the search algorithm operating on a typical tree, then we’ll examine how the tree is constructed in the first place. For our example keys, the following Patricia tree is constructed when the keys are successively inserted. To search in this tree, we start at the root and proceed down the tree, using the bit index in each node to tell us which bit to examine in the search key, going right if that bit is 1, left if it is 0. The keys in the nodes are not examined at all on the way down the tree. Eventually, an upwards link is encountered: each upward link points to the unique key in the tree that has the bits that would cause a search to take that link. For example, S is the only key in the tree that matches the bit pattern 10x11. Thus if the key at the node pointed to by the first upward link encountered is equal to the search key, then the search is successful, otherwise it is unsuccessful. For tries, all searches terminate at external nodes, whereupon one full key comparison is done to determine whether the search was successful or not; for Patricia all searches terminate at upwards links, whereupon one full key comparison is done to determine whether the search was successful or not. Futhermore, it’s easy to test whether a link points up, because the bit indices in the nodes (by
 RADLX SEARCHING 221 definition) decrease as we travel down the tree. This leads to the following search code for Patricia, which is as simple as the code for radix tree or trie searching: type link=fnode; node=record key, info, b: integer; 1, r: link end; var head: link; function patriciasearch(v: integer; x: link): link; var f: link; begin repeat f:=x; if bits(v, xf.b, I)=0 then x:=xf.l else x:=xf.r; until f‘r.b
 222 CHAPTER 17 external node containing X with a new internal node with X and Z as sons in radix trie insertion, with oneway branching eliminated by including the bit index. The insertion of T=lOlOO illustrates a more complicated case. The search for T ends at P=lOOOO, indicating that P is the only key in the tree with the pattern 10x0x. Now, T and P differ at bit 2, a position that was skipped during the search. The requirement that the bit indices decrease as we go down the tree dictates that T be inserted between X and P, with an upward self pointer corresponding to its own bit 2. Note carefully that the fact that bit 2 was skipped before the insertion of T implies that P and R have the same bit 2 value. The examples above illustrate the only two cases that arise in insertion for Patricia. The following implementation gives the details: function patriciainsert(v: integer; x: link): link; var t,f: link; i: integer; begin t :=patriciasearch (v, x) ; i:=maxb; while bits(v, i, I)=bits(tt.key, i, 1) do i:=iI; repeat f:=x; if bits(v, xf.b, I)=0 theu x:=xf.l else x:=xt.r; until (xT.b
CÓ THỂ BẠN MUỐN DOWNLOAD

Thuật toán Algorithms (Phần 1)
10 p  69  18

Thuật toán Algorithms (Phần 16)
10 p  59  15

Thuật toán Algorithms (Phần 2)
10 p  48  10

Thuật toán Algorithms (Phần 8)
10 p  55  9

Thuật toán Algorithms (Phần 11)
10 p  57  9

Thuật toán Algorithms (Phần 3)
10 p  59  8

Thuật toán Algorithms (Phần 12)
10 p  49  8

Thuật toán Algorithms (Phần 4)
10 p  48  7

Thuật toán Algorithms (Phần 13)
10 p  50  7

Thuật toán Algorithms (Phần 6)
10 p  57  7

Thuật toán Algorithms (Phần 10)
10 p  46  6

Thuật toán Algorithms (Phần 9)
10 p  51  6

Thuật toán Algorithms (Phần 7)
10 p  42  6

Thuật toán Algorithms (Phần 5)
10 p  55  6

Thuật toán Algorithms (Phần 14)
10 p  31  5

Thuật toán Algorithms (Phần 15)
10 p  36  4

Thuật toán Algorithms (Phần 17)
10 p  32  4