DATA STRUCTURE

AND
ALGORITHM

Dr. Irfana Memon

Department of CSE, QUEST

https://sites.google.com/a/quest.edu.pk/dr-irfana-memon/lecture-slides
1
NO TOPIC CLO
01 A General Overview CLO1
02 Introduction to Data Structures and Algorithm CLO1
03 String Processing CLO1
04 Abstract Data Types CLO1
05 Linked list CLO1
06 Stack and Queue CLO1
07 Recursion CLO1
08 Complexity Analysis CLO2
09 Sorting and Searching techniques CLO2
10 Trees CLO2
11 Graph CLO3
12 P & NP CLO3

2
String Processing

3
• Computer terminology usually uses the term “string” for
a sequence of characters rather than the term “word”.
• Therefore, many texts sometimes use the expression”
string processing” instead of “word processing”
• This chapter discusses how such data are stored and
processed by the computer.
• Each programming language contains character set that is used
to communicate with the computer. The usually indicates the
following:

• Alphabet: A,B,C,D…..,Z
• Digits: 0,1,2,3,4,5,6,7,8,9
• Characters: +, -, /, *, ^, &, %, = etc.

• A finite sequence of 0 or more characters is called a string.

• The number of characters in a string is called its length.
• The string with zero characters is called empty string or null
string.
• Specific string will be denoted by enclosing their characters in
single quotation marks.
• Strings are stored in three types of structures:
(1) fixed-length structures
(2) variable-length structures with fixed maximum
(3) linked structures
1. Fixed-Length Storage

• Record-Oriented
In fixed-length storage each line of print is viewed as a record,
where all records have the same length, i.e. each record
accommodate the same number of characters. Assume our
record has length 80 unless otherwise stated.
• Suppose the input consists of a program. Using a record-
oriented, fixed length storage medium, the input data will
appear in memory.
1. Fixed-Length Storage (Advantages and
Disadvantages)

• Advantages
– The ease of accessing data from any given record
– The ease of updating data in any given record (as long as the
length of the new data does not exceed the record length)
• Disadvantages
– Time is wasted reading an entire record if most of the storage
consists of blank spaces.
– Certain records may require more space than available.
– When the correction consists of more or fewer characters than
the original text, changing a misspelled word requires the entire
record to be changed.
2. Variable-Length Storage with Fixed Maximum

• Although string may be stored in fixed-length memory location

as above, there are advantages in knowing the actual length of
each string; one does not have to read the entire record when the
string occupies only the beginning part of the memory location.

• The storage of variable-length strings in memory cells with fixed

lengths can be done in two general ways:
1. One can use a marker that is two $$ signs, to signal the end of
the string.
2. One can list the length of the string as an additional item in
the pointer array .
3. Linked Storage

• Computer must be able to correct and modify the printed

matter, which usually means deleting, changing, and inserting
words, phrases, sentences and even paragraphs in the text.
• The fixed-length memory cells do not easily lend themselves to
these operations. For this reason strings are stored by means
of linked lists.
• String may be used in a linked list as follows.
• Each memory cell is assigned one character or a fixed number
of characters, and a link contained in the cell gives the address
of the cell containing the next character or group of characters
in the string.
• Constant
- String constant are placed in either single or double quotation
e.g., “Computer Systems”

• Variable
- Static variable: Length is defined before the program is
executed and can not change throughout the program.

- SemiStatic variable: Length may vary during the execution of

program until maximum limit which is defined before the
execution of program.

- Dynamic variable: Length may vary during the execution of

program.
• Substring ( substr(pos,len))
– Accessing a substring form a given string requires two piece of
information.
1. The position of the first character of the substring,
2.The length of the substring.

• Indexing (find())
– Indexing refers to finding the location of the string.

• Concatenation (concat(string1,string2))
– String concatenation is the operation of joining two character
strings end to end. For example, the strings "snow" and "ball" may
be concatenated to give "snowball".

• Length( length(), size())

– The number of characters in the string is called the length or
size of string.
The operations usually associated with word processing are:

– Replacement
• Replacing one string in the text by another i.e., replace(pos1,
len1,string, pos2, len2)

– Insertion
• Inserting a string in the middle of the text insert()

– Deletion
• Deleting a string from the text. Erase( position-FirstChar, length)
• Given strings T (text) and P (pattern), the pattern matching
problem consists of finding a substring of T equal to P.
• T: “the rain in spain stays mainly on the plain”
• P: “n th”
• We assume that the length of pattern does not exceed the
length of text.
• Applications:
– Text editors
– Web search engines (e.g. Google)
 The Brute Force Algorithm

• P and T are strings with length R and S, respectively, and are

stored as array with one character per element. The algorithm
finds the Index of P in T.
1. [Initialize] Set K= 1 and MAX=S-R+1
2. Repeat Step 3 to 5 while K<=MAX
3. Repeat for L=1 to R : [Test each character of P]
If P[L]!= T[K+L-1], then: Go to step 5.
[End of inner loop]
4. [Success] Set INDEX=K, and Exit
5. Set K=K+1
[End of Step 2 outer loop]
6. [Failure] Set INDEX=0
7. Exit.
 The Brute Force Algorithm
• The first pattern matching algorithm is the one in which we
compare a given pattern P with each of the substring of T, moving
from left to right, until we get a match.
• Let Wk denote the substring of T having the same length as P and
beginning with the Kth character of Wk=
Substring(T,K,LENGTH(P))
• First we compare P, character by character, with first substring
W1
• If all the characters are the same, then P= W1 and so P appears
in T and Index(T,P)=1.
• If some characters of p is not the same as corresponding
character W1
Then P is not equal to W1 and we can move on to the next
substring W2
 The Brute Force Algorithm
• The process stops when we find the match of P with some
substring Wk and so P appears in T and Index(T,P)=K, or We
exhaust all the Wk with no match that means P does not appear in
T.
• The maximum value of substring K is equal to Length(T)-
Length(P) +1.
 The Brute Force Algorithm

• P and T are strings with length R and S, respectively, and are

stored as array with one character per element. The algorithm
finds the Index of P in T.
1. [Initialize] Set K= 1 and MAX=S-R+1
2. Repeat Step 3 to 5 while K<=MAX
3. Repeat for L=1 to R : [Test each character of P]
If P[L]!= T[K+L-1], then: Go to step 5.
[End of inner loop]
4. [Success] Set INDEX=K, and Exit
5. Set K=K+1
[End of Step 2 outer loop]
6. [Failure] Set INDEX=0
7. Exit.

Draw Flow chart for the above algorithm

 The Brute Force Algorithm (Analysis)
• Brute force pattern matching runs in time O(mn) in the worst
case.
• But most searches of ordinary text take O(m+n), which is very
quick.
• Example of a worst case:
– T: "aaaaaaaaaaaaaaaaaaaaaaaaaah"
– P: "aaah"
• Example of a more average case:
– T: "a string searching example is standard"
–P: “string"
More efficient algorithms utilize information from previous
comparisons.
1. A text T and a pattern P are stored as array with one character
per element. Write algorithm and draw flow chart that deletes
every occurrence of P in T.
1. A text T and a pattern P are stored as array with one character
per element. Write algorithm and draw flow chart that deletes
every occurrence of P in T.

1. [find index of P] Set K:= INDEX(T,P)

2. Repeat while K!= 0
(a) [delete P from T]
Set T:= DELETE(T,INDEX(T,P), LENGTH(P))
(b) [Update index] Set K:= INDEX (T,P)
[End of loop]
3. Write: T
4. Exit.
1. A text T and a pattern P are stored as array with one character
per element. Write algorithm and draw flow chart that deletes
every occurrence of P in T.

1. [find index of P] Set K:= INDEX(T,P)

2. Repeat while K!= 0
(a) [delete P from T]
Set T:= DELETE(T,INDEX(T,P), LENGTH(P))
(b) [Update index] Set K:= INDEX (T,P)
[End of loop]
3. Write: T
4. Exit.

Draw Flow chart for the above algorithm

2. A text T and a pattern P are stored as array with one character
per element. Write algorithm and draw flow chart that replaces
every occurrence of P in T by Q.
2. A text T and a pattern P are stored as array with one character per element.
Write algorithm and draw flow chart that replaces every occurrence of P in T by Q.

T = each
P=a
Q= e
S= Length of T
R = Length of P
2. A text T and a pattern P are stored as array with one character per element.
Write algorithm and draw flow chart that replaces every occurrence of P in T by Q.
[find index of T where pattern P start ]

T = each
P=a
Q= e
S= Length of T
R = Length of P
2. A text T and a pattern P are stored as array with one character per element.
Write algorithm and draw flow chart that replaces every occurrence of P in T by Q.
[find index of T where pattern P start ]
1. Set K=K+1 [Initialize] Set K= 1 and MAX=S-R+1
2. Repeat Step 3 to 5 while K<=MAX
3. Repeat for L=1 to R : [Test each character of P]
If P[L]!= T[K+L-1], then: Go to step 5.
[End of inner loop]
4. [Success] Set INDEX=K, and Goto step 7

[End of Step 2 outer loop]

6. [Failure] Set INDEX=0 Goto step 11

T = each
P=a
Q= e
S= Length of T
R = Length of P
2. A text T and a pattern P are stored as array with one character per element.
Write algorithm and draw flow chart that replaces every occurrence of P in T by Q.
[find index of P]
1. [Initialize] Set K= 1 and MAX=S-R+1
2. Repeat Step 3 to 5 while K<=MAX
3. Repeat for L=1 to R : [Test each character of P]
If P[L]!= T[K+L-1], then: Go to step 5.
[End of inner loop]
4. [Success] Set INDEX=K, and Goto step 7
5. Set K=K+1
[End of Step 2 outer loop]
6. [Failure] Set INDEX=0 Goto step 11
7. Set M=1
[Loop for Replace P by Q] T = each
8. Repeat step 9 to 10 while M<=R P=a
Q= e
9. Set T[INDEX]=Q[M]
S= Length of T
10. INDEX=INDEX+1 and M=M+1 R = Length of P
11. Exit.
 Wish
You
Good Luck

28