Scribd
Upload
14 views8 pages

Chapter 3

Python

Uploaded by

archanasarangi5
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
14 views8 pages

Chapter 3

Python

Uploaded by

archanasarangi5
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 8

CHAPTER-9

Linear Search in Python


Python is one of the most popular and powerful languages. It takes a few lines to execute the cod

, which makes it much user-friendly language. In this tutorial, we will learn the linear search in

Python. Searching is a technique to find the particular element is present or not in the given list.

There are two types of searching -

ADVERTISEMENT
ADVERTISEMENT

o Linear Search
o Binary Search

Both techniques are widely used to search an element in the given list.

What is a Linear Search?


Linear search is a method of finding elements within a list. It is also called a sequential search.

It is the simplest searching algorithm because it searches the desired element in a sequential ma

ADVERTISEMENT

It compares each and every element with the value that we are searching for.

If both are matched, the element is found, and the algorithm returns the key's index position.

Concept of Linear Search


Let's understand the following steps to find the element key = 7 in the given list.

Step - 1: Start the search from the first element and Check key = 7 with each element of list x.

Step - 2: If element is found, return the index position of the key.

Step - 3: If element is not found, return element is not present.


Linear Search Algorithm
There is list of n elements and key value to be searched.

Below is the linear search algorithm.

1. LinearSearch(list, key)
2. for each item in the list
3. if item == value
4. return its index position
5. return -1

Python Program
Let's understand the following Python implementation of the linear search algorithm.

Program

1. def linear_Search(list1, n, key):


2.
3. # Searching list1 sequentially
4. for i in range(0, n):
5. if (list1[i] == key):
6. return i
7. return -1
8.
9.
10. list1 = [1 ,3, 5, 4, 7, 9]
11. key = 7
12.
13. n = len(list1)
14. res = linear_Search(list1, n, key)
15. if(res == -1):
16. print("Element not found")
17. else:
18. print("Element found at index: ", res)

Output:

Element found at index: 4


Explanation:

In the above code, we have created a function linear_Search(),

which takes three arguments - list1, length of the list, and number to search.

We defined for loop and iterate each element and compare to the key value.

If element is found, return the index else return -1 which means element is not present in the list.

Linear Search Complexity


Time complexity of linear search algorithm -

o Base Case - O(1)


o Average Case - O(n)
o Worst Case -O(n)

Linear search algorithm is suitable for smaller list (<100) because it check

every element to get the desired number. Suppose there are 10,000 element

list and desired element is available at the last position, this will consume much time by compari

with each element of the list.

Python Program for Binary Search (Recursive and Iterative





In a nutshell, this search algorithm takes advantage of a collection of elements that is alre

sorted by ignoring half of the elements after just one comparison.


1. Compare x with the middle element.
2. If x matches with the middle element, we return the mid index.
3. Else if x is greater than the mid element, then x can only lie in the right (greater)
subarray after the mid element. Then we apply the algorithm again for the right h
4. Else if x is smaller, the target x must lie in the left (lower) half. So we apply the alg
for the left half.
Python Program for Binary Search Using Recursive
 Python3
# Python 3 program for recursive binary search.
# Modifications needed for the older Python 2 are found in comments.

# Returns index of x in arr if present, else -1


def binary_search(arr, low, high, x):

# Check base case


if high >= low:

mid = (high + low) // 2

# If element is present at the middle itself


if arr[mid] == x:
return mid

# If element is smaller than mid, then it can only


# be present in left subarray
elif arr[mid] > x:
return binary_search(arr, low, mid - 1, x)

# Else the element can only be present in right subarray


else:
return binary_search(arr, mid + 1, high, x)

else:
# Element is not present in the array
return -1

# Test array
arr = [ 2, 3, 4, 10, 40 ]
x = 10

# Function call
result = binary_search(arr, 0, len(arr)-1, x)

if result != -1:
print("Element is present at index", str(result))
else:
print("Element is not present in array")

Output
Element is present at index 3

Time Complexity: O(log n)


Auxiliary Space: O(logn) [NOTE: Recursion creates Call Stack]
Python Program for Binary Search Using Iterative
 Python3

# Iterative Binary Search Function


# It returns index of x in given array arr if present,
# else returns -1
def binary_search(arr, x):
low = 0
high = len(arr) - 1
mid = 0

while low <= high:

mid = (high + low) // 2

# If x is greater, ignore left half


if arr[mid] < x:
low = mid + 1

# If x is smaller, ignore right half


elif arr[mid] > x:
high = mid - 1

# means x is present at mid


else:
return mid

# If we reach here, then the element was not present


return -1

# Test array
arr = [ 2, 3, 4, 10, 40 ]
x = 10

# Function call
result = binary_search(arr, x)

if result != -1:
print("Element is present at index", str(result))
else:
print("Element is not present in array")

Output
Element is present at index 3

Time Complexity: O(log n)


Auxiliary Space: O(1)
Python Program for Binary Search Using the built-in bisect module
Step by step approach:
 The code imports the bisect module which provides support for binary searching.
 The binary_search_bisect() function is defined which takes an array arr and
the element to search x as inputs.
 The function calls the bisect_left() function of the bisect module which finds the po
of the element in the sorted array arr where x should be inserted to maintain the
If the element is already present in the array, this function will return its position.
 The function then checks if the returned index i is within the range of the array
and if the element at that index is equal to x.
 If the condition is true, then the function returns the index i as the position of the
element in the array.
 If the condition is false, then the function returns -1 indicating that the element is
present in the array.
 The code then defines an array arr and an element x to search.
 The binary_search_bisect() function is called with arr and x as inputs and the retur
result is stored in the result variable.
 The code then checks if the result is not equal to -1, indicating that the element
is present in the array. If true, it prints the position of the element in the array.
 If the result is equal to -1, then the code prints a message that the element is not
in the array.
 Python3

import bisect

def binary_search_bisect(arr, x):


i = bisect.bisect_left(arr, x)
if i != len(arr) and arr[i] == x:
return i
else:
return -1

# Test array
arr = [2, 3, 4, 10, 40]
x = 10

# Function call
result = binary_search_bisect(arr, x)
if result != -1:
print("Element is present at index", str(result))
else:
print("Element is not present in array")

Output
Element is present at index 3

You might also like