A new sorting algorithm is presented. Its running time is O(n(1+10g(F/n)) where F = I{(f,j); i < j and xi < xj}1 is the total number of inversions in the input sequence xn xn_1 xn_2 ... x2 xl• In other words, presorted sequences are sorted quickly, and completely unsorted sequences are sorted in O(n log n) steps. Note that F < n2/2 always. Furthermore, the constant of proportionality is fairly small and hence the sorting method is competitive with existing methods for not too large n

Mehlhorn, Kurt

Acronym

Sorting Presorted Files Kurt Mehlhorn Fachbereich Informatik Universitat des Saar1andes D-6600 SaarbrUcken August 1978 A 78/12 Abstract: A new sorting algorithm is presented. Its running time is O(n(1+10g(F/n)) where F = I{(f,j); i < j and xi < xj}1 is the total number of inversions in the input sequence xn xn_1 xn_2 ... x2 xl· In other words, presorted sequences are sorted quickly, and completely unsorted sequences are sorted in O(n log n) steps. Note that F < n2/2 always. Further-more, the constant of proportionality is fairly small and hence the sorting method is competitive with existing methods for not too large n. I. Introduction In this paper we consider the problem of sorti ng presorted files. Consider the following two permutations of the numbers 1.2.3 •...• 7: 1 3 2 7 5 4 6 and 761 5 2 4 3 Intuitively speaking. the second permutation is more out of order than the first. A precise notion of this observation is to count the number of inversions; in our example the first permutation has 5 inversions (namely (3.2). (7.5). (7.4), (7.6) and (5.4)) and the second permutation has 15 inversions. In general. let xn xn_l xn_2 ... x3 x2 Xl be a sequence of elements xp from an ordered universe. Define F l{(i,j); Xi < Xj and < j} I as the number of inve rsions in this sequence. Then - 1 -o ~ F ~ n(n-1)/2. (Note that F = n(n-l)/2 if xn > xn_1 > ••• > x2 > Xl)' We take F as a measure for the "sortedness" of sequence xn xn_l ... x2 xl' We will sort sequence xn xn_l ... x2 Xl by an insertion sort. i . e . we s ta rt with the sorted s equence consisting of only element Xl and then insert X2 ·X 3 .. · at their proper places. Let fj I [ i ; x· 1 < Xj and i < j}l Then Lfj = F. Also fj is the number of elements smaller than Xj and to the right of Xj in the input sequence. Hence Xj has to be inserted at the fj-th position during the insertion sort. If the input sequence is presorted, i.e. F is small with respect to n2/2, then fj will tend to be small on the average . Hence most elements will have to be inserted near the front of the sorted sequence. There is a well-known method for inserting an element into a ordered sequence Y1 < Y2 < ... < Ym in time O(log t) where - 2 -t is such that Yt < y < Yt+1. This method was used by Fredman and Bentley & Yao and was termed exponential and binary search in Mehlhorn 77. The basic idea is to compare y with Y2 i for i = 0,1,2, ... until y ~ y . (exponential search) and then to 2' perform a binary search on the interval y . l' ... 'y .. 2'- 2' After having found the proper position by exponential + binary search we will have to insert y at the proper place. Note that it will not do to have numbers Y1' ... Yn is an array. The following data structure supports the search and the insertion proce s s efficiently: A linear list L of AVL-trees To ,T 1 ,T 2 , ... , where Ti has height i. It supports exponential search since Ti has at least 1.6S i leaves. It supports binary search and the insertion process by virtue of AVL-trees. (The actual data structure will be slightly more complicated). In the next section we introduce the data structure,describe the sorting algorithm and prove that its running time is O(n(l + log(F/n))). This is optimal up to a constant factor. Our algorithm solves a special case of a more general problem considered by Guibas et a1 and Brown & Tarjan. They study finger trees which represent linear lists in a way, as to make insertion in the vicinity of certain points (called fingers) efficient. In their terminology we have just one finger which is always directed at the front end of the file. However, our data structure solves this special case more efficient. A sorting method arises which is compatible with existing methods for not too large n. Our data structure has storage requirement 3n vs. 6n for the structure due to Brown & Tarjan. Guibas et al' s data structure is based on B-trees of degree at least 25 and hence seems suitable only for very large n. Also. though their algorithms have the same asymptotic behavior. the constant of proportionality for our algorithm is smaller. II. The Algorithm Our algorithm uses the following data structure: 1) Let L be a linear list Lo .L 1•· ..• Lk • 2) Each Li • 0 < i < k. is a linear list of AVL-trees - 3 -T .• T. 1 •...• T .• with i1. > O. The L1. are called sUblists. 1,0 1, l''\''i 3) T. 1 .0 is an AVL-tree of height i-I. i or i+l and T ..• 1 • J 1 < j < i·. is an AVL-tree - - 1 t = 0 and T has height o 0,0 of height i-lor i. Furthermore o or 1. A sUblist Li is either clean or dirty. If ii = 0 then Li is clean. if i. > 1 then L. is dirty. We use our data structure 1 - 1 to store ordered sets S: 3') Let T be an AVL with m leaves and let S be an ordered set with m elements. We store the elements of S in increasing order from left to right in the leaves of T. In an interior node v of T we store the largest element in the left subtree of the tree with root v. Fig. 1 shows an AVL-tree of height 2 and 3 leaves. The set {7,9.13} is stored in it. Fig. 1: Fact 1 (Adel'son-Vel 'skii + Landis) Let T be an AVL-tree of height h and let m be the number of leaves of T. Then where F1 = F2 numbers. Fh+2 < m < 2h 1 and Fi+2 F' 1 + F . are the Fibonacci , + , Since Fi = (ex i - ~i)/V5 with ex = (1+V5)/ 2 '" 1.618 and 6 = (l-v5) /2 '" -0.618 it follows that and hence - 4 -2') Let li be a sublist, i.e. li is a linear list of AVl-trees T. o,T i 1, ... ,T. R- with R-i > O. let 1" 1, i of tree T .. and let S be a set with , , J We store the mo largest elements of S largest elements in T. 1" .. , and the , , be the number of leaves mj elements. in T . , the , ,0 mL smallest , ne xt m1 elements in T. t . In the sublist l. we store pointers to the roots of 1, i 1 the trees T .. . Along with the pointer to tree T . . we also 1,J 1,J s tore the largest element stored in Tree T .. , denoted max ... 1,J 1,J Fig. 2 shows a list II consisting of 3 trees T1 ,0' T1 ,1' T1 ,2 of height 2,0,1 respectively. We have m1 ,0= 13, m1 ,l = 6 and ml ,2 = 5. Note that we draw the -- - --~ ""------"-tr "-4 6 13 first element of the list at the right end. Also the first element always contains a pointer to the last element. -Fact 2: Let Li be a sublist. Then the total number of leaves of the trees in sublist Li is at least (ai+1_1)/VS Proof: Since tree T. has height at least i-1 this follows 1 ,0 immediately from Fact 1. 1') Let finally L be the linear list Lo ,L 1 ,··.,L k , let ni 5 -be the total number of leaves of trees in sublist Li , 0 < i < k, k and let S be set with n = ~ ni elements. We store the no i=o smallest el ements of S in Lo as described in 2', the next n1 smallest elements in L1 , .... Fig. 3 shows a possible data structure for set {2,5,6,7,9,13,19,21,~}. We draw list L as consisting of the first elements of the sUblists Li . In our example sUblists Lo and L2 are clean and L1 is dirty. 2 co 9 13 Fig. 3 We use our data structure to do an insertion sort. Let xn xn_l xn_2 ... x2 xl Xo be an unordered list of reals (to be specific). We assume that Xo = co, i.e. Xo is at least as large as all other elements in the list. This assumption will allow us to eliminate some special cases and is quite customary in sorting. We start with our data structure for the singleton set { xo}' i.e. L consists of sublist Lo only, La consists of - 6 -one tree of height 0 and the only leaf of that tree contains xo. Next we insert x l ,x 2 ,x 3 ' • .• into the structure. Suppose we inserted xl' ... ,x p_l and obtained structure L. We want to insert xp next. First we locate the sublist Li in which xp is to be inserted. i -<- 0 whil e do i -<- i+l Remember that max i •o is the largest element of tree T i.o and hence the largest element stored in sublist i. Suppose L consists of sublists Lo .L 1 •...• Lk . Then max k • o ~ = and hence the while-loop terminates although we have not included a test for end of list. Let h be the final value of variable i. Then x < max h and either h ~ 0 or p - ,0 In our example we would have h ~ 1 if we try to insert 12 and we would have h ~ 2 if we try to insert 35. - 7 -Definition: Let fp:~ ICq;q<p and Xq < x } I p be the number of inversions caused by element xp' to the right of xp yet smaller than f is the number of elements p xp' From now on. log fp always denotes leg max(2.f p)' Lemma 1: Let h be defined as above. Then Proof: If h ~ 0 then we have nothing to show. Suppose h > O. Then xp > max h_1 •0 ' Furthermore. sublist Lh_1 contains at least tree Th- 1 •0 which h has height at least h-2 and hence at least Fh ~ (a -1)/V5 leaves. These leaves contain elements Xq with q < p and Xq < xp' Hence fp > (a h-1)IVS . At this point we have located sublist Lh and we want to insert xp into one of the trees Th • j • 0 ~ j ~ tho on sublist Lh . We distinguish whether Lh is clean or dirty. Case 1: Lh is clean. i.e. ~ ~ O. We insert x into AVL-tree p Th •o using the standard insertion algorithm for AVL-trees. Tree T has height h-1. h or h+1. After the insertion Th has h , 0 ,0 c height h-1, h, h+1, h+2. If its height is ~ h+1 then we are done and proceed to insert xp+1' If its height is h+2, then let T' and T" be its left and right subtree and let v be its root. Trees T' and T" have height h or h+1, not necessarily the same. We let T' be the new Th and append ,0 T" at the end of sublist Lh+1 . If Lh+1 did not exist,then we also have to create Lh+1 . Note also that the maximal element in T' is stored in v and that the maximal element in T" is the old max h . Hence we are able to maintain our ,0 data structure. - 8 -Lemma 2: O(log fp) time units suffice to insert xp into Th,o and to update the data structure. Proof: Tree Th,o has height at most h+l. Hence h+1 (by Lemma 1) time units suffice. Case 2: Lh is dirty. We will first clean Lh by pairing the trees in it and moving some of the resulting tree to Lh+1 . Let Lh consist of trees Th,o' Th ,l'" .,Th,t h with th > 1. Remember that Th,O has < j < t h , have T h ., 1 ,J height h-1, h or h+1 and that trees height h-1 or h. if height of Th is h+1 ,0 then delete Th,o from Lh and append Th,o to the end of Lh+1; co all trees on Lh have height h-1 or h. while Lh contains> 3 trees do begin delete the first two trees T' and T" from Lh; combine them into a new AVL-tree of height h or h+1; append T to the end of list Lh+1 - 9 -co Lh now contains either one or two trees; if Lh contains two trees T' and T" then combine T' and T" into a single tree T , delete T' and from Lh and make T the only tree of list Lh; At this pOint Lh is clean, but Lh+1 may be dirty. Now we try again whether xp has to be inserted into Lh, i.e. we execute xp > max h ,0 proceed as and try to clean Lh+1 again. If in case 1. insert x P first, ... it has to Otherwise into L h+l . be we If inserted into Lh then we increase i by 1 to h+1 Lh+l is dirty, then we Cleaning Lh means to move at most one tree unchanged from Lh and Lh+l and to pair off the remaining trees. Since at least one tree is moved unchanged or at least one pair is formed, the time required to clean Lh is proportional to the number of trees moved unchanged (at most one) plus the number of pairs formed. We will use this fact when analysing the total time complexity of all cleaning processes. This ends the description of the algorithm. Example: Fig. 5 shows the effect of inserting 12 into the structure of Fig. 3. We first determine h = 1. Ll is dirty. Hence Ll is cleaned and the structure in 5a is obtained. Next we find out that i has to be increased to h+l. L2 is dirty and we clean L2 . The structure in 5b is obtained. Now i stays stable and L2 is clean. Hence we insert 12 into T2 ,0 and obtain 5c. T" - 10 -)----4<.6 ~--------------------~ ~ 5a 2 )---~ 6 }-_____ -< 13 )-___ -< co 2 5 19 21 5b 2 6 >-------{ 13>-----< 9 5 - 11 -It remains to estimate the running time of the algorithm. Suppose we us ed the algorithm to sort x ,x 1"" , x1 ' x . n n - 0 Let S be the total time spent on cleaning and let T be the total time spent outside the cleaning processes. n Note that T = L O(log f ) if we never try to insert into a p= 1 P dirty sublist. Suppose now that at some point we try to insert into a dirty sublist Lh . Then Lh is cleaned first. The cost of cleaning i s allotted to S. Then we find out at the cost of 0(1) whether we still have to insert into Lh . If we don't have to then we try to insert into Lh+1 . Hence 0(1) time units are charged to T for looking at Lh in thi s case. Hence for the computation of T we may as well assume that we only insert n into clean lists and thus T = L 0 ( log f ). p=1 P Lemma 3: T O(n(1 + 10g(F/n))) where F Proof: By the discussion above n T L O(log fp) p=l n O(n) + o ( L log fp) p=l i o ( n) + o ( log n f.) i=l , = O(n) + O(n log(F/n)) n L f p=l P s ince ( nf . ) 1/ n < (Lf.) / n , - , (the geometric mean is never larger than the arithmetic mean). The quantity S is more difficult to estimate. In order to do so we construct a forest:Y in parallel to the execution D - 12 -of the algorithm. There wi 11 be one interior node in ~ for every tree moved unchanged and for every pair formed in the cleaning processes. Hence the number of interior nodes of Y will provide us with a bound for S. Initially ~ consists of one leaf which represents the only tree T in our structure. 0 , 0 a) The leave s of 3:': The leaves of '31 will be constructed after inserting new element s into our data structure. Suppose we insert element xp into clean list Lh , i . e. we insert x p AVL-tree Th,o . After the insertion Th,o is either split into or not . all Th,o is not split . Then we create one new leaf which re-presents the tree Th,o on list Lh after the insertion took place . a2) Th,o is split into T' and T". T' stays on list Lh and T" i s mo ved to list Lh+l . We construct two new leaves of forest ~ representing trees T' on list Lh and T" on list Lh+l respectively. Since at most two leaves are constructed after inserting an element into our data structure, forest ::p has at most 2n+l leaves. b) The interior nodes of Y: The interior nodes are constructed by the cleaning process. Suppose we clean list Lh. Then tree Th,o may be moved unchanged to list Lh+1 . If this is the case then we construct one new node with a single son. This new node repre sent s tree Th,o on list Lh+l . Its single son is the node which represented tree Th,o on list Lh. Also pairs of tree of Lh are formed . For every pair formed we con s truct a new node with two sons. The new node represents the newly formed tree on whatever list it is on (either Lh or Lh+1) and its two sons are the two nodes which represent the two con s tituent trees on list Lh · From the construction of forest Yis it apparent that at every-point during the execution of our algortthm every tree in the data structure will be represented by a node of (p. Interior nodes of Y have ei ther one or two sons. - 13 -Lemma 4: Let v be a node of ~ having exactly one son w. Then w is either a leaf or has two sons. Proof: Assume otherwise. Then w has a single son x. x re-presents some tree T on some list Lh. Hence T has height < h+1. Node w represents the same tree on list Lh+l' Hence w represents a tree of height ~ h+1 on list Lh+1 . Such a tree is never moved unchanged during the cleaning. Hence there can be no node having w as its only son. Contradiction. Forest F has at most 2n+1 leaves. Hence it has at most 2n nodes with two sons and hence at most 4n+l nodes with one s on. This shows that at most Bn+2 trees are handled during the whole of the cleaning processes. Hence S = O(n). We thus proved: Theorem: Let xn xn_1",x 1 be an unordered sequence and let F = [{(i,j); i > j and xi> xj }[ be the total number of inversions in that sequence. Then our algorithm sorts the sequence in 0(n(1 + 10g(F/n))) time units. c Guibas et al have shown that the logarithm of the number of permutations of {1,2, ... ,n} with at least F inversions is n(n(log(l+F/n)). Hence our algorithm is optimal up to a constant factor. This is also true for the algorithms due to Guibas et al and Brown & Tarjan. However, our constant of proportionality is smaller. A first analysis shows that the running time is about 24n 10g(F/n) + 40n on the machine defined in Mehlhorn 77. Comparing this with the running time of Quicksort which is about gn log n on the average on that machine shows that D if if 24n 10g(F/n} + 40n ~ 9n log n 10g(240/24'F/n} < (9/24) log n F < 1/2(40/24}n33/ 24 "" O.314n1.375 and hence the algorithm is competitive with Quicksort for F < O.314n1.375. - 14 -Guibas et al base their data structure on B-trees (Bayer & McCreight) of order (degree of branching) at least 25. Hence it seems unsuitable for small or moderate size n. Brown & Tarjan base their data structure on 2-3 trees. The storage requirement of their structure is 6n. Our data structure requires only 4n storage, a 3n implementation is possible. An obvious implementation of AVL-trees is to use 3 storage cells per node and one storage cell per leaf. This makes 4m-3 storage cells for an AVL-tree with m leaves. In addition, we need for each AVL-tree an element in sublist Li which pOints to it. Again three storage cells are required for such an element. Finally, we need two additional storage cells for each sublist L.: a pointer to L. 1 and a pointer to the last 1 1 + element in Li . Altogether, 4n+O(10g n} storage cells suffice. Also our algorithm is more time efficient than theirs. This is due to the fact that it uses AVL-trees instead of 2-3 trees and that list L above can be kept in any array. III. Conclusion We presented a new sorting algorithm. Several variations of the general theme are po ss ible. 1) Usage of s ome other kind of balanced trees in stead of AVL-trees, e.g. B-t rees [Bayer -McCreight). 2) List L starts with sUbli s t Ls ' s > 1, instead of Lo. This might remove some overhead. - 15 -3) It is conceiv able to use the same datastructure recursively to organize list L. After all, list L has length log nand inserting element xp corresponds to finding the (log fp)-th position in this list . 4) Usage of random trees in s tead of balan ced trees. This might result in a s orting algorithm with fast average running time. 5) We chose to delay cleaning list Li+l after it became dirty by a split of Ti,o. It would be possible to clean list Li+l (a nd Li +2 , Li +3 , .. . as necessary) immediately after that split. The same analysis and time bound applies. It requires more study which solutio n is more efficient with respect to time and s pace requirements. - 16 -Bibliography Adelson-Velskii-Landis: "An algorithm for the organization of information", Soviet. Math. Dokl,3,1259-1262, 1962 Aho, Kopcroft & Ullman: "The Destgn and Analysis of Computer Algorithms·, Addison Wesley, 1974 Bayer & McCreight: "Organization and Maintenance of Large Ordered Indizes", Acta Informatica, 1 (1972), 173-189 Bentley & Yao: "An almost Optimal Algorithm for Unbounded Searching", Information Processing Letters, Vol. 5, No.3, p. 82-87, August 1976 Brown & Tarjan: "A Representation for Linear Lists with Movable Fingers", 10th ACM Symposium on Theory Of Computing, p. 19-29, 1978 Fredman, M.L.: "Two applications of a Probabl1istic Search Technique: Sorting X + Y and Building Balanced Search Trees", 7th ACM Symposium on Theory of Computing, 1975 240-244 Guibas, Creight, Plass, Roberts: "A new representation for linear lists, 9th ACM Symposium on Theory of Computing, 1977, 49-60 Mehlhorn, K.: "Effiziente Algorithmen", Teubner StudienbUcher Informatik, Stuttgart 1977 

Sorting presorted files

Universaar

https://publikationen.sulb.uni-saarland.de/bitstream/20.500.11880/26142/1/fb14_1978_12.pdf

Sorting presorted files

Abstract

Similar works

Full text

Available Versions

Acronym

Universaar