Doubly-linked List Research Articles

The design of the C mobile earth station simulator based on C language

The communication equipment software of the Global Maritime Distress and Safety System is based on DOS platform, and the equipment operation simulator used for training and assessment is generally developed by VC, VB and FLASH technology. There are a lot of difference between the simulator and the real machine on the interface and the operating response. The operation of the simulator is done with mouse, while the operation of the real machine must be done with the keyboard only on board ships. The Inmarsat-C mobile earth station simulator has being developed by C language. The simulator terminal operating interface and response is identical with the real machine operation because the developing language of the simulator is the same as the real machine. Because the adoption of the doubly-linked list data structure, program structure is clear and code is simplified.

Juggrnaut: using graph grammars for abstracting unbounded heap structures

This paper presents a novel abstraction framework for heap data structures. It employs graph grammars, more precisely context-free hyperedge replacement grammars. We will show that this is a very natural formalism for modelling dynamic data structures in an intuitive way. Our approach aims at extending finite-state verification techniques to handle pointer-manipulating programs operating on complex dynamic data structures that are potentially unbounded in their size. The theoretical foundations of our approach and its correctness are the main focus of this paper. In addition, we present a prototypical tool entitled Juggrnaut that realizes our approach and show encouraging experimental verification results for three case studies: a doubly-linked list reversal, the flattening of binary trees, and the Deutsch---Schorr---Waite tree traversal algorithm.

Average-case linear-time similar substring searching by the q-gram distance

In this paper we consider the problem of similar substring searching in the q-gram distance. The q-gram distance dq(x,y) is a similarity measure between two strings x and y defined by the number of different q-grams between them. The distance can be used instead of the edit distance due to its lower computation cost, O(|x|+|y|) vs. O(|x||y|), and its good approximation for the edit distance. However, if this distance is applied to the problem of finding all similar strings, in a long text t, to a given pattern p, the total computation cost is sometimes not acceptable. Ukkonen already proposed two fast algorithms: one with an array and the other with a tree. When “similar” means k or less in dq, their time complexities are O(|t|k+|p|) and O(|t|logk+|p|), respectively. In this paper, we propose two algorithms of average-case complexity O(|t|+|p|), although their worst-case complexities are still O(|t|k+|p|) and O(|t|logk+|p|), respectively. The linearity of the average-case complexity is analyzed under the assumption of random sampling of t and the condition that q is larger than a threshold. The algorithms exploit the fact that similar substrings in t are often found at very close positions if the beginning positions of the substrings are close. In the second proposed algorithm, we adopted a doubly-linked list supported by an array and a search tree to search for a list element in O(logk) time. Experimental results support their theoretical average-case complexities.

The Formal Design Models of Digraph Architectures and Behaviors

Graphs are one of the most fundamental and widely used non-linear hierarchical structures of linked nodes. Problems in sciences and engineering can be formulated and solved by the graph model. This paper develops a comprehensive design pattern of formal digraphs using the Doubly-Linked List (DLL) architecture. The most complicated form of graphs known as the weighted digraph is selected as a general graph model, based on it simple graphs such as nondirected and/or nonweighted ones can be easily derived and tailored. A rigorous denotational mathematics, Real-Time Process Algebra (RTPA), is adopted, which allows both architectural and behavioral models of digraphs to be rigorously designed and implemented in a top-down approach. The architectural models of digraphs are created using RTPA architectural modeling methodologies known as the Unified Data Models (UDMs). The physical model of digraphs is implemented using nodes of DLL dynamically created in the memory. The behavioral models of digraphs are specified and refined by a set of 18 Unified Process Models (UPMs) in three categories namely the management operations, traversal operations, and node manipulation operations. This work has been applied in a number of real-time and nonreal-time system designs and specifications such as a Real-Time Operating System (RTOS+), graph-based and tree-based applications, and the ADT library for an RTPA-based automatic code generation tool.

Efficient data structures for Time Warp simulation queues

Abstract Optimistic simulation is besides the conservative methods the most promising approach to distributed discrete-event simulation (DDEVS). In the optimistic Time Warp strategy, every sub-simulator has to handle in addition to its main event queue (input queue) two other queues, holding information about sent messages and past states, respectively. We present efficient data structures and algorithms for the three queue types in Time Warp simulation. It shows that for two queue types the simple doubly linked list (DLL) approach suffices, for the input queue however, significant speed-up can be achieved by enhancing a data structure originally developed for sequential simulation. We show an improvement from an O(n) to an O(1) average case behavior for some operations by moving from the DLL to the new data structure without increasing the average case and worst case order of the other operations. Empirical results show that the new data structure yields substantial faster operation for enqueuing items into the list, which — regardless of the overhead introduced by the new data structure to the other queue operations — results in queue access acceleration for typical Time Warp simulations even for medium input queue sizes of about 100. For large queue sizes of about 10000 the new data structure yields more than 15 times faster overall queue operation performance.

Self-Organizing Doubly-Linked Lists

In this paper, we study the problem of maintaining a doubly-linked list (DLL) in approximately optimal order, with respect to the mean search time. We study two types of DLL reorganization strategies. Move-To-End (MTE) [12] and SWAP [14] are two memoryless DLL heuristics obtained from natural extensions of the well-known singly-linked-list (SLL) heuristics, move-to-front and transposition, respectively. We first derive a general sufficient condition which permits comparison of any two DLL heuristics. We use this condition as a guideline to identify families of access distributions for which SWAP yields a lower expected cost than the MTE. We have also presented an absorbing DLL heuristic. The strategy requires one additional memory location and is analogous to the scheme presented in [15]. The reorganization is achieved by moving each element exactly once to its final position in the reorganized list. The scheme is stochastically absorbing and it is shown to be optimal for a restricted family of distributions. Thus, for these distributions, the probability of the scheme converging to the optimal list order can be made as close to unity as desired.

A Short Note on Doubly-Linked List Reorganizing Heuristics

The class of memoryless heuristics for maintaining a Doubly-Linked List in an approximately optimal order is studied. Two mappings that relate Singly-Linked List and Doubly-Linked List heuristics are defined, and theorems involving these mappings are presented. A new heuristic referred to as the Swap heuristic for the Doubly-Linked List is introduced, and its asymptotic distribution has been derived