01. introduction to data structures

Chapter – 1 Introduction to Data Structures
Asmelash Girmay
Department of Information Technology
Data Structures

The Need of Data Structure
• Helps to understand relationship one data element with other and
organize it within the memory. Example:
• Months of a year: one month after the other can be linked
• Thus knowing the starting and ending month name could help to know the other months
• Specific department of a university can be represented in a tree
• Example: IT
IT3201 Data Structures 22018-10-30

Data Representation
• Various methods are used to represent data in Computers
• Example: hierarchal data representation
• Bit – basic unit of data representation
• Byte – combination of 8 bits
• In ASCII code representation 1 byte represents a character
• One or more characters are used to form a string
• String: is a data structure that emerges through several layers of data structures.

Integer Representation
• Int: -2n-1 to 2n-1 - 1 using n-number of bits
• Non-negative int represented using binary number system
• Each bit position represents power of 2, where the right most bit represents 20 = 1
• Example: 00100110 represents 21 + 22 + 25 = 2 + 4 + 32 = 38.
• Negative int represented using one’s complement and two’s complement
• One’s complement complements each bit, e.g. -38 = 11011001
• Two’s complement adds to the one’s complement of a number, e.g. -38 = 11011010

Real Number Representation
• Float: m*nr => -3.4*1038 to 3.4*1038
• A real number is represented by mantissa and exponent. E.g.,
• 43.56 can be represented as 4356 * 10-2 , where 4356 – mantissa, -2 exponent
• Both mantissa and exponent are two’s complement of binary
integers. E.g.
• 4356 = 0001000100000100, and -2 = 1111 1110 (8 – bit representation)
• 43.56 = 0001 0001 0000 0100 1111 1110

Character Representation
• Char: [0-9, a-z, A-Z] + other symbols = 2n chars, for n-number of bits
• Codes to represent characters are BCD, EBCDIC, ASCII
• ASCII is commonly used
• If 8 bits used to represent a character, 28 = 256 characters can be represented
• E.g., If character ‘A’ represented with 0100 0001 and ‘B’ with 0100 0010, then
“AB” can be represented with 0100 0001 0100 0010, which is a string

Abstract Data Types (ADTs)
• ADT is the mathematical model of data objects
• Specifies logical & mathematical properties of a data type and its operations
• ADT is useful as a guideline to implement a data type.
• In ADT, no implementation
• Two steps in ADT
1. Description of the way in which components are related to each other.
2. Statements of operations that can be performed on that data type.

Abstract Data Types (ADTs)...
• Example: in C, to implement integer data type, INTEGER_ADT defines:
• Range of numbers that will be represented
• Formats for storing the integer numbers
• Operations on it, such as addition, subtraction, division, multiplication,
modulo

Data Type
• A method of interpreting a bit pattern.
• It’s the implementation of the mathematical model specified by an ADT.
• It is an internal representation of data in the memory.
• Once ADT specification is done, a data type can then be implemented in:
• Hardwire – Circuitry as part of a computer
• Software – using the existing hard wired instructions

Data Structure Types

Review on C
This course uses C to implement data structures

Function
• A section of program, separately written from main program for:
• Reusability, readability, and/or modularity of software program.
• Function is a way of modularizing and organizing program.
• Function has much emphasis on procedural-oriented programming such as C.
• We can define a function in C in 4 ways.
• A function – with return type and argument/s [WRWA]
• A function – with return type but no arguments [WRNA]
• A function – with no return type but with arguments [NRWA]
• A function – with no return type and no arguments [NRNA]
KEY: R-return type, A – Argument lists, W – With, and N – No

Function…

Array
• Array is a derived data type, from basic data types like int, float, char, etc.
• It is used to store more than one data of same types at a time. E.g.,
• float StudentsGrade [57];
• It stores data in indexing form, where indexing starts at 0 (zero).
• It is also a data structure, but built-in and stores fixed-size sequential collection of
elements of same type.
• There are one-dimensional arrays, two-dimensional arrays, and three or above
dimensional arrays.

Structures
• A structure is a user-defined derived data type which allows you to
combine data items of different kinds/types.
• Used to store/represent a record as in a database table. E.g.,
• Attributes of a book:
• Title,
• Author,
• Subject,
• BookId

Structures…
• Exercise: Given a record with attributes, Students {name, gender,
department, idNumber}. Construct a structure type of students and use
them in your main program.
• A special type of structure that points to it self.
• It’s important in creating a linked list, dynamic stack and queue, tree, and
other data structures.

Pointers
• It is a type, which stores the location of another variable of any data
type.
• In C, some tasks are easy to work with pointers;
• Tasks like memory management cannot be performed without using pointers.
• Example: int A; int *ptrA = &A;

Memory Management
• Memory space is limited and should be dynamically managed.
• In C, memory management is done using
• Pointers, and
• Built-in functions such as calloc, free, malloc and realloc

Conditional statements
• In C, conditional statements are used to define conditional actions,
e.g., if no class, work on your homework. Otherwise, go to class.
• Conditions are defined using
• if…
• if...else
• if...else if…else
• switch

Loops
• In C, loops are used to program repetitive actions
• Loops defined using one of the following, let’s say: int i, n = 10;
• For loop:
• for (i=0; i<n; i++) { //Statements }
• While loop
• while (i<n) {//Statements; i++;}
• Do…while loop
• do {//Statements; i++;} while (i<n);

Analysis of Algorithm
The algorithm can be analyzed by tracing all step-by-step instructions.

Algorithm
• Algorithm should be checked for
• Correctness
• Simplicity
• Performance
• Algorithm performance analysis and measurements depends on:
• Space complexity
• Time complexity

Algorithm: Space Complexity
• Space complexity of an algorithm is the amount of memory it needs
to run to completion.
• Space needed by a program:
• Instruction space: to run an executable program. It is fixed
• Data space: to store all constants and variable values…
• For constants and simple variables. Fixed
• For fixed structural variables such as array and structure
• Dynamically allocated space.

Algorithm: Space Complexity…
• Environment stack space: to store information of suspended functions
• When a function is invoked, the following data is stored:
• Return address
• Value of all lead variables and formal parameters of the function being invoked
• The amount of space used by recursive functions is called recursive stack space.
• This space depends on:
• The size of each local variables
• The depth of the recursion

Algorithm: Time Complexity
• The amount of time a program needs to run to completion
• Exact time depends on:
• Implementation of the algorithm
• Programming language
• Compiler used
• CPU speed
• Other hardware characteristics
• Counting all operations performed in the algorithm will help in calculating time

Algorithm: Time Complexity…
• Time complexity has to be expressed in the form of functions
• Analysis of algorithm depends
• The input data
• Three cases of an algorithm
• Best case – best possible input data
• Average case – typical input data
• Worst case – worst input configuration

Algorithm: Big “OH” Notation
• A characteristics scheme that measures properties of algorithm complexity,
performance, and memory requirements.
• Complexity can be measured by eliminating constant factors.
• Thus, complexity function f(n) of an algorithm increases as ‘n’ increases.
• E.g., Let’s consider a sequential searching algorithm
• If an array contains n elements.
• Worst case – the search compares the whole elements with the target, thus f(n) = n
• Average case – if the target element found at half way, thus f(n) = n/2
• Best case – if the target element found in the first position, thus f(n) = 1

Algorithm: Big “OH” Notation...
• F(n) = O(n) read as “fof n is big Oh of n” or “f(n) is the order of n”
• The total running time (or time complexity) includes the initializations and several other
iterative statements through the loop.
• Based on the time complexity representation of the big Oh notation, an algorithm can
be:

Limitation of Big “OH” Notation
• It contains no effort to improve the programming methodology. Big Oh Notation
does not discuss the way and means to improve the efficiency of the program,
but it helps to analyze and calculate the efficiency (by finding time complexity) of
the program.
• It does not exhibit the potential of the constants. For example, one algorithm is
taking 1000n2 time to execute and the other n3 time. The first algorithm is O(n2),
which implies that it will take less time than the other algorithm which is O(n3).
However, in actual execution the second algorithm will be faster for n< 100

Recursion
”A recursion routine is one whose design includes a call to itself”

Recursion
• Recursion is a powerful technique for defining an algorithm
• A procedure is recursive if it is defined in terms of itself. E
• Example:
• Factorial: f(n) = n*f(n-1), where f(0) = 1 for n>0.
• Fibonacci numbers f(n-1) + f(n-2), where f(0) = 0, f(1) = 1.

Recursion…
• Factorial:
• Factorial (n)
• If n == 0 or 1 Return 1;
• Else Return n*Factorial(n-1);
• Fibonacci:
• Fibonacci(n)
• if n <= 1 Return n;
• else Return Fibonacci(n-1) + Fibonacci(n-2);

Principle of Recursion
• While design an algorithm with recursion, the following basic principles should be
considered.
1. Find the key step – then find out if the remaining problem can be solved the same way
2. Find a stopping rule – after substantial part of an algorithm is done, the execution should
stop
3. Outline the algorithm – combining the above two principles (1 and 2) with if…else
statements and recursion, an algorithm should be designed
4. Check termination – the recursion should terminate after finite number of steps
5. Draw a recursion tree – to analyze the recursion algorithm, one has to draw a recursion
tree

Recursion vs Loop
• Loop is used when we want to execute a part of the program or block
of statements several times
• A recursion function is a function which calls itself from its body again
and again.

The End ☺

01. introduction to data structures

Recommended

Recommended

More Related Content

What's hot

What's hot (16)

Similar to 01. introduction to data structures

Similar to 01. introduction to data structures (20)

Recently uploaded

Recently uploaded (20)

01. introduction to data structures