This document summarizes the pseudocode and time complexity for three sorting/searching algorithms: 1) Linear search has a time complexity of O(n) and searches a list sequentially to find a matching item. 2) Binary search has a time complexity of O(log n) and searches a sorted array by repeatedly dividing the search interval in half. 3) Bubble sort has a time complexity of O(n^2) and iterates through a list, comparing and swapping adjacent elements into ascending order.

1. ADVANCE ALGORITHMS
ANALYSIS
NAME: MUHAMMAD SARFRAZ
RE NO: 2022-MSCS-48

2. Linear Search pseudocode
procedure linear search (list, value)
for each item in the list
if match item == value
return the item's location
end if
end for
end procedure

3. Time Complexity?
O(n)

4. Pseudo code for Binary Search
Procedure binary_search
A ← sorted array
n ← size of array
x ← value to be searched
Set lowerBound = 1
Set upperBound = n
while x not found
if upperBound < lowerBound
EXIT: x does not exists.
set midPoint = lowerBound + ( upperBound - lowerBound ) / 2

5. if A[midPoint] < x
set lowerBound = midPoint + 1
if A[midPoint] > x
set upperBound = midPoint - 1
if A[midPoint] = x
EXIT: x found at location midPoint
end while
end procedure

6. midPoint = lowerBound + ( upperBound - lowerBound ) / 2
Time Complexity?
O(log n)

7. Pseudo code for Bubble Sort
procedure bubbleSort( list : array of items )
loop = list.count;
for i = 0 to loop-1 do:
swapped = false
for j = 0 to loop-1 do:
if list[j] > list[j+1] then
swap( list[j], list[j+1] )
swapped = true
end if
end for
if(not swapped) then
break
end if
end for
end procedure return list

8. Time Complexity?
O(n2)