Amount Of Extra Space Research Articles

Inplace 2D matching in compressed images

The compressed matching problem is the problem of finding all occurrences of a pattern in a compressed text. In this paper we discuss the 2-dimensional compressed matching problem in Lempel–Ziv compressed images. Given a pattern P of (uncompressed) size m× m, and a text T of (uncompressed) size n× n, both in 2D-LZ compressed form, our algorithm finds all occurrences of P in T. The algorithm is strongly inplace, that is, the amount of extra space used is proportional to the best possible compression of a pattern of size m 2. The best compression that the 2D-LZ technique can obtain for a file of size m 2 is O( m). The time for performing the search is O( n 2) and the preprocessing time is O( m 3). Our algorithm is general in the sense that it can be used for any 2D compression which can be sequentially decompressed in small space.

Inplace run-length 2d compressed search

The recent explosion in the amount of stored data has necessitated the storage and transmission of data in compressed form. The need to quickly access this data has given rise to a new paradigm in searching, that of compressed matching (Proc. Data Compression Conf., Snow Bird, UT, 1992, pp. 279–288; Proc. 8th Annu. Symp. on Combinatorial Pattern Matching (CPM 97), Lecture Notes in Computer Science, Vol. 1264, Springer, Berlin, 1997, pp. 40–51; Proc. 7th Annu. Symp. on Combinatorial Pattern Matching (CPM 96), Lecture Notes in Computer Science, Vol. 1075, Springer, Berlin, 1996, pp. 39–49). The goal of the compressed pattern matching problem is to find a pattern in a text without decompressing the text.The criterion of extra space is very relevant to compressed searching. An algorithm is called inplace if the amount of extra space used is proportional to the input size of the pattern. In this paper we present a 2d compressed matching algorithm that is inplace. Let compressed(T) and compressed(P) denote the compressed text and pattern, respectively. The algorithm presented in this paper runs in time O(|compressed(T)|+|P|logσ) where σ is min(|P|,|Σ|), and Σ is the alphabet, for all patterns that have no trivial rows (rows consisting of a single repeating symbol). The amount of space used is O(|compressed(P)|). The compression used is the 2d run-length compression, used in FAX transmission.

Let Sleeping Files Lie: Pattern Matching in Z-Compressed Files

The current explosion of stored information necessitates a new model of pattern matching, that ofcompressed matching. In this model one tries to find all occurrences of a pattern in a compressed text in time proportional to the compressed text size,i.e., without decompressing the text. The most effective general purpose compression algorithms areadaptive, in that the text represented by each compression symbol is determined dynamically by the data. As a result, the encoding of a substring depends on its location. Thus the same substring may “look different” every time it appears in the compressed text. In this paper we consider pattern matching without decompression in the UNIX Z-compression. This is a variant of the Lempel–Ziv adaptive compression scheme. Ifnis the length of thecompressedtext andmis the length of the pattern, our algorithms find the first pattern occurrence in timeO(n+m2) orO(nlogm+m). We also introduce a new criterion to measure compressed matching algorithms, that ofextra space. We show how to modify our algorithms to achieve a trade-off between the amount of extra space used and the algorithm's time complexity.

RELAXED INORDER HEAPS

In this paper, we introduce a new variant of implicit heaps, called relaxed inorder heaps. The structure is semi-implicit due to the use of 1 extra bit per node to maintain heap order and the allowance of some systematically controlled extra space. We show that relaxed inorder heaps are asymptotically more efficient than other known variants of implicit heaps. In particular, relaxed inorder heaps are especially efficient for heap merging and splitting operations, which are known to be problematic operations for implicit heaps. Using amortized analysis, we derive several improved time bounds. Heap creation can be done in O(n) comparisons and node movements. Finding the minimum node and node insertion can each be done in O(1) comparisons and node movements. Key updating and node deletion can each be done in O(log n) comparisons and node movements. As for merging, we show that O(1) comparisons and 2k+O(1) node movements are sufficient for merging two heaps of sizes n and k. For splitting, we show that O(log n) comparisons and 1.5k+O(log n) node movements are sufficient for splitting an n-node implicit heap into two heaps of sizes k and n−k. The amount of extra space in a relaxed inorder heap is O(log n) if splitting does not occur, and O(n) otherwise. The significance of our results is that small sophistication in the structure of implicit heaps can produce large improvements in efficiency. We have implemented the algorithms for operations on relaxed inorder heaps. The simulation results strongly indicate that relaxed inorder heaps are practical, since the constant factors recorded for the heap operations are all very small.

Splitsort—an adaptive sorting algorithm

We present a new sorting algorithm, called Splitsort, which adapts to existing order within the input sequence. The algorithm is optimal with respect to several known measures of presortedness, including the number of inversions, for which no such simple and space efficient algorithm was known before. The amount of extra space needed is only n pointers. Splitsort uses a simple data structure and is easy to code. In the worst case Splitsort performs 2.5 nlog 2 n comparisons, but if the input is presorted according to some of the measures it completes the sorting task considerably faster. We also show how a variant of the algorithm can be implemented to run in-place.