ALGORITM VISUALIZER

PROJECT SYNOPSIS

OF MAJOR PROJECT

BACHELOR OF TECHNOLOGY

Computer Science

SUBMITTED BY

Prabhjot Singh

2002559

448/2, Sector 45-A, Chandigarh

prabhjotsinghrainu@gmail.com

7056952556

DEPARTMENT OF COMPUTER SCIENCE AND

ENGINEERING
Chandigarh Engineering College – Landran
Mohali, Punjab - 140307
March 2022
Introduction:

Data structure and algorithm visualizations and animations (hereafter referred to

generically as algorithm visualizations) have a long history in computer science
education. While the 1981 video “Sorting out Sorting” by Ronald Permission to make
digital or hard copies of all or part of this work for personal or classroom use is granted
without fee provided that copies are not made or distributed for profit or commercial
advantage and that copies bear this notice and the full citation on the first page. To copy
otherwise, to republish, to post on servers or to redistribute to lists, requires prior
specific permission and/or a fee.

Baeker was the first well-known visualization, ad hoc visualizations existed long
before. The first recognized system for creating algorithm animations was BALSA [2]
in 1984. Since then, hundreds of algorithm visualizations have been implemented and
provided freely to educators, and scores (or hundreds) of papers have been written about
them. It is widely perceived that algorithm visualizations can provide a powerful
alternative to static written presentations (from textbooks) or verbal descriptions
supported by illustrations (from lectures). There has been some debate in the literature
as to whether algorithm visualizations are effective in practice. Some studies have
shown the classic dismissal that is the downfall of most technological interventions in
education: “no significant difference” [6, 9, 11]. Other studies have shown that
algorithm visualizations can indeed improve understanding of the fundamental data
structures and algorithms that are part of a traditional computer science curriculum [13,
3, 7]. Certainly, many visualizations exist and are widely (and freely) available via the
Internet. Unfortunately, the vast majority of those currently available serve no useful
pedagogical purpose.

So we see that (a) many algorithm visualizations exist, yet relatively few are of true
value, and (b) algorithm visualizations can be demonstrated to have pedagogical value,
yet it is also quite possible to use them in ways that have no pedagogical effect. These
facts seem to imply that creating and deploying effective algorithm visualizations is
difficult. There is a small body of literature that investigates how to create
pedagogically useful algorithm visualizations (for example, [10, 15]). Yet, there is still
much to be done before we are at the point where good quality visualizations on most
topics of interest are widely available.
Literary Survey:

The purpose of this paper is to provide a summary of preliminary findings resulting

from our efforts to survey the state of the field of algorithm visualization. To bound the
content area, we focused our attention on topics commonly taught in undergraduate
courses on data structures and algorithms. We seek an understanding of the overall
health of the field, and present a number of open research questions that we and others
can work on in the future. Since Spring 2006, we have made a significant effort to
catalog as many existing algorithm animations as we could. The results can be found at
our Data Structure and Algorithm Visualization Wiki [18]. In this time, we have
developed the most extensive collection of links to algorithm visualizations currently
available. While it is by no means complete, it does serve as a representative sample of
the total population of visualizations accessible from the Internet. We are still collecting
visualizations, and many of the following assessments are based on preliminary data.
We used a number of techniques to locate algorithm visualizations. We began with a
list of all visualization systems that we were aware of from our general knowledge of
the field. We developed a topic list based on our experiences teaching relevant courses.
We considered what search terms would be most productive for locating visualizations
via Internet searches (this is discussed further in Section 3). Based on our topic list, we
then performed searches using Google to find whatever we could. Once we had
generated a base of visualization links, we then examined these pages to try to locate
other visualizations, since developers of a given visualization often have others
available. Sometimes we could find these other visualizations from direct references on
the pages we already had, and other times we could deconstruct the URLs to find more
visualizations. Whenever we stumbled across a page that had links to collections of
visualizations, we would follow those links to capture any new ones not yet in our
collection. We have collected links to over 350 visualizations. Many of these are
individual applets or programs, but a significant fraction appear as parts of integrated
visualization collections (typically, individual applications that include 5-20 distinct
visualizations, or toolkits that distribute a collection of 5-20 distinct visualizations as a
unit). If a given program contains multiple visualizations (for example, a single Java
applet that embodies separate visualizations for both stacks and queues), then we count
it multiple times, once for each distinct visualization. We speculate that we have so far
captured roughly half of what is publicly available.
Methodology:

In this article, we will build a Sorting Algorithm Visualizer using Python and Tkinter. Tkinter
is a standard GUI library for Python. We will use it to create the user interface of our project.
We will visualize Bubble Sort and Merge Sort. But we can implement all the comparison-
based sorting algorithms in this project.
Table of Contents:
· File Structure of the Project
· colors.py
· main.py
· Filling up The Functions
· Implementing Bubble Sort
· Implementing Merge Sort
· Completing what we left behind
We will structure our project files at the very beginning. First, we will create a folder and name
it Sorting Visualizer. This will be our project directory. Inside this folder, we will create
another folder named algorithms. Then we will create two python
files main.py and colors.py. main.py will be our main Python file which we will
execute. colors.py will contain some hexadecimal values of colors that we will need.
Inside the algorithm folder, we will create a file __init__.py. This will allow
the algorithms folder to act as a Python package. See the documentation on packaging a
project. We will create two more Python files inside
the algorithms folder, bubbleSort.py and mergeSort.py. In these files, we will implement our
sorting algorithms.So our file structure will be like this…

In colors.py we will store some hexadecimal values of colours as variables. We will use these
colours in our project.
main.py will be our main executable file that will run our project. We will import all packages
and modules in this file. First, we will import some stuff and set up a basic interface.
Facilities Required for the Project:

• Install Visual Studio Code.

• Install Python and Add to Path.
• Install MinGW.
• Install all the modules like random, math, and many more
• A computer or laptop with good specifications.

References:

[1] Association for Computing Machinery. The ACM digital library. http://portal.acm.org,
2006.
[2] M. H. Brown and R. Sedgewick. A system for algorithm animation. In SIGGRAPH ’84:
Proceedings of the 11th Annual Conference on Computer Graphics and Interactive Techniques,
pages 177–186, New York, NY, USA, 1984. ACM Press.
[3] M. D. Byrne, R. Catrambone, and J. T. Stasko. Do algorithm animations aid learning?
Technical Report GIT-GVU-96-18, Georgia Institute of Technology, 1996.
[4] CITIDEL: Computing and information technology interactive digital educational library.
http:// www.citdel.org, 2006.
[5] Connexions scholarly content repository. http:// cnx.org, 2006.
[6] J. S. Gurka and W. Citrin. Testing effectiveness of algorithm animation. In Proceedings,
IEEE Symposium on Visual Languages, pages 182–189, 1996