Searching and sorting by B kirron Reddi

www.cscareerblog.com
Searching and Sorting
Searching is an operation or a technique that helps finds the place of a given element
or value in the list. Any search is said to be successful or unsuccessful depending upon
whether the element that is being searched is found or not.
Sorting is refers to the operation or technique of arranging and rearranging sets of data
in some specific order. A collection of records called a list where every record is having one
or more fields. The fields which contains unique value for each record, is termed as the key
field.
The records are either sorted either numerically or alphanumerically. The records are then
arranged in ascending or descending order depending on the numerical value of the key
Linear search
Linear search is also called as sequential search. Linear search is a method for finding a
particular value in a list. In this searching technique you need to check every elements one by one
until desired element found.
This search process starts comparing of search element with the first element in the list. If
both are matching then results with element found otherwise search element is compared with next
element in the list. If both are matched, then the result is "element found". Otherwise, repeat the same
with the next element in the list until search element is compared with last element in the list, if that
last element also doesn't match, then the result is "Element not found in the list". That means, the
search element is compared with element by element in the list.
Search element 12
Step 1
Search element (12) is compared with first element (65)
both are not matching. So move to next element
Step 2
Step 3
Step 4

Step 5
Step 6
Both are matching. So we stop comparing and display element found at index 5.
Example
#include<iostream>
using namespace std;
int main()
{
int arr[10], i, num, n, c=0, pos;
cout<<"Enter the array size : ";
cin>>n;
cout<<"Enter Array Elements : ";
for(i=0; i<n; i++)
{
cin>>arr[i];
}
cout<<"Enter the number to be search : ";
cin>>num;
for(i=0; i<n; i++)
{
if(arr[i]==num)
{
c=1;
pos=i+1;
break;
}
}
if(c==0)

{
cout<<"Number not found..!!";
}
else
{
cout<<num<<" found at position "<<pos;
}
return 0;
}
Output:
Binary search
The binary search can not be used for list of element which are in random order. This search
process starts comparing of the search element with the middle element in the list. If both are
matched, then the result is "element found". Otherwise, we check whether the search element is
smaller or larger than the middle element in the list. If the search element is smaller, then we repeat
the same process for left sublist of the middle element. If the search element is larger, then we repeat
the same process for right sublist of the middle element. We repeat this process until we find the
search element in the list or until we left with a sublist of only one element. And if that element also
doesn't match with the search element, then the result is "Element not found in the list".
Search element 12
Step 1
Search element (12) is compared with middle element (50)
Both are not matching. And 12 is smaller than 50. So we search only in the left sublist (i.e. 10,12,20
& 32).
Step 2
Both are matching. So the result is “element found at index 1”
Search element 80

Step 1
Both are not matching. And 80 is larger than 50.so we search only in the right sublist (i.e. 55,65,80 &
99 ).
Step 2
Both are not matching. And 80 is larger than 65.so we search only in the right sublist (i.e. 80 & 99 ).
Step 3
Both are not matching. So the result is “ element found at index 7”
Example
#include<iostream>
int main()
{
int n, i, arr[50], search, first, last, middle;
cout<<"Enter total number of elements :";
cin>>n;
cout<<"Enter "<<n<<" number :";
for (i=0; i<n; i++)
{
cin>>arr[i];
}
cout<<"Enter a number to find :";
cin>>search;
first = 0;
last = n-1;
middle = (first+last)/2;
while (first <= last)
{

if(arr[middle] < search)
{
first = middle + 1;
}
else if(arr[middle] == search)
{
cout<<search<<" found at location "<<middle+1<<"n";
break;
}
else
{
last = middle - 1;
}
middle = (first + last)/2;
}
if(first > last)
{
cout<<"Not found! "<<search<<" is not present in the list.";
}
return 0;
}
Output:
Selection sort
Sorting is refers to the operation or technique of arranging and rearranging sets of data
in some specific order. A collection of records called a list where every record is having one
or more fields. The fields which contains unique value for each record, is termed as the key
field.
The records are either sorted either numerically or alphanumerically. The records are then
arranged in ascending or descending order depending on the numerical value of the key
Unsorted list
1st iteration:
Smallest = 5
2 < 5, smallest = 2
1 < 2, smallest = 1
4 > 1, smallest = 1

3 > 1, smallest = 1
Swap 5 and 1
2nd iteration:
Smallest = 2
2 < 5, smallest = 2
2 < 4, smallest = 2
2 < 3, smallest = 2
No Swap
3rd iteration:
Smallest = 5
4 < 5, smallest = 4
3 < 4, smallest = 3
Swap 5 and 3
4th iteration:
Smallest = 4
4 < 5, smallest = 4
No Swap
Finally,
Example
#include<iostream>
int main()
{
int size, arr[50], i, j, temp, index, small, count=0;
cout<<"Enter Array Size : ";
cin>>size;
for(i=0; i<size; i++)
cin>>arr[i];
cout<<"Sorting array using selection sort...n";
for(i=0; i<(size-1); i++)
{
small = arr[i];
for(j=(i+1); j<size; j++)
{
if(small>arr[j])

{
small = arr[j];
count++;
index = j;
}
}
if(count!=0)
{
temp = arr[i];
arr[i] = small;
arr[index] = temp;
}
count=0;
}
cout<<"Now the Array after sorting is :n";
cout<<arr[i]<<" ";
return 0;
}
Output:
Bubble sort
The bubble sort makes multiple passes through a list. It compares adjacent items and
exchanges those that are out of order. Each pass through the list places the next largest value in its
proper place. In essence, each item “bubbles” up to the location where it belongs.
Figure shows the first pass of a bubble sort. The shaded items are being compared to see if
they are out of order. If there are n items in the list, then there are n−1n−1 pairs of items that need to
be compared on the first pass. It is important to note that once the largest value in the list is part of a
pair, it will continually be moved along until the pass is complete.

At the start of the second pass, the largest value is now in place. There are n−1n−1 items left
to sort, meaning that there will be n−2n−2 pairs. Since each pass places the next largest value in place,
the total number of passes necessary will be n−1n−1. After completing the n−1n−1 passes, the
smallest item must be in the correct position with no further processing required. ActiveCode 1 shows
the completebubbleSort function. It takes the list as a parameter, and modifies it by exchanging items
as necessary.
The exchange operation, sometimes called a “swap,” is slightly different in Python than in
most other programming languages. Typically, swapping two elements in a list requires a temporary
storage location (an additional memory location). A code fragment such as
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
will exchange the ith and jth items in the list. Without the temporary storage, one of the values would
be overwritten.
Example:
#include<iostream>
int main()
{
int n, i, arr[50], j, temp;
cout<<"Enter total number of elements :";
cin>>n;
cout<<"Enter "<<n<<" numbers :";
for(i=0; i<n; i++)

{
cin>>arr[i];
}
cout<<"Sorting array using bubble sort technique...n";
for(i=0; i<(n-1); i++)
{
for(j=0; j<(n-i-1); j++)
{
if(arr[j]>arr[j+1])
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
cout<<"Elements sorted successfully..!!n";
cout<<"Sorted list in ascending order :n";
for(i=0; i<n; i++)
{
cout<<arr[i]<<" ";
}
return 0;
}
Output:
Insertion sort
Insertion sort algorithm arranges a list of elements in a particular order. In insertion sort
algorithm, every iteration moves an element from unsorted portion to sorted portion until all the
elements are sorted in the list.
Consider the following list of elements..
Iteration 1:
Select the first position element in the list compare it with all other elements in the list and whenever
we found a smaller element that the element at first position then swap those two elements.

List after 1st
iteration
Iteration 2:
Select the second position element in the list compare it with all other elements in the list and
whenever we found a smaller element then the element at first position then swap those two elements.
List after 2nd
iteration
Iteration 3:
Select the third position element in the list compare it with all other elements in the list and whenever
we found a smaller element then the element at first position then swap those two elements.
List after 3rd
iteration
Iteration 4:
Select the fourth position element in the list compare it with all other elements in the list and
List after 4th
iteration
Iteration 5:

Select the fifth position element in the list compare it with all other elements in the list and whenever
List after 5th
iteration
Iteration 6:
Select the sixth position element in the list compare it with all other elements in the list and whenever
List after 6th
iteration
Iteration 7:
Select the seventh position element in the list compare it with all other elements in the list and
List after 7th
iteration
This is final sort
Example:
#include<iostream>
int main()
{
int size, arr[50], i, j, temp;
cout<<"Enter Array Size : ";
cin>>size;
{
cin>>arr[i];
}
cout<<"Sorting array using selection sort ... n";
{
temp=arr[i];
j=i-1;
while((temp<arr[j]) && (j>=0))
{
arr[j+1]=arr[j];
j=j-1;
}
arr[j+1]=temp;
}

cout<<"Array after sorting : n";
{
cout<<arr[i]<<" ";
}
return 0;
}
Output:

Searching and sorting by B kirron Reddi

More Related Content

What's hot (19)

Similar to Searching and sorting by B kirron Reddi (20)

More from B.Kirron Reddi (18)

Recently uploaded (20)

Searching and sorting by B kirron Reddi