Attribution Non-Commercial (BY-NC)

Als PDF, TXT **herunterladen** oder online auf Scribd lesen

45 Aufrufe

Attribution Non-Commercial (BY-NC)

Als PDF, TXT **herunterladen** oder online auf Scribd lesen

- DSA 3.pdf
- Harvard SPSS Tutorial.pdf
- JFo_3_2.pdf
- Numerical Analysis of a Fractional Step Θ-method for Fluid Flow Problems. a Dissertation Presented to the Graduate School of Clemson University
- ABAP Data Declarations
- Computer Programming Practical Assig 1-2
- CS_Final
- Data types variables and Arrays
- LiskovZilles74
- Lecture 2&3
- Data Structure.pptx
- Elementary Data Types
- Tut 5
- Generic Ethernet Ip Explicit s
- L1 Analysis
- -2b. AsymptoticAnalysis
- Lec_2.1
- 220handout-lecture04
- Intro Algo
- CSE373

Sie sind auf Seite 1von 19

At the end of this chapter, you will be familiar with the concepts of data structures and

algorithms.

SCOPE

1.1 Introduction

1.3 Algorithms

1.3.1 Analysis of Algorithms

1.3.2.1 Space Complexity

1.3.2.2 Time Complexity

1.3.2.3 Asymptotic Notation

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 1

Introduction to Data Structures And Algorithms

1.1 Introduction

Computers help us in solving many real life problems. We know that computers can work

with greater speed and accuracy than human beings. What actually does a computer do?

A very simple answer to this question is that a computer stores data and reproduces it as

information as and when required. Representation of data should be in a proper format so

that accurate information can be produced at high speed. In this course, we will study the

various ways in which data can be represented. Efficient storage and retrieval of data is

important in computing. In this course we will study and implement various data

structures.

Organized data is known as information. Let us consider a few examples and try to

understand what data structures are. You all must have seen a pile of plates in a

restaurant. Whenever a plate is required, the plate on the top is removed. Similarly, if a

plate is added to the pile, it is kept on the top of the pile. There is a definite process

involved in the storage and retrieval of the plates. If the rack is empty there will be no

plates available. Similarly if the rack is full then there will be no place for more plates.

Similar process is applied with stacks. Stack is a data structure which stores data at the

top, this operation is known as push. It retrieves data from the top, the operation is known

as pop. If the stack is empty then the pop operation raises an error while push operation

cannot be performed if the stack is full. Stack is shown in fig 1.1

Top

Fig 1.1

Stack (pile of plates)

You must have seen a queue at the bus stop. There is a well-defined method for a person

to enter the queue as well as leave the queue to get into the bus. To enter a queue a person

stands at the end of the queue and the person at the start of the queue leaves the queue to

enter the bus. Similarly, we have queue as a data structure in which a data element is

added at the rear end and removed from the front end. Fig 1.2 shows the structure of

queue.

Fig 1.2

Queues

Chapter 1

2 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

In a train, separate compartments are joined together. A new compartment can be added

at the end, at the beginning or in between the existing train compartments. The same

method is followed to remove a compartment. Linked lists in data structures follow

similar approach. An element can be inserted and deleted from any position in the linked

list. A list can be shown as in figure 1.3.

Fig 1.3

Linked list (train compartments)

There are other data structures that we will study in this course, for example graphs, trees

etc. As we have seen in the above examples data structures stores a given set of data

according to certain rules. These rules help in organizing the data.

You have studied programming languages before. This example will use some concepts

from it to explain why data structures are essential. Data can be stored in various ways.

Usually the representation chosen depends on the nature of the problem and not on the

data. Consider a program, which requires storing marks of five students for a single

subject. The simplest way to store them will be to use five integer variables. We assume

that the roll numbers are from one to five. Now I wish to write a program, which can give

me the marks of any roll number given as input. Is it possible to write an efficient

program to do this task if the numbers are stored as variables?

a b c d e

Fig 1.4

Marks stored in five different variables

The data, in this case the marks, is stored, but it cannot be reproduced as information

efficiently. Now we take an array of integers with five elements. The above data is stored

in the array. An array will have a name ‘a’ and each individual element can be accessed

using index. Therefore, the marks for the first roll number will be stored as a[0], for the

second roll number as a[1] and so on.

There is a relation between the roll number and the array index. Now it is much easier to

access the marks according to the roll number. This could not be achieved using

variables, as there was no relation between the data. It was not possible to relate marks

and roll number.

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 3

Introduction to Data Structures And Algorithms

Fig 1.5

Marks stored as an array

The above example can be slightly modified so that now we will store the marks of three

subjects per roll number. We can take three independent arrays to store them. We can

access the individual marks for each roll number from the respective arrays. We find that

the arrays contain marks of different subjects for the same roll number. It would be easier

to handle the marks if these three arrays were grouped together.

Fig 1.6

Three arrays to store the marks of three subjects

Now we need a data structure that stores the above information in logical relation with

each other so that it can be retrieved with higher speed. Structures in C store various

fields together, so now we can store the marks of three subjects in the structure and then

make an array of five elements. The above example shows that the method in which data

should be represented depends on the problem to be solved. The structure definition will

be as follows.

struct record

{

int a[5];

int b[5];

int c[5];

};

In the above problem, we have used three different types of representations for the data.

They are all built using the basic data structures. There are certain rules associated with

each data structure that restrict the storage and retrieving of data in an ordered format.

We have seen examples like stacks and queues, which restrict the entry and exit of its

Chapter 1

4 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

elements according to certain rules. Stacks allow entry and exit of elements at the top

position only, while in queues an element is added at the end and removed from the front.

Arrays and structures are built in data structures in most of the programming languages.

Data can be stored in many other ways using other type of data structures. Thus we can

define data structure as a collection of data elements whose organization is characterized

by accessing functions that are used to store and retrieve individual data elements. Data

structures are represented at the logical level using a tool called Abstract Data Type

(ADT) and actually implemented using algorithms.

Abstract Data Type’s show how exactly the data structure behaves. What are the various

operations required for the data structure? It can be called as the design of the data

structure. Using the Abstract Data Type, it can be implemented using various algorithms.

Abstract Data Type clearly states the nature of the data to be stored and the rules of the

various operations to be performed on the data. For example, the Abstract Data Type of a

stack will clearly state that a new element will be inserted at the top and an element can

be removed only from the top of the stack. It does not specify how these rules should be

implemented. It specifies what are the requirements of a stack.

The implementation of a data structure is done with the help of algorithms. An algorithm

is a logical sequence of discrete steps that describe a complete solution to a given

problem in a finite amount of time. A task can be carried out in various ways, hence

there are more than one algorithm which can be used to implement a given data structure.

This means that we will have to analyze algorithms to select the best suited for the

application. In this book, we will study the representation, implementation and analysis

of basic data structures.

Before we move to abstract data type let us understand what data type is. Most of the

languages support basic data types viz. integer, real, character etc. At machine level, the

data is stored as strings containing 1’s and 0’s. Every data type interprets the string of bits

in different ways and gives different results. In short, data type is a method of interpreting

bit patterns.

Every data type has a fixed type and range of values it can operate on. For example, an

integer variable can hold values between the min and max values allowed and carry out

operations like addition, subtraction etc. For character data type, the valid values are

defined in the character set and the operations performed are like comparison, conversion

from one case to another etc. There are fixed operations, which can be carried out on

them. We can formally define data types as a formal description of the set of values and

operations that a variable of a given type may take.

That was about the inbuilt data types. One can also create user defined data types, decide

the range of values as well as operations to be performed on them. The first step towards

creating a user defined data type or a data structure is to define the logical properties. A

tool to specify the logical properties of a data type is Abstract Data Type (ADT).

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 5

Introduction to Data Structures And Algorithms

Data abstraction can be defined as separation of the logical properties of the organization

of programs' data from its implementation. This means that it states what the data should

be like. It does not consider the implementation details. ADT is the logical picture of a

data type; in addition, the specifications of the operations required to create and

manipulate objects of this data type.

In the next section, we will study the method to represent an ADT. While defining an

ADT, we are not concerned with time and space efficiency or any other implementation

details of the data structure. ADT is just a useful guideline to use and implement the data

type.

(b) Operation definition.

As the name suggests the definition clause states the contents of the data type and

condition clause defines any condition that applies to the data type. Definition clause is

mandatory while condition clause is optional. For example, an integer variable can

contain only integer values while a character variable can contain only a valid character

value.

To understand the above clauses let us consider the ADT representation of integer data

type. In the value definition the definition clause will state that it can contain any number

between minimum integer value and the maximum integer value allowed by the computer

while the condition clause will impose a restriction saying none of the values will have a

decimal point.

(1) Function

(2) Precondition

(3) Postcondition

The function clause defines the role of the operation. If we consider the addition

operation in integers the function clause will state that two integers can be added using

this function .In general, precondition specifies any restrictions that must be satisfied

before the operation can be applied. This clause is optional. If we consider the division

operation on integers then the precondition will state that the divisor should not be zero.

So any call for divide operation, which does not satisfy this condition, will not give the

desired output.

Chapter 1

6 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

Precondition specifies any condition that may apply as a pre-requisite for the operation

definition. There are certain operations that can be carried out if certain conditions are

satisfied. For example, in case of division operation the divisor should never be equal to

zero. Only if this condition is satisfied the division operation is carried out. Hence, this

becomes a precondition. In that case & (ampersand) should be mentioned in the operation

definition.

Postcondition specifies what the operation does .One can say that it specifies the state

after the operation is performed. In the addition operation, the post condition will give the

addition of the two integers.

ADT

Clause Clause Condition Condition

Fig 1.7

Components of ADT

As an example, let us consider the representation of integer data type as an ADT. We will

consider only two operations addition and division.

Value definition

(1) Definition clause: The values must be in between the minimum and maximum values

specified for the particular computer.

Operations

(1) add(a,b)

Function: add the two integers a and b.

Precondition: no precondition.

Postcondition: output = a+b

(2) Div(a,b)

Function: Divide a by b.

Precondition: b != 0

Postcondition: output = a/b.

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 7

Introduction to Data Structures And Algorithms

There are two ways of implementing a data structure viz. static and dynamic. In static

implementation, the memory is allocated at the compile time. If there are more elements

than the specified memory then the program crashes. In dynamic implementation, the

memory is allocated as and when required during run time.

Any type of data structure will have certain basic operations to be performed on its data

like insert, delete, modify, sort, search etc depending on the requirement. These are the

entities that decide the representation of data and distinguish data structures from each

other.

Let us see why user defined data structures are essential. Consider a problem where we

need to create a list of elements. Any new element added to the list must be added at the

end of the list and whenever an element is retrieved, it should be the last element of the

list. One can compare this to a pile of plates kept on a table. Whenever one needs a plate,

the last one on the pile is taken and if a plate is to be added on the pile, it will be kept on

the top. The description wants us to implement a stack. Let us try to solve this problem

using arrays.

We will have to keep track of the index of the last element entered in the list. Initially it

will be set to –1.Whenever we insert an element into the list we will increment the index

and insert the value into the new index position .To remove an element, the value of

current index will be the output and the index will be decremented by one. In the above

representation, we have satisfied the insertion and deletion conditions.

Using arrays we could handle our data properly, but arrays do allow access to other

values in addition to the top most one. We can insert an element at the end of the list but

there is no way to ensure that insertion will be done only at the end. This is because array

as a data structure allows access to any of its values. At this point we can think of another

representation, a list of elements where one can add at the end, remove from the end and

elements other than the top one are not accessible. As already discussed this data

structure is called as STACK. The insertion operation is known as push and removal as

pop. You can try to write an ADT for stacks. We have covered stacks in detail in Chapter

3.

Another situation where we would like to create a data structure is while working with

complex numbers. The operations add, subtract division and multiplication will have to

be created as per the rules of complex numbers. The ADT for complex numbers is given

below. Only addition and multiplication operations are considered here, you can try to

write the remaining operations.

The ADT for complex numbers is as follows:

Value Definition:

Definition Clause: This data type has values a +ib where a and b are integers and i is

equal to under root of –1.

Chapter 1

8 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

Operations

1) add

Precondition: no Precondition.

2) multiply

Precondition: no Precondition.

1.3 Algorithms

In the last section, we considered the abstract form of data structures. Now it is also

essential to implement the abstract form in order to use the data type. Implementation is

nothing but writing functions for the various operations. Then these functions can be used

whenever required .In fact a library of data structures can be created. To write these

functions we will have to specify instructions step-by-step. When these instructions are

not language specific, it can be called as an algorithm. For example, the algorithm to add

two numbers is given below:

2) Input the second number and store in a variable.

3) Add the two numbers and store the result in a variable.

4) Display the result.

Any given task can be performed in various ways. There is more than one algorithm to

implement a given operations .In this section we will see how to choose the best method

according to our need. This does not mean that the other methods are not useful. Every

method or algorithm has its own advantages and disadvantages regarding the resources

required. Due to this, it is essential to analyze the algorithms. This analysis helps us to

select a proper algorithm. There are various methods to analyze algorithms.

By now the need of analyzing algorithms must be pretty clear. Two main factors on

which the performance of a program depends are the amount of computer memory

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 9

Introduction to Data Structures And Algorithms

consumed and the time required to execute it successfully. There are two ways in which

we can analyze the performance of an algorithm. One of them is to carry out experiments

with the algorithm by actually executing it, using various data sets and recording the

space and time required. This data can be analyzed to find the performance of an

algorithm. This method can be used only after successful implementation. Another

method, which can be used, is the analytical method. We can approximately find out the

space and time required before implementation.

successfully. This estimation of space can be used to identify the amount of memory

required by the implementation. This information can be used while allocating memory

in multi-user computer systems or while executing it on a system with less memory

resources. In addition, we can find out the size of the largest problem that a program can

solve in a given environment.

Let us consider the various factors on which space complexity depends. You all must be

familiar with static allocation and dynamic allocation of memories. In static allocation,

the memory required by the program is known at compile time while in dynamic

allocation it can increase during execution. Programs using recursion need space

depending on the number of recursive calls made. Each recursive function needs stack

space to store local variables and formal parameters. Based on the above discussion we

can divide the space needed by a program into two parts:

(1) A static part, which is independent of the instance characteristic. This includes the

space required to store the code. Again, the space required to store the code is

compiler and machine dependent. Other components are constants, variables,

complex data types etc.

(2) A dynamic part, which consists of components whose memory requirements, depends

on the instance of the problem being solved. Dynamic memory allocations and

recursion are few components of this type. The factors, which can help us in

determining the size of the problem instance, are number of inputs, outputs etc.

Example

(a) Let us consider a small function, which adds all the elements in a given array, and

analyzes its space complexity.

{

int value = 0;

for (int i = 0; i<n;i++)

value = value + a[i];

return value;

}

Chapter 1

10 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

In this function, we require space for a, i, value, n. All of them are static components and

hence require a fixed space. The total space required by this function would be equal to

the sum of all the above components.

(b) Next, let us consider the example to calculate factorial. We will write the function

using recursion.

{

if (n <= 1) return 1;

else return n * factorial (n-1);

}

In this function space required does not depend on the number of inputs but is a function

of n. the recursion depth will be at the most n and at least 1. Each recursive call will need

a stack space of two bytes to store the return address. Hence the memory required can be

calculated using the function 4* max {n, 1}.

Time can be useful in knowing the maximum time limit of the program to be executed. In

addition, we can test the response time of the program .It is very essential to have a good

response time for interactive applications like text editors etc.

Before analyzing an algorithm for time, we should know the machine and compiler on

which it is executed as compilation and execution time depends on them. If we consider a

conventional computer then we can assume that instructions of a program are carried out

one at a time and the major time is consumed by the operations carried out in the

algorithm.

There are two steps to be carried out during analysis of an algorithm. First step is to

determine the operations present in the algorithm. The various types of operations are

addition, subtraction, multiplication, division, comparison, assignment of values etc. All

the above operations take fixed time to complete i.e. their time is bound by a constant.

There are certain operations like comparison of strings, which are dependent on the

length of the string and hence require variable time. The second step is to determine data

sets, which cause the algorithm to exhibit the possible patterns of behavior. This step is

useful to find out the best, average and worst case behaviors.

There are two methods in which computing time can be analyzed viz. priori and

posteriori analysis. In priori analysis, we find an analytical function, which binds the

computing time of the algorithm. In a posteriori analysis, we work with the actual

statistics collected by execution of programs. We will consider how priori analysis can be

done. We have to find out the execution time required by each program statement. For

this we should know the number of time each program statement is executed and the

individual time taken for execution .The product of two will be the total execution time of

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 11

Introduction to Data Structures And Algorithms

each statement while sum of all these products will give the total time. Time required by

each program statement is computer and compiler dependent. So we can do priori

analysis only by finding out how many times each statement is executed i.e. the

frequency count.

Examples

(a) a = b + c;

(b) for(i=0;i<n;i++)

a = b + c;

for(j=0; j<n j++)

a = b + c;

In example (a) the statement is executed once so frequency count is 1. In example (b) the

line is execute n times while in example (c) it is executed n2 times. These frequencies

give the order of magnitude. The order of magnitude of an algorithm is the sum of

frequencies of all its statements. There are various mathematical notations, which help us

in analysis using the order of magnitude. In the next section we will see how this order of

magnitude is used to determine the time complexity of an algorithm.

We have studied time and space complexity in the previous section. These two

complexities are used during the analysis of algorithms. Algorithm analysis helps us to

choose the best algorithm for a given application. In the previous section we saw how

time and space complexity is calculated. Time and space complexity is measured in terms

of asymptotic notations. For example let us consider a program which stores n elements.

void store( )

{

int i, n;

printf(“enter the number of elements “);

scanf(“%d”, &n);

for(i = 0; i < n; i++)

{

}

}

In the above program space is required to store the executable code and to store the ‘n’

number of elements. The memory that is required to store the executable code is static.

The memory required to store the ‘n’ elements depends on the value of ‘n’.

Chapter 1

12 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

The time required to execute the code also depends on the value of ‘n’. In the above

program we have two executable statements printf and scanf. Let us assume there are x

statements in the for loop. Then the time required to execute the program will be equal to

x * n + 2.

‘n’ is the instance characteristics. Asymptotic notation can describe the time and space

complexity accurately for large instance characteristics. Asymptotic notation will provide

us with upper and/or lower time and space bounds for a given algorithm. However, what

do you mean by upper and lower bounds? Upper bound will give the maximum time or

maximum space required for a program. Lower bound will give the minimum time /

space required.

Big Oh notation

Definition: f (n) = O(g(n)) (read as “f of n equals big oh of g of n”) iff (if and only

if) there exist two positive constants c and n0 such that | f(n)| <= c|g(n)| for all n

>= n0 .

Big oh notation provides an upper bound for the function f. Consider f(n) to be the

computing time of some algorithm where n is the number of inputs, outputs, their sum or

any one of them. When we say that an algorithm has computing time O(g(n)) we mean

that if the algorithm is run on any computer on the same type of data but for increasing

values of n, the resulting time will always be less than some constant time g(n).

n <= 6n. So f(n) = O(n). Thus f(n) is bounded from above by a linear function. We

can arrive to the same conclusion in other ways. For example, 5n + 2 <= 10n for n>0.

Therefore we can also satisfy the definition of big oh by selecting c=10 and n0 equal to

any integer greater than zero.

(2) Quadratic Function: Suppose that f (n) = 5n2 + 4n + 2. We see that for n >= 2,

f (n) <= 5n2 + 5n. Now we note that for n>=5, 5n <= n2. Hence for n >= n0 = 5, f

(n) <= 5n2 + n2 = 11n2. Therefore f (n) = O (n2).

Omega Notation

constants c and n0exists such that f (n) >= g n0 for all n, n >= n0.

Omega notation provides the lower bound for function f. f(n) = omega(g(n)) means

f is atleast c times the function g except when n is smallest than n0.

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 13

Introduction to Data Structures And Algorithms

For example suppose we have a linear function f(n) = 3n + 2. Now 3n + 2 > 3n for

all n, hence f(n) = omega (n). If we consider a quadratic function f (n) = 5n2 + 2n

+ 2 then 5n2 + 2n +2 > 5n2 for n >= 0, hence we can say f (n0) = omega (n2).

Theta Notation

constants c1 and c2 and an (n0) exists such that c1 g(n) <= f(n) <= c2 g(n) for all

n, n >=n0.

F (n) = theta(g(n)) means f lies between c1 times the function g and c2 times the

function g except possibly when n is smaller than (n0). Here c1 and c2 are positive

constants. Thus g is both a lower and upper bound for a constants factor c on the value of

f for all suitably large n.

accessing functions that are used to store and retrieve individual data elements. The study

of data structures involves two major goals. The first goal is to identify and develop

useful mathematical entities, operations and determine what classes of problems can be

solved by using these entities and operations. A matrix is one such mathematical entity

that is used to solve various problems. The second goal is to determine representations

for abstract entities and implement them. Stack is a good example of the second goal.

The first goal aims at using high level data types as a tool to solve problems, while the

second one tries to implement the data type using the already existing data types. Usually

it is impossible to implement a mathematical model completely using hardware and

software. For example Integers have infinite number of values but on computer it is

between some finite range. One should know what are the limitations associated with a

particular implementation. One can implement the same data type in many possible ways.

Each representation will have its own strength and weakness. One should know the

possible tradeoffs that are involved while working for a specific application.

Example

You have studied programming languages and are familiar with C. Array is one of the

invaluable data structures in C. It is made up of the existing data types in the language.

Let us see how array is built up in C. We will consider the single dimensional array.

Basically, an array is an ordered set of homogeneous elements. Every array has a lower

bound, which is the smallest index and upper bound, the largest index. Two operations

done on an array are extraction and storing. Let us consider the ADT for arrays.

Chapter 1

14 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

1) Value definition

i) Definition clause:

The array will have elements equal to upper_bound and will contain elements of

element_type.

2) Operations

i) Retrieve (a, I)

Function: It retrieves an element from array placed at index, i. Returns an element _type

value.

Postcondition: output = a[I]

Postcondition: a [I] == element

Using basic data types, i.e. variables, we can carry out the implementation. A block of

memory capable of storing the required elements will be pointed by the array variable.

We will not move towards implementation details of array. This is just to give you an

idea how data structures can be built using basic data types.

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 15

Introduction to Data Structures And Algorithms

SELF ASSESSMENT

2. Differentiate between the Stacks and Queues on the basis of the storage of data.

5. Differentiate between the inbuilt functions and the user defined functions.

_____________.

Chapter 1

16 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

SUMMARY

♦ A computer program has data and a set of algorithms, which act on the data to

produce, required information.

♦ There are various ways in which data can be stored for a given problem. A data

structure is a collection of data elements whose organization is characterized by

accessing functions that are used to store and retrieve individual data elements.

to a given problem in a finite amount of time.

data type or a formal description of the set of values that a variable of a given type

may take is called a data type.

♦ An ADT is the logical picture of a data type plus the specifications of the operations

required in creating and manipulating objects of this data type.

♦ Basic operations performed on any type of data structures are insert, modify, delete,

search, sort etc.

♦ There are various algorithms available to implement the same task. Hence it is

necessary to analyze algorithms.

complexity.

program successfully.

in dynamic allocation it can increase during the execution.

successfully.

♦ The order of magnitude of an algorithm is the sum of the frequencies of all of its

statements.

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 17

Introduction to Data Structures And Algorithms

algorithms

♦ There are various types of asymptotic notations viz. Big Oh, Omega, Theta etc.

determine what classes of problems can be solved using these entities and

operations.

Chapter 1

18 Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority

Introduction to Data Structures And Algorithms

LAB EXERCISE

1. Write a program using two-dimensional arrays to store the names of 20 students.

• Enter a name.

• Delete a name.

• Display a name.

• Display all the names.

• Modify a name.

2. Write a program using structures to store the record of ten employees. The record

contains the following information:

• Employee name

• Employee number

• Salary

• Enter a record.

• Delete a record.

• Display a record.

• Display all the record.

• Modify a record.

Chapter 1

Copyright Tata Infotech Ltd. : Copying of this document in part or full is not permitted without express authority. 19

- DSA 3.pdfHochgeladen vonNishu Rave
- Harvard SPSS Tutorial.pdfHochgeladen vonsunilgenius@gmail.com
- JFo_3_2.pdfHochgeladen vonAkbar Wisnu
- Numerical Analysis of a Fractional Step Θ-method for Fluid Flow Problems. a Dissertation Presented to the Graduate School of Clemson UniversityHochgeladen vonNikolas Korakianitis
- ABAP Data DeclarationsHochgeladen vonVikrant077
- Computer Programming Practical Assig 1-2Hochgeladen vonAbhinav Bansal
- CS_FinalHochgeladen vonAnonymous eUjKo3
- Data types variables and ArraysHochgeladen vonapi-3777165
- LiskovZilles74Hochgeladen vonAnalyst_M
- Lecture 2&3Hochgeladen vonMark Chow Khoon Keat
- Data Structure.pptxHochgeladen vonMuhammad Ali
- Elementary Data TypesHochgeladen vonhammaddon
- Tut 5Hochgeladen vonhamaranewton
- Generic Ethernet Ip Explicit sHochgeladen vonroomel
- L1 AnalysisHochgeladen vonPeleira Nicholas Zulu
- -2b. AsymptoticAnalysisHochgeladen vonAdnan Khan
- Lec_2.1Hochgeladen vonnouraiz
- 220handout-lecture04Hochgeladen vonSridhar Chandrasekar
- Intro AlgoHochgeladen vonRavi Stephen
- CSE373Hochgeladen vonkhoalan
- ArraysHochgeladen vonPramote Kuacharoen
- AA Formulas 24Jan19Hochgeladen vonLuis Alberto Garnica López
- 23.Computer ApplicationHochgeladen vonrajchawla
- 1001_SDR_gsm_radio_20190618113905Hochgeladen vonNguyen Quang Khai
- PHPExcel Function Reference developer documentation.odtHochgeladen vonnoel2018
- Read FileHochgeladen vonaaronpham
- Lists in Unicode SystemsHochgeladen vonAlyDeden
- maaxHochgeladen voncalimaax
- C++ Variable TypesHochgeladen vonhimanshu
- MPLAB XC8 C Compiler User s Guide 1 2Hochgeladen vonarjun raj

- Banking ManagementHochgeladen vonSasi Devi Ramakrishnan
- eng_58101_52_1314bHochgeladen vonAnonymous xdetBXSaot
- Gk Power Capsule Dec 2013Hochgeladen vonJames Parker
- Basel IIIHochgeladen vong24uall
- cmcpsHochgeladen vong24uall
- List of Confused English Spellings Gr8AmbitionZHochgeladen vonsandeepkottem
- Job Description CS Final OnlineHochgeladen vong24uall
- Chhattisgarh PcsHochgeladen vonmonurahul
- IBPS EXAMHochgeladen vonSeema Panmand
- Newly Elected Chief Ministers of India, Recently Elected Chief Ministers of India _ Banking AwarenessHochgeladen vong24uall
- 1356947482.9353caiibgbmmarketingmngtmodule_d.pptHochgeladen vonNicholas Ward
- Interview Capsule Ibps Po IIIHochgeladen vonganeshsingh1
- Gr8AmbitionZHochgeladen vong24uall
- Examination 05122013Hochgeladen vong24uall
- GA_13_SEPT_2013_to_20_NOV_2013Hochgeladen vong24uall
- NMDC Employment Notification 10x22 With Skill SetHochgeladen vonNaresh
- NOTICE FOR RE_EXAMINATION 28112013.pdfHochgeladen vong24uall
- Council of Ministers,List of Ministers of India, List of Minister’s Portfolios _ Banking Awareness.pdfHochgeladen vong24uall
- Sbh Mgmt Exec Advertisement EngHochgeladen vonScore1234
- IBPS CLERK NOTIFICATION 2013Hochgeladen vonscang55
- 2013-14 Indian Union General Budget - HighlightsHochgeladen vonkayalontheweb
- New Microsoft Office Word DocumentHochgeladen vong24uall
- KPO-Prospectus 2013 (1)Hochgeladen vonBineet Kumar Varma
- Ibps Clerk 3 Gk CapsuleHochgeladen vonganeshsingh1
- General Awareness Study Material for IBPS Clerk Exam Www.bankingawareness.comHochgeladen vong24uall
- Think-Feel-Live.pdfHochgeladen vong24uall
- NICL AO Recruitment of Admin Officers 2013Hochgeladen vong24uall

- CSI-2110-summary.pdfHochgeladen vonjohn
- BINARY AND HEXADECIMAL NUMBER SYSTEMHochgeladen vonkaran007_m
- Core Java MeterialHochgeladen vonPravallika Repana
- Assignment ProblemHochgeladen vonmanisa1992
- Small DataHochgeladen vonAnonymous ZS0ZWi4K7
- The Barzilai and Borwein Gradient Method for TheHochgeladen vonRaymath Ben
- KnapsackHochgeladen vonskimdad
- COMPUTER PROGRAMMING (TMK 3102) LECTURE NOTES 3Hochgeladen vonmamat88
- 117AN - ARTIFICIAL INTELLIGENCE.pdfHochgeladen vonvenkiscribd444
- BDDHochgeladen vonnasheetat
- Study Island Practice 14 Relations and FunctionsHochgeladen vonمحمد أحمد عبدالوهاب محمد
- 16 Mark Questions PCD & MPHochgeladen vonvembu
- Introduction to JavaHochgeladen vonCiberaj Palaniyandi
- 0912 Kuliah 12 MatrixHochgeladen vonfellando
- SLM-Unit-05-MB0048Hochgeladen vonPankaj Kumar
- Major programming paradigms.pdfHochgeladen vonMaxwell Smith
- Introduction to AutomataHochgeladen vonal_badwi
- Gray Code - Algorithm in Matlab Bin_dec ConversionsHochgeladen vonrakeluv
- Improvement And Experimental Evaluation BellmanFord AlgorithmHochgeladen vonMahyuddin Husairi
- Nested QuantifiersHochgeladen vonMohomed Athif
- entorpuHochgeladen vonpi194043
- bt1Hochgeladen vonarvchamp
- TravellingSalesmanProblem.pdfHochgeladen vonSarah Garcia
- old paper cs402Hochgeladen vonAli Raza
- CS2208-LMHochgeladen vonVajith_Raghman_7390
- Design of 32- Point FFT Algorithm - A Literature ReviewHochgeladen vonInternational Journal for Scientific Research and Development - IJSRD
- Logic GatesHochgeladen vonApurbajyoti Bora
- Handout Preparation ModelHochgeladen vonPrasadDam
- Heuristic-search PDF PracticeHochgeladen vonPankaj Shukla
- Minimum Spanning Tree ParallelHochgeladen vonHarsh Singh