#abstract data types

Notes on Abstract Data Types In Java

Introduction:

Everything in computer is stored in only two states 0 and 1. Its Binary number system used by computers. Have you even thought about why we human use decimal number system ? I would tell you answer of that at end of this blog.

Everything means everything is in binary, your display, movies, songs, images everything is stored in binary. Now How does computer understand what is what if…

Topics

Abstract Data Types - the abstract set of data types

Agnostic to programming language

ADTs can be made using several specific data structures, as long as they retain the same functionality/have the same public API

Set - collection of objects such that each object either exists or does not exist in the set (all are unique, no duplicates)

include - add to set

query - check if in set

remove - from set

Map

set - value from key (must check whether key already exists)

get - value from key

delete - by key

HashMap - most common way of implementing a Map

Stack

LIFO - Last In, First Out (considered unfair)

Similar to cafeteria trays

push/pop || shift/unshift - push/pop most common

Queue

FILO - First In, First Out (considered fair)

dequeueing - take object away from front of queue

enqueue -- add object ot end of queue

Similar to line at the register

push/shift || pop/unshift

Trees

Parent-child relationships where each child has at most 1 parent

Trees have directionality

Root/Base - single node with no children

Empty tree is still a tree!

Binary - max 2 children per node

Ternary - max 3 children per node

Unary - max 1 child per node (also called a Linked List)

Polytree / N-ary Tree - a tree with no guarantee of its number of children

Subtrees often named/referenced by root

Tree Traversal & Tree Searching Algorithms

Depth First Search (BFS) - use a Stack, recursion

Breadth First Search (DFS) - use a Queue, iterative

Very useful for predicting the outcome of a game/set of steps

Projects

PolyTreeNode class - a class for defining an uncapped number of children for a given node

@parent, @children, @value

@parent= - set new parent and update new & old parent as well as child's instance variables

add_child(child_node)

remove_child(child)

dfs(target_value) - Depth First tree searching algorithm to find a given child node

bfs(target_value) - Breadth First tree searching algorithm to find a given child node

Knight's Travails - find all the possible positions a knight can get to from a given starting position on a chess board. Find the shortest path to get from one tile to another.

Tic-Tac-Toe AI - Build an AI that can predict all possible winning/losing moves in a polytree, so that it always to chooses a move that will not allow it to lose. It's unbeatable!

Learnings

Traversing Trees is cool!!

Although technically Depth First Search visits & checks all of the leaves before the upper branches, it is more efficient to check a given node when you first reach it. So developers generally check a parent before all its children, even on its way down to the roots.

attr_accessor / attr_reader - make a setter & getter method for instance variables that have the same name as the instance variable.

public vs private

public methods are available to all objects of all classes

private methods - available only to objects of the same class

private instance variable methods -- vailable only to the object itself (cannot be called by different objects of the same class

class methods

defined as self.method_name

called as ClassName.method_name

Ampersand & in &prc is used to convert in both directions:

Block --> Proc

Proc --> Block

Generally used as method_name(&prc)

Exception Handling

begin

regular body of code

rescue OneTypeOfException

What to do for this exception

rescue AnotherTypeOfException

What to do for this type of exception

else

What to do for all all other exceptions

ensure

Will always be executed

end

Data Structures

Data structures are ways of organizing information in a programming language. They include things like Arrays, Hashmaps or Strings.

Abstract Data Types

Abstract Data Types (ADTs) are conceptual ways of organizing information. Data Structures implement ADTs. As their name suggests, ADTs are more abstract than Data Structures. Examples of ADTs includes a map, a stack or a queue. It doesn’t matter how you implement an ADT, as long as you follow the application program interface (or API) of the ADT, it will work. How you implement an ADT will affect performance, but not functionality. Map (Or Dictionary)

A map is an ADT that organizes data into key value pairs. It needs to be able to find the value associated with a key, assign a value to a key, or delete a key. When assigning a key a map must check if the key already exists and assign a new value to the existing key if it does before adding a new key. This API is essential for a map to work properly, but it’s not essential that a map be implemented using a Hashmap for it to work properly.

Later I’ll talk more about why a Hashmap implements a map so very well.

Set

A set is a group of distinct values. It’s an example of a different ADT that you could implement with a Hashmap. The essential thing about a Set is that it doesn’t have any duplicates. If you create a Hashmap where they keys all point to true, that will implement a set, because when you add a key that’s already in the Set, you won’t wind up adding a duplicate (you’ll just set it to true again).

Queue

A queue is most efficiently implemented by an Array. For a Queue to function properly, items must only be added to one end of the the Array, and removed/read from the other end of the Array, which can be used by restricting yourself to either #push and #shift or #deshift and #pop. This is also called First In First Out or FIFO.

Stack

A stack is sort of the inverse of a Queue. The rule with a stack is Last In First Out or LIFO. A stack could also be implemented using an Array by restricting yourself to only #push and #pop. A stack could also be implemented with recursion by taking advantage of the implicit call stack. Recursive methods are really just algorithms that use a stack, and could be implemented recursively or with a manual stack.

Trees

A tree is a group of data points, called nodes, that are organized into parent-child relationships. A node with no parents, is called the root. A node with no children is called a leaf. A node can have at most one parent, or the data structure isn’t a tree.

There are different types of trees with different limits on how many children a node can have.

Binary: A node can have at most two children.

Ternary: A node can have at most three children.

N-Ary or Poly: A node can have an unlimited number of children

Unary: A node can have at most one child. This is also (and more descriptively) referred to as a linked list.

Trees are very powerful ADTs, if somewhat complex. A Tree is a good way of implementing an AI for example. A tree is the ADT I had to use to write the word-chain program.

A Tree structure that you interact with all the time is your directory. All of the folders on your computer are organized in a PolyTree structure. A folder can contain any number of folders. But, a single folder can’t be contained within more than one other folder. That’s a tree.

Algorithms

An algorithm is a layer more abstract than an ADT. An Algorithm requires certain ADTs to work, and can’t be implemented without specific ADTs. It still doesn’t matter what Data Structure you use to implement the ADT that implements an Algorithm, but you can’t implement an Algorithm without the right ADT.

Breadth First Search (BFS)

BFS is a way of traversing a Tree in which you start at the root and move through the tree one layer at a time. A BFS is implemented using a queue.

Depth First Search (DFS)

Tom Stuart demystifies monads masterfully in this talk/post.

I remember reading this in October and promising myself I'd share this any time I found myself in a situation where the topic of monads was brought up in hushed tones.

Last night at a software craftsmanship meetup I finally found myself in that exact situation and instinctively recommended this. I just watched the actual talk for the first time today and still think it's the clearest treatment of a concept of which every programmer should be aware and of which no programmer should be afraid.

Next up are maps.  Conceptually, you can think of Maps kind of like a dictionary, not to be confused with a Dictionary ADT (Abstract Data Type).  With a dictionary, you have the word you want to lookup, the ‘key’, and you have the definition, the ‘value’.  Unlike a dictionary, in a Map, each key, or word, has to be unique.  You have a word, and you go to the starting letter and then meticulously search through that letter for your word.  A map data structure works exactly the same way.

    Like a dictionary, a map is divided into sections, buckets.  Whatever you add to a map, it is inserted into a bucket.  Which bucket?  Well, that’s what the hash is for.  Every key is passed through hashing method, or function.  IE.  A mathematical operation which returns a value.  This value is then used to enter the key-value pair into the corresponding bucket.

      Sounds neat, right? Well, sorta. First, maps are really good for looking stuff up. Since they use hashes, looking for a key is pretty fast. Theoretically, it could take O(n) but usually not. How, you ask? Imagine if all the objects you want to enter wind up in the same bucket. Then you would have to search thru that bucket in a linear fashion, which we know takes O(n).

  Use the example in the image as a reference.  There are 6 objects.  When you create a map and start adding elements, each element’s key is hashed.  This hash is then used to determine which bucket to enter the object into.  Thus, insertion is O(1) since, once we have the hash, it’s a simple matter of assigning it to a bucket.

  Searching is just as simple.  When searching for a key, that same hashing function is used and the appropriate bucket where the object is.

Data Types

After much deliberation, I decided to call this project The Datatypes Project: Abstract Assembly. I had many other titles in mind. What I really wanted to treat, in an aesthetic manner, were data structures. I could have called it Abstract Data Types or just The Data Project. I ended up with Datatypes and threw in the notion of assembly, abstract assembly, to indicate that the project is about abstractions and building abstract objects, treated in an artistic fashion in the case at hand.

This project is part of a much bigger project whose current working title is "20 Years of Data". Many projects over the last 20 years have culminated in this "grand vision", which is at once a work of autobiography, of self-portraiture, one could say it is a work of sousveillance, of the contemporary artist meeting the archivist meeting the "Quantified Self". It is the artist telling his story through a form of abstract, phenomenological, historiographic, autobiographical "data journalism".

It is a work of self-narration, of the artist telling himself the story of his own becoming as an artist. I have chosen to narrate the story of my development as an artist through data, through my personal archives, which is where the number "20" comes from, for I have been meticulously and rigorously keeping personal archives at least for the past 20 years.

[ENTER THE ARCHIVES]: The History-Project, circa 2001-2006

Autobiographical notes from the archives outlining the concept(s) behind the original History-Painting, circa 2001:

07/27/01 3:53:11 PM L. bought me a canvas, a Masonite board, a 6x8, I think, and I need to find out what to paint on it. To do this I need to find out what’s been on my mind lately. Well, I’ve been reading a lot. I read ‘Formal and Transcendental Logic’ by Edmund Husserl, so I have a bit of formal ontology fresh in my mind. Added to that is a book I just finished called ‘Art History’s History’ by Vernon Hyde Minor, published in 1994. That took me through all the ages of art history, and should be useful for a painting. I want there to be perspective, proportion. What are important icons in art history? How can I paint art history onto a canvas? I could stick with an abstraction and just give it tons of depths, fields, planes, all of the above. I want perhaps to stick to white and black, just make a Borduas-like historical painting. I could throw in some green and yellow or red. What would be the appropriate colors to use? What are the present colors in my consciousness? [colors present] The incipience of forms. Forms moving onto the plane of formal existence. The birth of art history. I have to think about this. 07/27/01 5:21:26 PM Concerning the painting, so far I have a white background in acrylic. Form, painting. There’s something to be said right there, regarding forms and the art of painting. What exists between me and the painting? What do me and the painting possibly make together? What forms can I project onto the canvas from my unconscious or from my imagination? I’d like to paint a rhetorical figure, irony or something, maybe I’ll finally paint my first allegory.  07/27/01 8:17:19 PM I decided to paint an allegory of history in red, yellow, and black squares floating over a disjointed white surface. Each square is a construction, or a discursive formation of sorts. The concept isn’t all figured out yet. But the painting, well, it’s pretty much finished, although I only worked 20 minutes on it. I’ll let it dry and work some more on it next week. The concept I will work on till then and maybe I can do a series of works and call it all ‘The Allegory of History’. It’s the allegory of history because I’m calling it history, and it’s an allegory because the discursive formations are separate and floating in empty space, or in a gridlock. Another allegory of history could be the portrait of a man, but a man who is all broken up. In history we have synchronies and diachronies. Each can be painted. A synchrony in painting is translated as a mosaic. That’s what I tried to make, but each piece of the mosaic is just an abstraction; I could have made them portraits, and at heart I wanted to make copies of famous paintings and call it the allegory of art history. That I’ll do on a bigger canvas. I’ll really concentrate on the space between the squares or rectangles.

That was the first painting in a series of paintings that went on for several years, collectively called The History-Project. It included over 1000 pages of text, hundreds of images, and entire concept-albums full of original music. Yet at the heart of it all was the desire to paint the concept of History.

The project itself was a failure in the sense that I did not attain the objective, though I was prolific in my production of unique works of art. I in fact created an interconnected network of art objects, indelibly linked to my own day-to-day experience, my personal history, and of course, my archives.

That project, at least in part, has led to this: The reduction of an entire field of possible abstractions to a finite number of precise, discrete structures and types. It is through the lens of these types and structures, through the data I have accumulated over the course of decades, that I tell the same story, only differently this time. I like to think that I have added a new layer of method to the madness.

Definitions

abstract data type: A set of data values and associated operations that are precisely specified independent of any particular implementation.

data structure: An organization of information, usually in memory, for better algorithm efficiency, such as queue, stack, linked list, heap, dictionary, and tree, or conceptual unity, such as the name and address of a person. It may include redundant information, such as length of the list or number of nodes in a subtree.

via NIST - Dictionary of Algorithms and Data Structures