By: Abdo Ababor

1
 Searching and Sorting Algorithm
 Searching is a process of looking for a specific element in a
list of items or determining that the item is not in the list.
There are two simple searching algorithms:
• Sequential Search, and
• Binary Search
1. Linear Search
 Pseudocode- Loop through the array starting at the first
element until the value of target matches one of the array
elements. If a match is not found, return –1.
 Time is proportional to the size of input (n) and we call this
time complexity O(n).
February 19, 2025 2
 Linear Search (Sequential Search)
 Example Implementation:
int Linear_Search(int list[], int key) {
int index=0;
int found=0;
do{
if(key==list[index])
found=1;
else
index++;
}while(found==0&&index<n);
if(found==0)
index=-1;
return index; } 3
 Binary Search
 Prerequisite -This searching algorithms works only on an ordered
list.
The basic idea is:
 Step1: Locate midpoint of array to search

 Step2: Determine if target is in lower half or upper half of an

array.
 If in lower half, make this half the array to search

 If in the upper half, make this half the array to search

 Step3: Loop back to step 1 until the size of the array to search is

one, and this element does not match, in which case return –1.
 The computational time for this algorithm is proportional to log2n.
Therefore the time complexity is O(log n)
4
Example Implementation:
int Binary_Search(int list[], int key) {
int left=0; int right=n-1; int found=0;
do{
mid=(left+right)/2;
if(key==list[mid])
found=1;
else{ if(key<list[mid])
right=mid-1;
else
left=mid+1;
}
}while(found==0&&left<right);
if(found==0)
index= -1;
else
index=mid;
return index;} 5
Binary search

6
 Sorting Algorithms
 Sorting is one of the most important operations performed
by computers.
 Sorting is a process of reordering a list of items in either
increasing or decreasing order.
 The following are simple sorting algorithms used to sort
small-sized lists.
• Insertion Sort
• Selection Sort
• Bubble Sort

7
 Insertion Sort
 The insertion sort works just like its name suggests - it
inserts each item into its proper place in the final list.
 The simplest implementation of this requires two list
structures - the source list and the list into which sorted items are
inserted.
 To save memory, most implementations use an inplace sort
that works by moving the current item past the already
sorted items and repeatedly swapping it with the preceding
item until it is in place.
 It's the most natural type of sorting algorithm. The approach
is the same approach that you use for sorting a set of cards
in your hand.
8
 Insertion Sort: Basic Idea
 Find the location for an element and move all others up, and
insert the element.
The process involved in insertion sort is as follows:
1. The left most value can be said to be sorted relative to itself. We don’t
need to do anything.
2. Check to see if the second value is smaller than the first one. If it is,
swap these two values.
 The first two values are now relatively sorted.
3. Next, we need to insert the third value in to the relatively sorted
portion so that after insertion, the portion will still be relatively
sorted.
4. Remove the third value first. Slide the second value to make room for
insertion. Insert the value in the appropriate position.
 Now the first three are relatively sorted.
5. Do the same for the remaining items in the list. 9
 Insertion Sort Implementation
void insertion_sort(int list[]){
int temp;
for(int i=1;i<n;i++){
temp=list[i];
for(int j=i; j>0 && temp<list[j-1];j--)
{ // work backwards through the array
finding where temp should go
list[j]=list[j-1];
list[j-1]=temp;
}
}
}

10
 Insertion Sort Implementation
void insertion_sort(int list[]){
int temp;
for(int i=1;i<n;i++){
temp=list[i];
for(int j=i; j>0 && temp<list[j-1];j--)
{ // work backwards through the array
finding where temp should go
list[j]=list[j-1];
list[j-1]=temp;
}
}
}

11
Insertion Sort Implementation

12
 Selection Sort
 Basic Idea:
Loop through the array from i=0 to n-1.
 Select the smallest element in the array from i to n Swap this
value with value at position i.

 Find smallest element in unsorted portion of container

February 19, 2025 singular linked list 13

14
 Selection Sort

February 19, 2025 15

 Bubble Sort
 Bubble sort is the simplest algorithm to implement and the
slowest algorithm on very large inputs.
Basic Idea: Loop through array from i=0 to n and swap
adjacent elements if they

February 19, 2025 16

void bubble_sort(list[]){ Bubble Sort
int i,j,temp;
for(i=0;i<n; i++){
Bubble sort starts with very first two
for(j=0;j<n; j++){
elements, comparing them to check
if(list[j]>list[j+1]){ which one is greater.

temp=list[j];
list[j]=list[j+1]; In this case, value 33 is greater than
14, so it is already in sorted locations.
list[j+1]=temp; Next, we compare 33 with 27.
}
}
We find that 27 is smaller than 33 and
} these two values must be swapped.

} 17
void bubble_sort(list[]){
Bubble Sort
int i,j,temp; The new array should look like this -

for(i=0;i<n; i++){
for(j=0;j<n; j++){
Next we compare 33 and 35. We find
if(list[j]>list[j+1]){ that both are in already sorted positions.

temp=list[j];
list[j]=list[j+1];
Then we move to the next two
list[j+1]=temp; values, 35 and 10.

}
}
We know then that 10 is smaller
} 35. Hence they are not sorted.

} 18
void bubble_sort(list[]){
int i,j,temp; We swap these values. We find that we
have reached the end of the array. After
for(i=0;i<n; i++){ one iteration, the array should look like
this -
for(j=0;j<n; j++){
if(list[j]>list[j+1]){
temp=list[j];
list[j]=list[j+1];
list[j+1]=temp;
}
}
} We take an unsorted array for our
example. Bubble sort takes Ο(n2 ) time
} so we're keeping it short and precise 19
 End of

Simple
searching &
sorting

February 19, 2025

20