BCA DATA STRUCTURES SEARCHING AND SORTING MRS.SOWMYA JYOTHI

1. UNIT-II
SORTING AND SEARCHING
MRS.SOWMYA JYOTHI, SDMCBM, MANGALORE
Reference: Data Structures with C by
Seymour Lipschutz, Schaum’s Outlines Series.

2. SEARCHING
•Searching in Linear Array:
•Searching refers to the operation of finding the location
LOC of ITEM in DATA or printing some message that ITEM
does not appear there.
•(The process of finding a particular element of an array is
called Searching”).
•The search is said to be successful if ITEM does appear in
DATA and unsuccessful otherwise.

3. There are two types of search.
1)Linear search and
2) Binary Search.

4. LINEAR SEARCH:
• The linear search compares each element of the array with the
search key until the search key is found.
• To determine that a value is not in the array, the program must
compare the search key to every element in the array.
• It is also called “Sequential Search” because it traverses the data
sequentially to locate the element.
• To simplify, ITEM is assigned to DATA[N+1], the position following
the last element of DATA, then the outcome LOC=N+1,
• where LOC denotes the location where ITEM first occurs in DATA
signifies the search is unsuccessful.

5. Algorithm 4.10: (Linear Search) LINEAR (DATA, N, ITEM, LOC)
Here DATA is a Linear Array with N elements and ITEM is a
given item of information to search.
This algorithm finds the location LOC of ITEM in DATA and if
successful, it returns its location
otherwise it sets LOC=0 for unsuccessful.

6. 1. [Insert ITEM at the end of DATA] Set DATA[N+1]:=ITEM
2. [Initializes counter] Set LOC:=1
3. [Search for ITEM]
Repeat while DATA[LOC]≠ITEM: ( ITEM not found, condition is true loc++)
Set LOC:=LOC+1
[End of loop]
4. [Unsuccessful?] If LOC=N+1 then: Set LOC:=0 (Unsuccessful)
5. Exit.

9. Binary Search
• Binary search is a fast search algorithm.
• This search algorithm works on the principle of divide and
conquer.
• For this algorithm to work properly, the data collection
should be in the sorted form.
• Binary search is an extremely efficient algorithm. It is useful
for the large sorted arrays.
• The binary search algorithm can only be used with sorted
array and eliminates one half of the elements in the array
being searched after each comparison.

11. 1. First find the middle element of the array
2. Compare the middle element with an ITEM
3. There exist two cases.
a. If it is less than the desired element (ITEM) then
search only the first half of the array.
b. If it is greater than the desired element (ITEM),
search in the second half of the array.
4. Repeat the same steps until an element (ITEM) is found or
exhausted the search are.
5. If it is the desired element (ITEM) then search is
successful otherwise unsuccessful.

12. Search ITEM is in left side
Search ITEM is in right side

15. SORTING
• Sorting an array is the ordering the array elements in ascending
(increasing - from min to max) or descending (decreasing – from
max to min) order.

17. BUBBLE SORT:
• The technique we use is called “Bubble Sort” because the
bigger value gradually bubbles their way up to the top of
array like air bubble rising in water, while the small values sink
to the bottom of array.
• This technique is to make several passes through the array.
• On each pass, successive pairs of elements are compared.
• If a pair is in increasing order (or the values are identical), we
leave the values as they are.
• If a pair is in decreasing order, their values are swapped in the
array.
increasing order(ascending)

25. RADIX SORT

26. RADIX SORT

29. SELECTION SORT

30. • Merge Sort Algorithm
• Merge sort is one of the most efficient sorting algorithms. It works on
the principle of Divide and Conquer. Merge sort repeatedly breaks
down a list into several sublists until each sublist consists of a single
element and merging those sublists in a manner that results into a
sorted list.
• Top-down Merge Sort Implementation:
• The top-down merge sort approach is the methodology which
uses recursion mechanism. It starts at the Top and proceeds
downwards, with each recursive turn and “split the array into two,
make a recursive call, and merge the results.”, until one gets to the
bottom of the array-tree.

31. • Example: Let us consider an example to understand the
approach better.
1.Divide the unsorted list into n sublists, each comprising 1
element (a list of 1 element is supposed sorted).
2. Repeatedly merge sublists to produce newly sorted sublists until
there is only 1 sublist remaining. This will be the sorted list.
• Merging of two lists done as follows:
• The first element of both lists is compared. If sorting in ascending
order, the smaller element among two becomes a new element of the
sorted list. This procedure is repeated until both the smaller sublists
are empty and the newly combined sublist covers all the elements of
both the sublists.

35. Merging of two lists