0 valutazioniIl 0% ha trovato utile questo documento (0 voti)
60 visualizzazioni28 pagine
The document provides an introduction to data structures and algorithms. It defines primitive data types, abstract data types (ADTs), and data structures. Linear data structures like arrays, stacks, and queues are discussed as well as nonlinear structures like trees and graphs. Algorithms are defined as step-by-step procedures to solve problems. Big-O notation is introduced to analyze algorithm efficiency. Specific data structures like arrays and linked lists are then described in more detail, including their operations and implementations.
The document provides an introduction to data structures and algorithms. It defines primitive data types, abstract data types (ADTs), and data structures. Linear data structures like arrays, stacks, and queues are discussed as well as nonlinear structures like trees and graphs. Algorithms are defined as step-by-step procedures to solve problems. Big-O notation is introduced to analyze algorithm efficiency. Specific data structures like arrays and linked lists are then described in more detail, including their operations and implementations.
The document provides an introduction to data structures and algorithms. It defines primitive data types, abstract data types (ADTs), and data structures. Linear data structures like arrays, stacks, and queues are discussed as well as nonlinear structures like trees and graphs. Algorithms are defined as step-by-step procedures to solve problems. Big-O notation is introduced to analyze algorithm efficiency. Specific data structures like arrays and linked lists are then described in more detail, including their operations and implementations.
Pratheepan Data Structure and Algorithm ATI-Trincomalee
1
1. Introduction to Data Structure and Algorithm
Primitive Data Types: Primitive Data Types are basic data types of a programming language. These refer to two things: a data item with certain characteristics and the permissible operations on that data. For example, The operations + (addition), - (subtraction), * (multiplication), / (division) can be applied to the primitive data types integer and float. The operations && (and), || (or), ! (not) can be applied to the primitive data type boolean.
Abstract Data Types (ADT): ADT is a specification of a mathematical set of data and the set of operations that can be performed on the data. The set of operations that define an ADT is referred to as its interface. ADTfocuses on what it does and ignores how it does its job.That is,ADT is independent of any particular implementation. Eg: 1. stack (last-in-first-out) Push(5) Pop()
Data Structures: Data structure is the arrangement of data in a computer memory/storage. Data structure is the implementation of ADT such as stack, queue, linked list, tree, graph. When working with certain data structures we need to know how to insert new data, how to search for a specific item, and how to delete a specific item. Data structure helps for efficient programming. Data structure reduces complexity of the program and its calculations. There are two types of data structures: Linear data structure and Nonlinear data structure
Linear and Nonlinear Data Structures: Linear Data Structure Nonlinear Data Structure Data Organized Sequentially (one after the other) Data organized non sequentially Easy to implement because the computer memory is also organized as linear fashion Difficult to implement E.g: Array, Stack, Queue, Linked List E.g: Tree, Graph
What is Algorithm? An algorithm is a step by step procedure for solving a problem in a finite amount of time. Many algorithms apply directly to a specific data structures.
Efficiency of an Algorithm: Some algorithms are more efficient than others. We would prefer to choose an efficient algorithm. Running time of algorithms typically depends on the input set, and its size(n).
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 2
Big O Notation: We can say that a function is of the order of n", which can be written as O(n) to describe the upper bound on the number of operations. This is called Big-Oh notation. Some common orders are: O(1) constant (the size of n has no effect) O(log n) logarithmic O(n log n) O(n) O(n 2 ) quadratic O(n 3 ) cubic O(2 n ) exponential If the number of operations is 500, then the big O notation is O(1). If the number of operations is 9n + 200, then the big O notation is O(n). If the number of operations is n 3 + 3n + 8,then the big O notation is O(n 3 ). Generally we can take O(1) is faster than O(n) and O(n) is faster than O(n 3 ).
Best, Worst and Average Cases: Best case efficiency is the minimum number of steps that an algorithm can take any collection of data values. Worst case efficiency is the maximum number of steps that an algorithm can take for any collection of data values. Average case efficiency is the efficiency averaged on all possible inputs must assume a distribution of the input is normally assumed for uniform distribution (all keys are equally probable) For example, when we search for an element in a list sequentially, In best case, the cost is 1 compare. That is O(1). In worst case, the cost is n compares. That is O(n). In the average case, the cost may be (n+1)/2. That is O(n).
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 3
2. Array Data Structure
What is an array? Arrays are a group of continuous similar type of variables referred by a common name. In C++, array can be declared and used as follows: 0 1 2 3 4 intnum[5]; num
0 1 2 3 4 num[2]=3; num 3
0 1 2 3 4 num[4]=2*num[2]; num 6
cout<<num[4]+num[2]; 9
A program to store and print elements in an array: #include<iostream.h> #include<conio.h> void main() { int i; char keys[6]={'Q','W','E','R','T','Y'}; cout<<"The first 6 keys of a keyboard are "; for (i=0; i<=5; i++) cout<<keys[i]<<" "; }
A program to search and replace an element in an array: #include<iostream.h> #include<conio.h> void main() { int i; char s,r; int found=0; //found=false char keys[6]={'Q','W','E','R','T','Y'}; cout<<"Enter a character to be searched: "; cin>>s; cout<<"Enter a character to replace: "; cin>>r; i= (-1); while (i<5 && found==0) if (keys[++i]==s) found=1; if (found==1) keys[i]=r; else cout<<"No such element."; }
A program to delete an elementfrom an array: Actually we cant delete an element from an array. If we want to delete an element, we have to move all the subsequent elements forward. Or otherwise we can replace the element with invalid values (e.g.: 0 or NULL).
#include<iostream.h> #include<conio.h> void main() { int i; char d; J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 4
int found=0; //found=false char keys[6]={'Q','W','E','R','T','Y'}; cout<<"Enter a character to be deleted: "; cin>>d; i= (-1); while (i<5 && found==0) if (keys[++i]==d) found=1; if (found==1) keys[i]=NULL; else cout<<"No such element." }
Multi-Dimensional Array: Multi-dimensional array can be considered as an array of arrays. For example a two dimensional array may look like as follows: table 0 1 2 3 4 5 6 0
0 1 2 3 4 5 6 1 This location can be referred to as table[1][5]
0 1 2 3 4 5 6 2
Or simply we can imagine a two dimensional array as follows:
table 0 1 2 3 4 5 6 0 1 This location can be referred to as table[1][5] 2
A program to store and print elements in a two dimensional array: #include<iostream.h> #include<conio.h> void main() { Int i,j; clrscr(); int matrix[3][4]={{5,3,6,4},{2,5,3,7},{3,6,5,8}}; cout<<"The elements of the array are"; for (i=0; i<3; i++) { for (j=0; j<4; j++) cout<<matrix[i][j]<<"\t"; cout<<"\n"; } }
Advantages of arrays: Fast access if index is known Easy to add an element in a particular location.
Disadvantages of arrays: Fixed size Same data type Slow in searching an element Slow in inserting/deleting an element J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 5
3. Linked List Data Structure
What is Pointer? Pointer contains memory address of a particular type of data. In C++, we use * to declare a pointer. 2cdf 1a5c c75c int p; int* iptr; char* cptr; p iptr 1a5c cptr c75c
p = 9; *iptr = 5; *cptr=$; p 9 iptr 5 cptr $ t # /0
cout<<p; cout<<iptr; cout<<cptr; 9 1a5c $t#
cout<<&p; cout<<*iptr;cout<<*cptr; 2cdf 5 $ 2cdf 1a5c iptr = &p; p 9 iptr 2cdf 5 cptr $ t # /0
What is Linked List? A linked list consists of nodes of data which are connected to other nodes. There are several types of linked lists.
E.g1:
d a t a
n e x t
d a t a
n e x t
d a t a
n e x t
d a t a
n e x t
head 5 9 6 7 /
E.g2: head
d a t a
n e x t
d a t a
n e x t
d a t a
n e x t
d a t a
n e x t
front 5 9 6 7 / rear
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 6
E.g3:
p r e v i o u s
d a t a
n e x t
p r e v i o u s
d a t a
n e x t
p r e v i o u s
d a t a
n e x t
p r e v i o u s
d a t a
n e x t
head / 5 9 6 7 /
Common operations of Linked List are: initializeList() - initializes the list as empty list. insertFirstElt(int elt) - inserts a new element into an empty list. insertAtFront(int elt) - inserts an element at the beginning of the list. insertAtEnd(int elt) - inserts an element at the end of the list (appendElt or appendNode). insertAfter(int oldElt, int newElt) - inserts an element after a specified element. deleteElt(int elt) - deletes a specified element. displayList() - displays all the elements in the list isEmpty() - returns true if the list has no elements, false otherwise. isFull() - returns false if the list is full, false otherwise.
Structural Diagramsof Linked List Operations:
1. initializeList() head /
3.insertAtFront(3)
d a t a
n e x t
head 5 /
d a t a
n e x t
newNode 3
4. insertAtEnd(8)
d a t a
n e x t
d a t a
n e x t
head 3 5
newNode 8 /
5. insertAfter(5,7)
d a t a
n e x t
d a t a
n e x t
d a t a
n e x t
head 3 5 8 /
newNode 7
2. insertFirstElt(5)
d a t a
n e x t
head 5 / J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 7
6. deleteElt(5):
d a t a
n e x t
d a t a
n e x t
d a t a
n e x t
d a t a
n e x t
head 3 5 7 8 /
Implementation of Linked List Operations: #include<iostream.h> #include<conio.h> class LinkedList { private: struct listNode { int data; listNode* next; };
listNode* head;
public: LinkedList(); void initializeList(); void insertFirstElt(int elt); void insertAtFront(int elt); void insertAtEnd(int elt); void insertAfter(int oldElt, int newElt); void deleteElt(int elt); void displayList(); int isEmpty(); int isFull(); }
Advantages of Linked List: Easy to insert and delete elements. Unlike array, memory space is not wasted in linked list.
Disadvantages of Linked List: Slow in searching.
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 10
4. Stack Data Structure What is Stack? Stack is a data structure which is used to handle data in a last-in-first-out (LIFO) method. That is we can remove the most recently added element from the stack first. Common operations of Stack are: initializeStack() initializes the stack as empty stack. push()- adds an element on top of the stack. pop()-removes and returns the top most element from the stack. topElt()-returns the top element without removing it. isEmpty() - returns true if the stack has no elements and false otherwise. isFull() - returns true if the stack is full of elements and false otherwise. displayStack() - displays all elements from top to bottom.
Graphical Representation of Stack Operation:
1. initializeStack()
2. p =isEmpty()
p = true
3. push(5)
5
4. push(7)
7 5
5. push(6)
6 7 5
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 11
6. q = isEmpty(); r = isFull();
6 7 q = false; r = false 5
7. x = pop()
7 x = 6 5
8. y = topElt()
7 y = 7 5
Static (Array based) Implementation of Stack Operations [Graphical Representation]:
1. initializeStack() 4 3 2 1 top = -1 0
2. p =isEmpty() 4 3 2 1 p = true top = -1 0
3. push(5) 4 3 2 1 top = 0 5 0
4. push(7) 4 3 2 7 1 top = 1 5 0
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 12
5. push(6) 4 3 6 2 7 1 top = 2 5 0
6. q = isEmpty(); r = isFull(); 4 3 6 2 7 1 q = false; r = false top = 2 5 0
7. x = pop() 4 3 2 7 1 x = 6 top = 1 5 0
8. y = topElt() 4 3 2 7 1 y = 7 top = 1 5 0
Static (Array based) Implementation of Stack Operations [C++ Code]:
#include<iostream.h> #include<conio.h>
const STK_SIZE=5;
class Stack { private: int top; int stk[STK_SIZE];
public: Stack(); void initializeStack(); void push(int); int pop(); int topElt(); int isEmpty(); int isFull(); void displayStack(); }
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 13
Stack::Stack() { top=(-1); }
void Stack::initializeStack() { top=(-1); }
void Stack::push(int elt) { if (top < STK_SIZE-1) stk[++top]=elt; }
int Stack::pop() { if (top > -1) return stk[top--]; else return 999; //Some invalid integer should be returned }
int Stack::topElt() { if (top > -1) return stk[top]; else return 999; //Some invalid integer should be returned }
int Stack::isEmpty() { return (top == (-1)); }
int Stack::isFull() { return (top == (STK_SIZE-1)); }
void Stack::displayStack() { int i=top; while (i>-1) { cout<<stk[i]<<endl; i--; } }
void main() { clrscr(); Stack s; s.push(5); s.push(7); s.push(6); J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 14
int x=s.pop(); s.push(9); s.displayStack(); }
Output: 9 7 5
Dynamic (Linked List based) Implementation of Stack Operations: initializeStack() - top=NULL; //Similar to initialzeList() and it is better to use top instead of head. push() - newNode->next=top; top=newNode; //Similar to insertAtFront() pop() - x=top->data; top=top->next; return x; topElt() - return top->data isEmpty() - if (top==NULL) return 1 else return 0 isFull() - return 0; //Always return false displayStack() - Similar to displayList()
Advantages of Stack: Last-in-first-out access
Disadvantages of Stack: Difficult to access other items J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 15
5. Queue Data Structure
What is Queue? Queue is a data structure which is used to handle data in a first-in-first-out (FIFO) method. That is we can remove the element which has been added earlier from the queue first. Common operations of Queue are: initializeQueue() initializes the queue as empty queue. enQueue()- adds an element at the rear of the queue. deQueue()-removes and returns the front element from the queue. frontElt()-returns the front element without removing it. isEmpty() - returns true if the queue has no elements and false otherwise. isFull() - returns true if the queue is full of elements and false otherwise. displayQueue() - displays all elements from front to rear.
Graphical Representation of Queue Operation:
1. initializeQueue()
2. p=isEmpty() p = true
3. enQueue(5) 5
4. enQueue(9) enQueue(7) 5 9 7
5. x=deQueue() 9 7 x = 5
6. enQueue(2) enQueue(6) 9 7 2 6
7. q = isFull() 9 7 2 6 q = false
8. enQueue(3) 9 7 2 6 3
9. r = isFull() y = deQueue() 7 2 6 3 r = true y = 9
Static (Array based) Implementation of Queue Operations [Graphical Representation]:
0 1 2 3 4 1. initializeQueue()
front -1 rear -1 size 0
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 16
void Queue::enQueue(int elt) { if (size < Q_SIZE) { rear=(rear+1)%Q_SIZE; que[rear]=elt; size++; } //Else cout<<Queue is full } J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 18
int Queue::deQueue() { if (size > 0) { front=(front+1)%Q_SIZE; size--; return que[front]; } else return 999; //Some invalid integer should be returned or cout<<Queue is empty }
int Queue::frontElt() { if (size>0) { return que[(front+1)%Q_SIZE]; } else return 999; //Some invalid integer should be returned or cout<<Queue is empty }
int Queue::isEmpty() { return (size == 0); }
int Queue::isFull() { return (size == Q_SIZE); }
void Queue::displayQueue() { int i=front; for (int j=1;j<=size;j++) { i=(i+1)%Q_SIZE; cout<<que[i]<<endl; } }
void main() { clrscr(); Queue q; q.enQueue(5); q.enQueue(9); q.enQueue(7); int x=q.deQueue(); q.enQueue(2); q.enQueue(6); q.enQueue(3); int y=q.deQueue(); q.displayQueue(); }
Output: 7 2 6 3 J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 19
Dynamic (Linked List based) Implementation of Queue Operations: initializeQueue() - front=NULL; //Similar to initialzeList() and it is better to use front instead of head. enQueue() - newNode->next=front; front=newNode; //Similar to insertAtFront() deQueue() - Move to the last node, get the data, remove the last node, return the data. frontElt() - Move to the last node, get the data, remove the last node, return the data. isEmpty() - if (front==NULL) return 1 else return 0 isFull() - return 0; //Always return false displayQueue() - Similar to displayList()
Advantages of Queue: First-in-first-out access
Disadvantages of Queue: Difficult to access other items
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 20
6. Tree Data Structure What is Tree? A tree is a widely-used data structure that emulates a hierarchical tree structure with a set of linked nodes. A rooted tree has a distinguished node called root.
Some Terms related to Trees: 1. Root, parent, child, sibling, leaf Every child node has a unique parent. Every parent node can have any number of children (including none). There is one unique node in every tree which has no parent and is called the root of the tree. An internal node has one or more children. A leaf node has no children. Nodes with the same parent are called siblings.
2. Size, depth, height and level The size of a tree is the number of nodes that it contains. The depth of a node is the number of edges from the root to the node. The height of a tree is the largest depth of any of its nodes. Size=9 Height=4
3. Degree The degree of a node is the number of its children. The degree of a tree is the maximum degree of any of its nodes.
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 21
4. Path Path between two nodes in a tree is a sequence of edges which connect those nodes. Path from F to C is (FB, BD, DC)
Special Types of Trees: 1. Binary Tree: A binary tree is a rooted tree in which no node can have more than two children, and the children are distinguished as left and right. A full binary tree is a tree in which every node other than the leaves has two children. A complete binary tree is a binary tree, which is completely filled, with the possible exception of the bottom level, which is filled from left to right. A perfect binary tree is a binary tree with all leaf nodes at the same depth. All internal nodes have degree 2.
2. Binary Search Tree: It is a binary tree such that for every node N in the tree: All keys in N's left sub tree are less than the key in N, and All keys in N's right sub tree are greater than the key in N. Note: if duplicate keys are allowed, then nodes with values that are equal to the key in node N can be either in N's left sub tree or in its right sub tree (but not both). In these notes, we will assume that duplicates are not allowed. Example: Inserting 21, 6, 41, 45, 50, 55, 57, 40, 50, 15, 20, 30 in a BST.
3. AVL (Adelson Velsky Landis) Tree: It is a binary search tree such that no node that has sub trees differing in height by more than 1. Example: Inserting 21, 6, 41, 45, 50, 55, 57, 40, 50, 15, 20, 30 in an AVL tree.
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 22
Implementation of Binary Tree: 6
4 8
/ 2 / 5 / / 7 / / 9 /
/ 3 /
Advantages of Binary Tree: Quick search, Quick inserts, Quick deletes (If the tree remains balanced)
Disadvantages of Binary Tree: Deletion algorithm is complex J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 23
7. Sorting Algorithms
What is sorting? Arranging items in ascending or descending order is called as sorting. There are different types of sorting techniques each of which is good for some cases such as nearly sorted, reversed, random, etc.
Selection Sort Algorithm: Here we repeatedly find the next largest (or smallest) element in the array and move it to its final position in the sorted array. Example: Sort the numbers 6, 7,72, 4, 32, 65, 9, 56 using selection sort.
0 1 2 3 4 5 6 7
Pass0 6 7 72 4 32 65 9 56 Original
Pass1 4 7 72 6 32 65 9 56
Pass2 4 6 72 7 32 65 9 56
Pass3 4 6 7 72 32 65 9 56
Pass4 4 6 7 9 32 65 72 56
Pass5 4 6 7 9 32 65 72 56
Pass6 4 6 7 9 32 56 72 65
Pass7 4 6 7 9 32 56 65 72 Sorted
Pseudo Code: swap(x, y) t = x x = y y = t
selectionSort (a[],n) //Let a be an array containing n items for i = 0 to n-2 m = i for j = i+1 to n-1 if (a[j] < a[m]) m = j next j swap(a[i],a[m]) next i
C++Code: #include<iostream.h> #include<conio.h>
void displayArray(int *a, int n) { int i; for (i=0; i<n; i++) cout<<a[i]<<" "; }
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 24
void swap(int *x,int *y) { int t; t=(*x); *x=(*y); *y=t; } void selectionSort (int *a, int n) { int i, j, m, t; for (i = 0; i < n-1; i++) { m = i; for (j = i+1; j < n; j++) if (a[j] < a[m]) m = j; swap(&a[i],&a[m]); } } void main () { clrscr(); int a[] = {4, 65, 2, -31, 0, 99, 2, 83, 782, 1}; int n = 10; displayArray(a,n);cout<<endl; selectionSort(a, n); displayArray(a,n); }
Bubble Sort Algorithm: Here we repeatedly move the largest element to the highest index position of the array. Example: Sort the numbers 6, 7,72, 4, 32, 65, 9, 56 using bubble sort.
0 1 2 3 4 5 6 7
Pass0 6 7 72 4 32 65 9 56 Original
Pass1 6 7 4 32 65 9 56 72
Pass2 6 4 7 32 9 56 65 72
Pass3 4 6 7 9 32 56 65 72
Pass4 4 6 7 9 32 56 65 72
Pass5 4 6 7 9 32 56 65 72 Sorted
Pseudo Code: bubbleSort(a[],n) //Let a be an array containing n items max = n-2 swapped = true while (max>0 AND swapped=true) swapped = false for j = 0 to max J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 25
if (a[j] > a[j + 1]) swap(&a[j],&a[j+1]) swapped = true end if next j max=max-1 end while
C++Code: void bubbleSort(int *a, int n) { int j; int max = n-2; int swapped = 1; while (max>0 && swapped) { swapped = 0; for (j = 0; j <= max; j++) { if (a[j] > a[j + 1]) { swap(&a[j],&a[j+1]); swapped = 1; } } max--; } }
Efficiency of the Sort Algorithms (Best, Worst and Average Case Comparison):
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 26
8. Searching Algorithm What is search algorithm? A search algorithm is an algorithm for finding an item among a collection of items.
Sequential/Linear Search Algorithm: It examines the first element in the list and then second element and so on until a much is found.
Pseudo code: int sequentialSearch(a[],n,t) //It returns the location of the target t in the array a[] with n elements. for i = 0 to n-1 if (a[i]=t) return i; next i return -1;
int sequentialSearch(int *a, int n, int t) { int i; for (i = 0; i < n; i++) if (a[i]==t) return i; return (-1); }
void main () { clrscr(); int num[] = {4, 65, 2, -31, 0, 99, 2, 83, 782, 1}; int n = 10; int t = 99; cout<<t<<" is found at "<<sequentialSearch(num, n, t)<<"."; }
Output: 99 is found at 5.
Binary Search Algorithm: Here the elements should be in (ascending) order and the elements should be saved in a randomly accessible data structure like array. The basic algorithm is to find the middle element of the list, compare it against the key/target, decide which half of the list must contain the key, and repeat with that half.
Pseudo code: int binarySearch(a[],l,u,t) //It returns the location of t in the array a[] from the index l to u. p = ( l + u) / 2; while(a[p] t AND l<=u) if (a[p] > t) u = p - 1 else l = p + 1 p = (l + u) / 2 end while if (l <= u) return p else return -1
J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 27
C++Implementation: int binarySearch(int* a, int l, int u, int t) { int p; p = ( l + u) / 2; while((a[p] != t) && (l<=u)) { if (a[p] > t) u = p - 1; else l = p + 1; p = (l + u) / 2; } if (l <= u) return p; else return (-1); }
void main () { clrscr(); int num[] = {1, 2, 7, 9, 50, 99, 100, 150, 190, 200}; int n = 10; int t = 99; cout<<t<<" is found at "<<binarySearch(num, 0, n-1, t)<<"."; }
Output: 99 is found at 5.
Recursive Pseudo Code: int recBinarySearch(a[],l,u,t) //It returns the location of t in the array a[] from the index l to u. if l>u then return -1 else mid=(l+u)/2 if t=a[mid] then return mid else if t<a[mid] then return recBinarySearch(a[],l,mid-1,t) else return recBinarySearch(a[],mid+1,u,t) end if end if
Recursive C++Code: int recBinarySearch(int* a, int l, int u, int t) { int mid; if (l>u) return (-1); else { mid=(l+u)/2; if (t==a[mid]) return mid; else if (t<a[mid]) return recBinarySearch(a,l,mid-1,t); J.Pratheepan Data Structure and Algorithm ATI-Trincomalee 28
else return recBinarySearch(a,mid+1,u,t); } }
void main () { clrscr(); int a[] = {1, 2, 7, 9, 50, 99, 100, 150, 190, 200}; int n = 10; int t = 99; cout<<t<<" is found at "<<recBinarySearch(a, 0, n-1, t)<<"."; }
Output: 99 is found at 5.
Efficiency of the Search Algorithms (Best, Worst and Average Cases): Searching Technique Best case Average Case Worst Case Sequential Search O(1) O(n) O(n) Binary Search O(1) O (log n) O(log n) The difference between O(log(N)) and O(N) is extremely significant when N is large. For example, suppose your array contains 2 billion values, the sequential search would involve about a billion comparisons; binary search would require only 32 comparisons!