Data Structure Visualization Research Articles

Integrating Multiple Approaches for Interacting with Dynamic Data Structure Visualizations

jGRASP 1.8.7 has integrated three approaches for interacting with its dynamic viewers for data structures: the debugger, the workbench, and a new text-based interactions tab that allows individual Java statements to be executed and expressions to be evaluated. While each of these approaches is distinct and can be used independently of the others, they can also be used together to provide a complementary set of interactions with the dynamic viewers. In order to integrate these approaches, the jGRASP visual debugger, workbench, and viewers had to be significantly redesigned. During this process, the structure identifier, which provides for the identification and rendering of common data structures, was also greatly improved by examining the examples from 20 data structure textbooks. The overall result of this integration effort is a highly flexible approach for user interaction with the dynamic data structure visualizations generated by a robust structure identifier.

Visualization of Spatial Data Structures on Different Levels of Abstraction

Spatial data structures are used to manipulate location data. The visualization of such structures faces many challenges that are not relevant in the visualization of one-dimensional data. The visualized data can be represented using several different types of visual metaphors. These metaphors can be divided into several different levels of abstraction depending on the purpose of the visualization. This paper proposes a division of data structure visualization into four levels of abstraction, and shows how these abstractions can be taken into account in the visualization of spatial data structures.

A Framework for Generating AV Content on-the-fly

Many computer science educators agree that the visualization or animation of dynamic systems, especially algorithms and data structures, should help students in learning about this central aspect of computer science. However, most educators do not use algorithm visualization and animation (AV) systems in their teaching. One central reason for this is the time needed to find or generate “appropriate” content [Naps, T. L., G. Rößling, V. Almstrum, W. Dann, R. Fleischer, C. Hundhausen, A. Korhonen, L. Malmi, M. McNally, S. Rodger and J. A. Velázquez-Iturbide, Exploring the Role of Visualization and Engagement in Computer Science Education, ACM SIGCSE Bulletin 35 (2003), pp. 131–152]. This paper tries to remedy this by illustrating an easy to use and yet flexible framework for generating content on-the-fly - but tailored to the end user's preferences.

Fully integrating algorithm visualization into a cs2 course.

We describe a two-year experience of fully integrating algorithm visualization technology into a CS2 course on data structures and algorithms. Our integration methodology was based on the engagement taxonomy proposed by the working group on Improving the Educational Impact of Algorithm Visualization : in particular, we used five forms of engagement of this taxonomy, that is, the no-viewing, the viewing, the changing, the constructing and the presenting forms. The integration of algorithm visualization technology into the course culminated in the writing of a textbook on the design, analysis and visualization of data structures and algorithms, whose reading is strictly dependent on the use of an algorithm visualization tool, called Alvie, which has been developed by the authors.

Data structure visualization with latex and prefuse

We report two ways with which data structures as well as their algorithmic operations can be visualized. The first method uses LaTeX to automatically generate diagrammatic presentation material from extended versions of the Java implementations of well-known ADTs. The second method uses the Prefuse API to explore objects created in running Java programs.

Dynamic object viewers for data structures

The jGRASP lightweight IDE has been extended to provide object viewers that automatically generate dynamic, state-based visualizations of data structures in Java. These viewers provide multiple synchronized visualizations of data structures as the user steps through the source code in either debug or workbench mode. This tight integration in a lightweight IDE provides a unique and promising environment for learning data structures. Initial classroom use has demonstrated the object viewers' potential as an aid to students who are learning to write and modify classes representing data structures. Recently completed controlled experiments with CS2 students indicate that these viewers can have a significant positive impact on student performance.

Observations on student misconceptions—A case study of the Build – Heap Algorithm

Data structures and algorithms are core issues in computer programming. However, learning them is challenging for most students and many of them have various types of misconceptions on how algorithms work. In this study, we discuss the problem of identifying misconceptions on the principles of how algorithms work. Our context is algorithm simulation exercises, where students simulate the steps of a given algorithm by manipulating data structure visualizations on a computer screen by using a mouse. Thus, contrasting to “typical” data structures and algorithms courses, these exercises are designed to work on an abstraction level higher than that of the actual implementation. We have analyzed the recorded simulation sequences to infer existing misconceptions from students' answers, and then implemented the corresponding variations of the target algorithm to find out how many of students' answers consistently follow each variation. The results suggest that many students are aware of the ultimate goal of the algorithm but have not studied the algorithm itself well enough. This often leads to different misconceptions that can be modeled and recognized using our approach. The results presented here concern the Build – Heap algorithm, but the approach is of general value.

3D Visualization on mobile devices

This paper discusses current status and recent advancements of 3D graphics on mobile platforms and describes open issues concerning its usage in different applications. We have treated two particular application fields. Firstly, we deal with problems of visualization of complex data structures on mobile devices. The implementation of a 3D visualization renderer on the Symbian platform for mobile devices is written as a C++ application and based on the DieselEngine® as a rendering engine. 3D visualization of data is generated in the form of a Virtual Reality Modelling Language (VRML) file meaning that actually any kind of 3D content written in VRML file format can be rendered on such a device. It was the result of a project the objective of which was to provide a user interface on a mobile platform displaying visualization of hierarchical Grid monitoring data. Secondly, we describe the system that brings face animation to embedded platforms. Face animation is considered to be one of the toughest tasks in computer animation today and its delivery to mobile platforms brings possibilities for development of new innovative and attractive services for the mobile market.

Visual Algorithm Simulation Exercise System with Automatic Assessment: TRAKLA2

Interaction and feedback are key factors supporting the learning process. Therefore many automatic assessment and feedback systems have been developed for computer science courses during the past decade. In this paper we present a new framework, TRAKLA2, for building interactive algorithm simulation exercises. Exercises constructed in TRAKLA2 are viewed as learning objects in which students manipulate conceptual visualizations of data structures in order to simulate the working of given algorithms. The framework supports randomized input values for the assignments, as well as automatic feedback and grading of students' simulation sequences. Moreover, it supports automatic generation of model solutions as algorithm animations and the logging of statistical data about the interaction process resulting as students solve exercises. The system has been used in two universities in Finland for several courses involving over 1000 students. Student response has been very positive.

An extensible framework for providing dynamic data structure visualizations in a lightweight IDE

A framework for producing dynamic data structure visualizations within the context of a lightweight IDE is described. Multiple synchronized visualizations of a data structure can be created with minimal coding through the use of an external viewer model. The framework supplies a customizable viewer template as well as high-level APIs to a graph drawing library and the Java Debugger Interface. Initial classroom use has demonstrated the framework's ease of use as well as its potential to as an aid to student learning.

External memory management and simplification of huge meshes

Very large triangle meshes, i.e., meshes composed of millions of faces, are becoming common in many applications. Obviously, processing, rendering, transmission, and archiving of these meshes are not simple tasks. Mesh simplification and LOD management are a rather mature technology that, in many cases, can efficiently manage complex data. But, only a few available systems can manage meshes characterized by a huge size: RAM size is often a severe bottleneck. In this paper, we present a data structure called Octree-based External Memory Mesh (OEMM). It supports external memory management of complex meshes, loading dynamically in main memory only the selected sections and preserving data consistency during local updates. The functionalities implemented on this data structure (simplification, detail preservation, mesh editing, visualization, and inspection) can be applied to huge triangles meshes on low-cost PC platforms. The time overhead due to the external memory management is affordable. Results of the test of our system on complex meshes are presented.

Language-independent interactive data visualization

We introduce the Language-Independent Visualization Environment (LIVE) as a system for the visualization and manipulation of data structures and the computer programs that create and operate on them.LIVE interprets arbitrary programs containing arbitrary data structure definitions, showing diagrammatically the data that the process generates.It is language-independent in that a single program can be visualized in the syntax of multiple languages. LIVE is interactive in that not only does it show the effects of statements immediately as they occur at runtime, but it also generates new program source code automatically when the user manipulates the data on the screen. We anticipate that this tool will be most useful in a pedagogical setting such as a CS2 or data structures course, particularly with the introduction of pointers and linked structures.

ViSOM - a novel method for multivariate data projection and structure visualization

When used for visualization of high-dimensional data, the self-organizing map (SOM) requires a coloring scheme, such as the U-matrix, to mark the distances between neurons. Even so, the structures of the data clusters may not be apparent and their shapes are often distorted. In this paper, a visualization-induced SOM (ViSOM) is proposed to overcome these shortcomings. The algorithm constrains and regularizes the inter-neuron distance with a parameter that controls the resolution of the map. The mapping preserves the inter-point distances of the input data on the map as well as the topology. It produces a graded mesh in the data space such that the distances between mapped data points on the map resemble those in the original space, like in the Sammon mapping. However, unlike the Sammon mapping, the ViSOM can accommodate both training data and new arrivals and is much simpler in computational complexity. Several experimental results and comparisons with other methods are presented.

Assessing the benefits of interactive prediction using Web-based algorithm animation courseware

This study used educational software—courseware—that contained algorithm animations and data structure visualizations that were implemented with the programming language Java, and were embedded in a collection of World Wide Web pages. The objective of this study was to determine whether the interactive prediction facility provided by this courseware produced a significant learning advantage. Two experiments were conducted. The results indicated that the students who used the interactive version of the courseware spent significantly more time using it than those who used the noninteractive version. Students who used the interactive version scored better on several of the questions that tested the more difficult lessons, but performed more poorly overall. None of the differences were statistically significant.

Testers and visualizers for teaching data structures

We present two tools to support the teaching of data structures and algorithms: Visualizers , which provide interactive visualizations of user-written data structures, and Testers , which check the functionality of user-written data structures. We outline a prototype implementation of visualizers and testers for data structures written in Java, and report on classroom use of testers and visualizers in an introductory Data Structures and Algorithms (CS2) course.

HPFIT: A set of integrated tools for the parallelization of applications using High Performance Fortran. Part II: Data-structure visualization and HPF extensions for irregular problems

The HPFIT project has the aim to provide a set of interactive tools integrated in a single environment to help users to parallelize scientific applications to be run on distributed memory parallel computers. In this paper about the HPFIT project we present a data structure visualization tool called Visit, and HPF extensions for irregular problems.

Using the Swan data structure visualization system for computer science education

Using the Swan data structure visualization system for computer science education

Visualization of Distributed Data Structures for High Performance Fortran‐Like Languages

This article motivates the usage of graphics and visualization for efficient utilization of High Performance Fortran′s (HPF′s) data distribution facilities. It proposes a graphical toolkit consisting of exploratory and estimation tools which allow the programmer to navigate through complex distributions and to obtain graphical ratings with respect to load distribution and communication. The toolkit has been implemented in a mapping design and visualization tool which is coupled with a compilation system for the HPF predecessor Vienna Fortran. Since this language covers a superset of HPF′s facilities, the tool may also be used for visualization of HPF data structures.

Comparing and Evaluating Layout Algorithms within GraphEd

Graph drawing and layout algorithms are gaining growing interest and importance for the visualization of complex data structures. But, despite many algorithms and concepts, there is no satisfactory solution to the central problem of the criteria for good and readable layouts. We approach this problem and evaluate layout algorithms by comparing their effect on a large set of sample graphs. In each run we compute statistical data which is collected and evaluated. Our experiments show that traditional layout criteria, such as minimal area or maximal edge length or straight line edges, are not as important as they may appear. Balance is often better than optimization, and displaying the intended and inherited structure of a graph is often more important than these formal cost criteria.

An iconic description language: programming support for data structure visualization

An icon description language, named DSIL (Data Structure Iconic Language), is described which facilitates the design of icons depicting data structures and accelerates the development of iconic interfacing tools for program visualization and debugging. By using the DSIL, different users can define or redefine their own icons to satisfy their needs. The DSIL has features of modern programming languages. It is hierarchical, modular, and provides adoption (inheritance). The design of the DSIL is based on the features of data structures in MODULA-2. The implementation of the DSIL in a data structure editor is presented.