search algorithm in computer science, a search algorithm is an algorithm that takes a problem as...
TRANSCRIPT
Search algorithm
In computer science, a search algorithm is an algorithm that takes a problem as input and returns a solution to the problem, usually after evaluating a number of possible solutions.
One example of the problems is searching for an item within an array of items, and the output for this problem is the position of the item in the array.
Linear search
It is a simplest search algorithm. It is based on brute force method. Also known as sequential search. It operates by checking every item of an
array one at a time in sequence until a match is found.
Linear search
FUNCTION LinearSearch(A[], n, x)FOR i = 1 TO n IF A[i] = x THEN RETURN iRETURN 0
This algorithm is unstructured.
Linear search
FUNCTION LinearSearch(A[], n, x)Pos = 0i = 1WHILE (Pos = 0) AND (i <= n) IF A[i] = x THEN Pos = i ELSE i = i + 1RETURN Pos
Improved linear search
The average performance of linear search can be improved by using it on an ordered array.
In the case of no matching item, the search can terminate at the first item which is greater than (lesser than) the unmatched target item, rather than examining the entire array.
Improved linear search
FUNCTION ImprovedLinearSearch(A[], n, x)i = 1WHILE (i <= n) AND (A[i] < x) i = i + 1IF (i <= n) AND (A[i] = x) THEN Pos = iELSE Pos = 0RETURN Pos
Binary search
It is better than linear search or improved linear search.
It uses an ordered array. It operates by checking the middle,
eliminating half of the array from consideration, and then performing the search on the remaining half.
Binary search
FUNCTION BinarySearch(A[], n, x)Pos = 0L = 1R = nWHILE (Pos = 0) AND (L <= R) mid = (L + R) div 2 IF A[mid] = x THEN Pos = mid ....
Binary search
FUNCTION BinarySearch(A[], n, x) .... ELSE IF A[mid] < x THEN L = mid + 1 ' search in the right half ELSE R = mid – 1 ' search in the left halfRETURN Pos
Improved binary search
The last algorithm of binary search uses two comparisons per iteration.
For improvement, the two comparisons can be replaced by a single comparison.
Improved binary search
FUNCTION ImprovedBinarySearch(A[], n, x)L = 1R = n + 1WHILE L < R mid = L + ((R – L) div 2) IF A[mid] < x THEN L = mid + 1 ELSE R = mid
Improved binary search
FUNCTION ImprovedBinarySearch(A[], n, x)....IF (L <= n) AND (A[L] = x) THEN Pos = LELSE Pos = 0RETURN Pos
Sorting algorithm
In computer science, a sorting algorithm is an algorithm that puts items of a list in a certain order.
List of items can be an array of items, or a linked list of items.
Three simple sorting algorithms are insertion sort, selection sort, and bubble sort.
Insertion sort
Every iteration of insertion sort removes an item from the input data, inserting it to the correct position in the already-sorted list, until no input items remain.
becomes
≤ x > x x ...
≤ x x > x ...
Insertion sort
PROCEDURE InsertionSort(A[], n)FOR i = 2 TO n value = A[i] j = i – 1 WHILE (j >= 1) AND (A[j] > value) A[j + 1] = A[j] j = j – 1 A[j + 1] = valueRETURN
Selection sort
The algorithm works as follows: Find the minimum value in the list. Swap it with the value in the first position. Repeat the steps above for the remainder of
the list (starting at the second position and advancing each time).
Selection sort
PROCEDURE SelectionSort(A[], n)FOR i = 1 TO n – 1 minIndex = i FOR j = i + 1 TO n IF A[j] < A[minIndex] THEN minIndex = j swap(i, minIndex)RETURN
Bubble sort
The algorithm works by repeatedly stepping through the list to be sorted, comparing two items at a time and swapping them if they are in the wrong order.
The pass through the list is repeatedly until no swaps are needed, which indicates that the list is sorted.
The algorithm gets its name from the way smaller items “bubble” to the top of the list.
Bubble sort
PROCEDURE BubbleSort(A[], n)REPEAT Swapped = False FOR i = 1 TO n – 1 IF A[i] > A[i + 1] THEN swap(i, i + 1) Swapped = TrueUNTIL NOT SwappedRETURN
Improved bubble sort
The performance of bubble sort can be improved marginally in the following manner.
First observed that, after each comparison (and contingent swap), the largest item encountered in the current pass will reside in the last position traversed.
Improved bubble sort
PROCEDURE BubbleSort(A[], n)REPEAT Swapped = False FOR i = 1 TO n – 1 IF A[i] > A[i + 1] THEN swap(i, i + 1) Swapped = True n = n – 1UNTIL NOT SwappedRETURN
Simplified improved bubble sort
PROCEDURE BubbleSort(A[], n)FOR i = 1 TO n – 1 FOR j = 1 TO n – i IF A[j] > A[j + 1] THEN swap(j, j + 1)RETURN
Faster sorting algorithm
There are two common sorting algorithm that have faster performance than three simple algorithm before, especially in large data list.
Merge sort Quick sort
Merge sort
Conceptually, a merge sort works as follows: If the list of length 0 or 1, then it is already
sorted. Otherwise: Divide the unsorted list into two sublists of
about half the size. Sort each sublist recursively by reapplying
merge sort. Merge the two sublists back into one sorted
list.
Merge sort
Merge sort
Merge sort works efficiently in sorting a linked list, but needs temporary memory of size n while sorting an array.
Merge sort
FUNCTION MergeSort(A[], L, R)IF L < R THEN mid = (L + R) div 2 MergeSort(A, L, mid) MergeSort(A, mid + 1, R) Merge(A, L, mid, R)RETURN
Merge sort
PROCEDURE Merge(A[], L, mid, R)i = Lj = mid + 1k = 0WHILE (i <= mid) AND (j <= R) k = k + 1 IF A[i] <= A[j] THEN B[k] = A[i] ELSE B[k] = A[j]
Merge sort
PROCEDURE Merge(A[], L, mid, R)....WHILE i <= mid k = k + 1 B[k] = A[i]WHILE j <= R k = k + 1 B[k] = A[j]....
Merge sort
PROCEDURE Merge(A[], L, mid, R)....FOR i = 1 TO k A[L + i – 1] = B[i]RETURN
Bottom-up merge sort
It is an improvement of recursive merge sort. The bottom-up merge sort works iteratively,
merge each two consecutive pieces repeatedly.
For first iteration, each piece has size 1. For second iteration, each piece has size 2. For third iteration, each piece has size 4. and so on...
Bottom-up merge sort
PROCEDURE BottomUpMergeSort(A[], n)UseTemp = FalseSize = 1WHILE Size < n L = 1 WHILE L < n IF UseTemp THEN BottomUpMerge(B, A, L, Size, n) ELSE BottomUpMerge(A, B, L, Size, n)
Bottom-up merge sort
PROCEDURE BottomUpMergeSort(A[], n) .... L = L + Size * 2 Size = Size * 2 UseTemp = NOT UseTempIF UseTemp THEN FOR i = 1 TO n A[i] = B[i]RETURN
Bottom-up merge sort
PROCEDURE BottomUpMerge(A[], B[], L, Size, n)i = Lj = L + Sizemid = j – 1R = mid + Sizek = L – 1....
Bottom-up merge sort
PROCEDURE BottomUpMerge(A[], B[], L, Size, n)....WHILE (i <= mid) AND (j <= R) AND (j <= n) k = k + 1 IF A[i] < A[j] THEN B[k] = A[i] ELSE B[k] = A[j]....
Bottom-up merge sort
PROCEDURE BottomUpMerge(A[], B[], L, Size, n)....WHILE i <= mid k = k + 1 B[k] = A[i]WHILE (j <= R) AND (j <= n) k = k + 1 B[k] = A[j]RETURN
Quick sort
The steps of the algorithm are: Pick an item, called a pivot, from the list. Reorder the list so that all items which are
less than the pivot come before the pivot and so that all items greater than the pivot come after it (equal values can go either way). This step is called partition operation.
Recursively sort the sub-list of lesser items and the sub-list of greater items.
Quick sort
PROCEDURE QuickSort(A[], L, R)IF L < R THEN PivotIndex = Partition(A, L, R, (L + R) div 2) QuickSort(A, L, PivotIndex – 1) QuickSort(A, PivotIndex + 1, R)RETURN
Quick sort
FUNCTION Partition(A[], L, R, PivotIndex)Pivot = A[PivotIndex]swap(A[PivotIndex], A[R])StoreIndex = LFOR i = L TO R – 1 IF A[i] <= Pivot THEN swap(A[i], A[StoreIndex]) StoreIndex = StoreIndex + 1swap(A[StoreIndex], A[R])RETURN StoreIndex
< Pivot Pivot > Pivot
More efficient quick sort
PROCEDURE QuickSort(A[], L, R)IF L < R THEN Pivot = A[(L + R) div 2] mid = AlternativePartition(A, L, R, Pivot) QuickSort(A, L, mid) QuickSort(A, mid + 1, R)RETURN
More efficient quick sort
FUNCTION AlternativePartition(A[], L, R, Pivot)i = Lj = RREPEAT WHILE A[i] < Pivot i = i + 1 WHILE A[j] > Pivot j = j – 1 ....
≤ Pivot ≥ Pivot
More efficient quick sort
FUNCTION AlternativePartition(A[], L, R, Pivot) .... IF i <= j THEN swap(A[i], A[j]) i = i + 1 j = j – 1UNTIL i > jRETURN j