python binary search

1def binary_search(a, key):
2	low = 0
3	high = len(a) - 1
4	while low < high:
5		mid = (low + high) // 2
6		if key == a[mid]:
7			return True
8		elif key < mid:
9			high = mid - 1
10		else:
11			low = mid + 1
12
13	return False

1#Complete Binary Search Tree Using Python 3
2
3class node:
4    def  __init__(self,data):
5        self.data=data
6        self.left=None
7        self.right=None
8
9class binarytree:
10    def __init__(self):
11        self.root=None
12
13#INSERT
14
15    def insert(self,data):
16        if self.root==None:				
17            self.root=node(data)
18        else:
19            self._insert(data,self.root)
20    def _insert(self,data,cur_node):
21        if data<cur_node.data:
22            if cur_node.left==None:			
23                cur_node.left=node(data)
24            else:
25                self._insert(data,cur_node.left) 
26        elif data>cur_node.data:			
27            if cur_node.right==None:
28                cur_node.right=node(data)
29            else:
30                self._insert(data,cur_node.right)
31        else:
32            print('Data In Treee Already')
33
34#REMOVE
35
36    def remove(self,data):
37        if self.root!=None:
38            self._remove(data,self.root)
39    def _remove(self,data,cur_node):
40        if cur_node == None:
41            return cur_node
42        if data<cur_node.data:
43            cur_node.left=self._remove(data,cur_node.left)
44        elif data>cur_node.data:
45            cur_node.right=self._remove(data,cur_node.right)
46        else:
47            if cur_node.left is None and cur_node.right is None:
48                print('Removing Leaf Node')
49                if cur_node==self.root:
50                    self.root=None
51                del cur_node
52                return None
53            if cur_node.left is None:
54                print('Removing None with Right Child')
55                if cur_node==self.root:
56                    self.root=cur_node.right
57                tempnode=cur_node.right
58                del cur_node
59                return tempnode
60            elif cur_node.right is None:
61                print('Removing None with Left Child')
62                if cur_node==self.root:
63                    self.root=cur_node.left
64                tempnode=cur_node.left
65                del cur_node
66                return tempnode
67            print('Removing Node with 2 Children')
68            tempnode=self.getpred(cur_node.left)
69            cur_node.data=tempnode.data
70            cur_node.left=self._remove(cur_node.data,cur_node.left)
71        return cur_node
72    def getpred(self,cur_node):
73        if cur_node.right!=None:
74            return self.getpred(cur_node.right)
75        return cur_node
76
77#INORDER TRAVERSAL
78
79    def inorder(self):
80        if self.root!=None:
81            self._inorder(self.root)
82    def _inorder(self,cur_node):
83        if cur_node!=None:
84            self._inorder(cur_node.left)
85            print(cur_node.data)
86            self._inorder(cur_node.right)
87
88#PREORDER TRAVERSAL
89
90    def preorder(self):
91        if self.root!=None:
92            self._preorder(self.root)
93    def _preorder(self,cur_node):
94        if cur_node!=None:
95            print(cur_node.data)
96            self._preorder(cur_node.left)
97            self._preorder(cur_node.right)
98
99#POSTORDER TRAVERSAL
100
101    def postorder(self):
102        if self.root!=None:
103            self._postorder(self.root)
104    def _postorder(self,cur_node):
105        if cur_node!=None:
106            self._postorder(cur_node.left)
107            self._postorder(cur_node.right)
108            print(cur_node.data)
109
110#MINIMUM VALUE
111
112    def minval(self):
113        if self.root!=None:
114            return self._minval(self.root)
115    def _minval(self,cur_node):
116        if cur_node.left!=None:
117            return self._minval(cur_node.left)
118        return cur_node.data
119
120#MAXIMUM VALUE
121
122    def maxval(self):
123        if self.root!=None:
124            return self._maxval(self.root)
125    def _maxval(self,cur_node):
126        if cur_node.right!=None:
127            return self._maxval(cur_node.right)
128        return cur_node.data
129
130tree=binarytree()
131
132tree.insert(100)
133tree.insert(90)					#			 100
134tree.insert(110)				#			/	\
135tree.insert(95)					#          90   110
136tree.insert(30)					#		  /  \
137								#		30    95 
138tree.remove(110)
139tree.remove(90)
140
141tree.inorder()
142#tree.preorder()
143#tree.postorder()
144
145print(tree.minval())
146print(tree.maxval())

1# This is real binary search
2# this algorithm works very good because it is recursive
3
4def binarySearch(arr, min, max, x):
5    if max >= min:
6        i = int(min + (max - min) / 2) # average
7        if arr[i] == x:
8            return i
9        elif arr[i] < x:
10            return binarySearch(arr, i + 1, max, x)
11        else:
12            return binarySearch(arr, min, i - 1, x)
13

1#binary search python
2def binaryy(ar, ele):
3    low = 0 
4    high = len(ar)-1
5    if ele not in ar:
6        return "Not Found"
7    while low <= high:
8        mid = (low + high) // 2
9        if ar[mid] < ele:
10            low = mid + 1
11        elif ar[mid] > ele:
12            high = mid - 1
13        else:
14            return mid
15
16
17ar = [10, 20, 30, 40, 50]
18ele = 55
19print(binaryy(ar, ele))

1def binary_search(arr, item):
2	first = 0
3	last = len(arr) - 1
4	while(first <= last):
5		mid = (first + last) // 2
6		if arr[mid] == item :
7			return True
8		elif item < arr[mid]:
9			last = mid - 1
10		else:
11			first = mid + 1	
12	return False

1#blog.icodes.tech
2def binary_search(item,my_list):
3    found=False
4    first=0
5    last=len(my_list)-1
6    while first <=last and found==False:
7        midpoint=(first+last)//2
8        if my_list[midpoint]==item:
9            found=True
10        else:
11            if my_list[midpoint]<item:
12                first=midpoint+1
13            else:
14                last=midpoint-1
15    return found