8/7/2019 DS_Doc

1/14

LINEAR SEARCH

START LOCATION= -1READ THE ARRAY A[MAX]

ENTER THE VALUE TO BE SEARCHED, M

I= 1DO WHILE I

8/7/2019 DS_Doc

2/14

INSERTION SORT

FOR I =1 TO N-1TEMP = A[I] //FIRST ELEMENT OF UNSORTED PART

J = I-1 // LAST EMEMENT OF SORTED PART

WHILE (TEMP=0)A[J+1] = A[J]

J=J-1

END WHILEA[J+1] = TEMP

END FOR

PRINT THE LIST

BUBBLE SORTC = 1

DO WHILE (C

8/7/2019 DS_Doc

3/14

QUICK SORT

Q_SORT(ARR, FIRST, LAST)LOW=FIRST,HIGH = LAST, PIVOT = ARR[(LOW+HIGH)/2]

DO WHILE (LOW PIVOT)

LOW = LOW+1

END DO

DO WHILE (ARR[HIGH] > PIVOT)

HIGH = HIGH 1END DO

IF LOW

8/7/2019 DS_Doc

4/14

IF (A>B)

FOR(D = C TO HIGH ), DOFIND[B] = LIST[D]

B = B +1

END FORELSE

FOR(D = A TO MID ), DO

FIND[B] = LIST[D]B = B+1

END FOR

END IF

SHELL SORT

S_SORT( ARR, SIZE)

ARR -> REPRESENTS THE LIST OF ELEMENTSSIZE-> RWPRESENTS THE SIZE OF THE LIST

INITIALIZE THE GAP = GAP/2DO WHILE GAP = GAP/2

SWAP = 0

DO WHILE (SWAP)FOR I = 1 TO SIZE GAP, DO

IF(ARR[I] > ARR[I+1])

TEMP = ARR[I]

ARR[I] = ARR[I+1]ARR[I+1] = TEMP

SWAP = 1END IF

END FOR

END OF DO

END OF DO

RADIX SORT

Step 1 : larg = Large (rec)

m = num (larg)

Step 2: Repeat through step 5 for j = 0,1,2,..,m

Step 3: Repeat for I = 0,1,2,,9

pocket [i] = NULLpocket1[i] = NULL

Step 4: r = recrepeat while r NULL

8/7/2019 DS_Doc

5/14

dig = digit (link [r], j)

Update (dig, r)

nex = link [r]r = nex

if (r NULL)

dig = digit (link[r], j)Update(dig, r)

Step 5: poc = 0Repeat while pocket1[poc] = NULL

poc = poc + 1

rec = Make_link (poc, rec)

Step 6: Return

ALGORITHM TO IMPLEMENT A STACK USING SINGLY LINKED LIST.

Procedure: Push an element into the stack.

1. [Check overflow condition]

If Stk = NULL

Output Overflow and exit.

2. [Remove first node from stk lit]

Set new = Stk

Stk = link[Stk]

3. [Copy item into new node]

Set info[new] = item

4. [New node points to the original top node in the stack]Set link[new] = top

5. [Reset top to point to the new node at the top of the stack]

Set top = new

6. Exit.

Procedure: Pop an element from the stack.

1. [Checks underflow condition]

If top = NULL

Output Underflow and return.

2. [Copy the top elementof stack into item]

Set item = info[top]

3. [Assign old top value to temp and reset top pointer]

temp = top

top = link[top]

4. [Return deleted node to the Stk list]

8/7/2019 DS_Doc

6/14

Set link[temp] = Stk

Stk = temp

5. Return.

ALGORITHM TO IMPLEMENT A QUEUE USING

ARRAYS

Procedure : Insert an element in the queue

if (rear >= size) // [check overflow condition]

print OVERFLOW and exitelse

rear = rear + 1

Q[rear = value] // insert an element

If (front = 0) //set front pointerFront = 1

End if

Return

Procedure : Delete an element from the queue

If (front = 0) // check underflow condition

Print UNDERFLOW and exit

ElseValue = Q[front]

If (front = rear) //check for empty queue

Front = 0Rear = 0Else

Front = front +1

End ifEnd if

Return

DequeALGORITHM TO IMPLEMENT A QUEUE USING ARRAYS.

Procedure: Insert an element in the queue.

1. [Check overflow condition]

If rear >= size

Output Overflow and exit.

2. [Increment rear pointer]

rear = rear+1

3. [Insert an element]

8/7/2019 DS_Doc

7/14

Q[rear] = value

4. [Set the front pointer]

If front = 0

front=1

Return.

Procedure: Delete an element from the queue.

1. [Check underflow condition]

If front = 0

Output Underflow and return.

2. [Remove an element]

value = Q[front]

3. [Check for empty queue]

If front = rear

front = 0

rear = 0

ElseFront = front+1

4. Return.

IMPLEMENT SINGLE LINKED LIST

//Add an element to the head of the linkded listprocedure AddTohead (element)

head = new Node (element, head)

if (not the Tail)

Tail = head

End if

End procedure

// Add an element to the tail of the linked listprocedure AddToTail (element)

if (this is the Tail)

Tail -> next = new Node (element)

Tail = Tail-> nextEnd if

Else head = Tail = new Node (element)

End procedure

// Remove an element from the head of the linked listprocedure RemoveFromHead () : integer

if (this is the Head)

element = head ->info

temp = head

if (this is the last item in the list)

Break pointer connection between head and tail to terminate list

Else

Set = head->next = next item in the listEnd if

Release temp from memory pool

8/7/2019 DS_Doc

8/14

Return element

Else

Return 0

End if

End procedure

// Remove an element from the tail of the linked listprocedure RemoveFromTail () : integerif (this is the Tail)

element = Tail->info

if (this is the last item in the Tail)

Break pointer connection between head and Tail to terminate list

Release head from memory pool

Else

Traverse list until we reach the Tail

Release Tail from the listSet Tail pointer to previous element if previous element exist

Set Tail pointer to next to nullEnd if

Return element

Else

Return 0

End if

End procedure

ALGORITHM :IMPLEMENT SINGLY LINKED LIST

//Add an element to the start of the linked list

procedure AddToHead(element)

head = new Node(element, head)

if(not the Tail)

tail = head

end if

end procedure

// Add an element to the tail of the linked list

procedure AddToTail(element)

if(this is the Tail)

tail->next = new Node(el)

tail = tail->next

endif

else head = tail = new Node(el)

end procedure

// Remove an element from the head of the linked list

procedure RemoveFromHead():integer

if(this is the Head)

element = head->info

temp = head

if(this is the last item in the list)

Break pointer connection between head and tail to

terminate list

else

8/7/2019 DS_Doc

9/14

set head.next to equal next item in list

end if

release temp from from memory pool

return element

else

return 0

end if

end procedure

// Remove an element from the tail of the linked list

procedure RemoveFromTail():integer

if(this is the Tail)

element = tail->info

if(this is the last item in the list)

Break pointer connection between head and tail to terminate

list release head from memory pool.

else

Traverse list until you reach the tail release tail from

memory pool

set tail pointer to previous element if one exists settail's pointer to next element to null.

end if

return element

else

return 0

end if

end procedure

ALGORITHM TO IMPLEMENT A QUEUE USING SINGLY LINKED LIST

Procedure: Insert an element into the queue.

1. [Check overflow condition]If Q = NULL

Output Overflow and return

2. [Remove first node from Q list]

Set new= Q

Q = link[Q]

3. [Copy item into new node]

info[nwew] = item

link[new] = NULL

4. [If Q is empty then item is the first element in the queue Q]

If (front = NULL)

Front = rear = new

Else

Set link[rear] = new

rear = new

5. Exit.

Procedure: Delete an element from the queue.

8/7/2019 DS_Doc

10/14

1. [Check underflow condition]

If (front = NULL)

Output Underflow and return.

2. [If Q nonempty, copy front in temp]

Set temp = front

item=info[temp]

3. [Reset front to point to the next element in the Q]

front = link[temp]

4. [Return the deleted node temp to the list Q]

link[temp] = Q

Q = temp

5. Exit.

IMPLEMENT DOUBLY LIST

//Add an element after specified position in the listprocedure insertAfter (List list, Node node, Node newNode)

newNode->prev = node

newNode->next = node->next

if (node->next = NULL)list->lastNode

else

node->next = newNodenode->next = newNode

//Add an element before specified position in the linked list

procedure insertBefore (List list, Node node, Node newNode)

newNode->prev = node->prev

newNode->next = nodeif (node->prev = NULL)

list->firstNode = newNode

elsenode->prev->next = newNode

node->prev = newNode

//Add an element to the start of the linked list

procedure insetrtBeginning (List list, Node node, Node newNode)if (list->firstNode = NULL)

list->firstNode = newNode

list->lastNode = newNode

newNode->prev = NULLnewNode->next = NULL

else

8/7/2019 DS_Doc

11/14

insert (list, list->firstNode, newNode)

//add an element to the end of the linked list

procedure insertEnd (List list, Node newNode)

if (list->lastNode = NULL)insertBeginning (list, newNode)

else

insertAfter (list, list->lastNode, newNode)

ALGORITHM : IMPLEMENT DOUBLY LINKED LIST

//Add an element after specified position in the linked list

procedure insertAfter(List list, Node node, Node newNode)

newNode.prev := node

newNode.next := node.next

if node.next = nulllist.lastNode := newNode

else

node.next.prev := newNode

node.next := newNode

//Add an element before specified position in the linked list

procedure insertBefore(List list, Node node, Node newNode)

newNode.prev := node.prev

newNode.next := node

if node.prev is null

list.firstNode := newNode

else

node.prev.next := newNode

node.prev := newNode

//Add an element to the start of the linked list

procedure insertBeginning(List list, Node newNode)

if list.firstNode = null

list.firstNode := newNode

list.lastNode := newNode

newNode.prev := null

newNode.next := null

else

insertBefore(list, list.firstNode, newNode)

//Add an element to the end of the linked list

procedure insertEnd(List list, Node newNode)

if list.lastNode = null

insertBeginning(list, newNode)

else

insertAfter(list, list.lastNode, newNode)

8/7/2019 DS_Doc

12/14

// Remove an element from the linked list

procedure remove(List list, Node node)

if node.prev = null

list.firstNode := node.next

else

node.prev.next := node.next

if node.next = null

list.lastNode := node.prev

else

node.next.prev := node.prev

destroy node

ALGORITHM TO CONVERT INFIX EXPRESSION TO POSTFIX FORM.

1. Initialize the stack.

2. Scan the leftmost symbol in the given infix expression and

denote it as current input symbol.

3. Repeat through step 6 while infix expression.

4. Remove and output all stack symbols whose precedence values

are greater than or equal to the precedence of the current input

symbol.

5. Push the current input symbols onto the stack.

6. Scan the leftmost symbol in the infix expression and let it be

the current input symbol.

ALGORITHM TO CONVERT INFIX EXPRESSION TO POSTFIX FORM

1. Initialize the stack

2. Scan the leftmost symbol in the given infix expression and denote it as

current input symbol.

3. Repeat through step 6 while infix expression.

4. Remove and output all stack symbols whose precedence values are

greater than or equal to the precedence of the current input symbol.

5. Push the current input symbols onto the stack.

6. Scan the leftmost symbol in the infix expression and let it be the

current input symbol.

ALGORITHM TO EVALUATE THE POSTFIX EXPRESSION.

1. Add a right paranthesis ) at the end of P.

2. Scan P from left to right and repeat steps 3 and 4 for each element

of P until the sentinel ) is encountered.

8/7/2019 DS_Doc

13/14

3. If an operand is encountered, put it on STACK.

4. If an operator x is encountered , then:

a) Remove the two top elements of STACK, where A is the top

element and B is the next-to-top element.

b) Evaluate B x A.

5. Place the result of (b) back on Stack.

6. Set Value equal to the top element on STACK.

7. Exit.

ALGORITHM TO EVALUATE THE POSTFIX EXPRESSION

1. Add a right parenthesis ) at the end of P

2. Scan P from left to right and repeat steps 3 and 4 for each element of P untilthe sentinel ) is encountered.

3. If an operand is encountered, put it on STACK.

4. If an operator X is encountered, then :remove the two top elements of stack and perform the operation X

5. Place the evaluated result back on the STACK

6. Set value equal to the top element on STACK

7. Exit

BFS

Input :V, the starting vertexOutput : A list VISIT giving the order of visit of vertices during traversal

Data Structure : linked structure of graph . gptr is the pointer to a Graph.

Steps :

If gptr = NULL thenPrint graph is empty and exit

Else

u = v // starts from v

open.ENQUENE (u) enter the starting vertex in openqwhile (openq.STATUS != EMPTY) // till the openq is not empty

u = openq.DEQUENE ()

if (SEARCH_SL_(VISIT, u) = FALSE) then //if u is not VISIT

// then VISIT itINSERT_SL_END (VISIT, u) // store u in VISIT

ptr = GPTR[u]while (ptr.link!= NULL) do // to store all the adjacent

//vertices of V in openq

vptr = ptr.linkopenq.ENQUENE (vptr.LABEL)

end while

8/7/2019 DS_Doc

14/14

end if

end while

end ifreturn (VISIT)

Stop

DFS

Input : v, the starting vertex

Output : A list VISIT giving the order of visit of vertices during Traversal

Data Structure : linked structure of graph. GPTR is the pointer to a Graph

Steps:

1 if GPTR = NULL

1 print GRAPH IS EMPTY

2 EXIT2 end if

3 u = v //start from V4 open.push (u)//push the starting vertex in OPEN

5 while (Open.Top!= NULL) //till the stack is not empty

1 u = Open.pop () //pop the top element from Open

2 if (SEARCH_SL_END (VISIT, u) = FALSE) then //if u is not visited

1 INSERT_SL_END (VISIT , u) //Store u in VISIT

2 Ptr = GPTR [u] //To push all adjacent vertices of u into

stack

3 While (ptr.link!=NULL) dovptr = ptr.linkOpen.push (vptr.LABLE)

4 end while

3 end if 6 End while

7 Return (VISIT)

8 STOP