Animal Home Page

Searching algorithms deal with finding a given element in a set of elements. Typically, the data structure that stores the elements is a list or an array. Due to the available indexing and direct navigation to the i-th element, array structures can support more efficient searching algorithms.

The following searching algorithms are currently covered in the repository:

• Straight Searching
• Binary Search
• Interpolated Searching

Algorithms are (almost) all sorts of instructions for solving a given (concrete or generic) problem that are sufficiently clear that a computer could understand them. A large part of Computer Science deals with algorithms in some way or other.

In the animation repository, we regard a set of different algorithms, depending on the topic covered:

• Searching
• String Searching
• Sorting
• Graph Algorithms
• Compression
• Cryptography
• Optimization

Welcome to the Animal Animation Repository!

This repository provides a quick overview of the currently hosted algorithm and data structure animations available for the Animal algorithm animation system.

Please note that there are far more animations actually available than can be shown here - simply due to the fact that each run of one of the built-in generators will create a new (and possibly unique) animation. The entries in this repository are mainly meant to illustrate the uses possible for Animal to "whet your appetite".

Graphs are a very important data structure for many Computer Science algorithms. They generalize the tree data structure (you may also regard trees as a special case of graphs).

In this animation, the structure and representation of directed graphs is presented as well as the possibility to change a non-directed graph into a directed one.

Finally, the following central terms are explained:

• path - any sequence of edges which have the same direction

This animation introduces the data structure Binary Tree.

First, the structure of a binary tree is shown and the terms (inner) node, root, leaf, level, path, path length are defined.

Following that, the possibilities of traversing a binary tree are presented:

• Pre-Order: the root of the subtree is processed first, before going into the left and then the right subtree.
• In-Order: After the complete processing of the left subtree, the root is processed, followed by the processing of the complete right subtree.

Trees are among the most important data structures in Computer Science. A tree has a base element (called root). Each element in the tree is either an (inner) node with successors, or a leaf (a node without successors). Each element also stores a value, which can be simply or a complex element.

Queues are a data structure that reflect the "first in, first out" principle of an (orderly) queue in front of a ticket office or at a bus stop.

Queues offer the following operations:

• void enqueue(v) adds the element v at the end of the queue
• v dequeue() removes and returns the first element or "head" of the queue
• v front() returns the first element of the queue without taking it out of the queue
• boolean empty() checks if the queue is empty and returns either true or false

Lists are an easy common data structure used in Computer Science. A list can contain an arbitrary number of elements, can shrink or grow at runtime, and offers linear iteration over the elements. Typically, each list element has a value and at least a pointer to the next list element (unless the element is the last list element, in which case the pointer will be null).

Variants of the lists, such as the doubly linked list, have more than one pointer, e.g. to the preceding element or to the element that is n positions further "down" the list.

The repository hosts a number of animations that focus on presenting the typical behavior of common data structures used in a Computer Science context.

The data structures currently covered are:

• Linked Lists (singly linked list, doubly linked list),
• Stacks
• Queues
• Trees (binary tree, B+ tree)
• Graphs