def binary_search(arr, val):
    middle = len(arr) // 2
    while arr[middle] != val:
        if len(arr) > 1:
            if arr[middle] < val:
                arr = arr[middle + 1:]  # X
            else:
                arr = arr[:middle]
        else:
            if arr[middle] != val:
                return False
        middle = len(arr) // 2
    return True


print(binary_search([0, 2, 3, 4, 5, 6], 7))

# output
IndexError: list index out of range

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None


class BST:
    def __init__(self):
        self.root = None

    def find(self, key):
        cur = self.root
        while cur != None:
            if cur.val == key:
                return cur
            elif cur.val > key:
                cur = cur.left
            else:
                cur = cur.right
        return False

    def insert(self, key):
        cur, pre = self.root, None
        while cur != None:
            if cur.val == key:
                return
            pre = cur
            if cur.val > key:
                cur = cur.left
            elif cur.val < key:
                cur = cur.right
        node = TreeNode(key)
        if pre.val > key:
            pre.left = node
        else:
            pre.right = node

    def delete(self, key):
        cur, pre = self.root, None
        while cur.val != key:
            if cur is None:
                return False
            pre = cur
            if cur.val > key:
                cur = cur.left
            else:
                cur = cur.right
        if cur.left is None or cur.right is None:
            child = cur.right or cur.left
            if pre.left == cur:
                pre.left = child
            else:
                pre.right = child
        else:
            replace_cur = self.find_min(cur)
            cur.val = replace_cur.val

    def find_min(self, node):
        if node is None:
            return None
        node = node.right
        while node.left is not None:
            node = node.left
        return node



if __name__ == '__main__':
    # 手动创建二叉搜索树
    bst = BST()
    bst.root = TreeNode(4)
    bst.root.left = TreeNode(2)
    bst.root.right = TreeNode(6)

    bst.root.left.left = TreeNode(1)
    bst.root.left.right = TreeNode(3)

    bst.root.right.left = TreeNode(5)
    bst.root.right.right = TreeNode(7)

    bst.insert(8)
    bst.delete(8)

    # 测试查找节点
    node = bst.find(8)
    if node:
        print(f"找到了节点，值为: {node.val}")  # 打印该节点的值
    else:
        print("未找到节点")

import random


def bogoSort(mylist):
    while (is_sorted(mylist) == False):  # if the list is not sorted...
        shuffle(mylist)  # ...shuffle again
    return (mylist)  # if sorted, return


# check if list is sorted
def is_sorted(mylist):
    n = len(mylist)
    for i in range(0, n - 1):  # iterate through list
        if (mylist[i] > mylist[i + 1]):  # if number is bigger than the number to the right
            return False  # list is not sorted so return False


# shuffle the list
def shuffle(mylist):
    n = len(mylist)
    for i in range(0, n):
        r = random.randint(0, n - 1)  # go through list, swapping each
        mylist[i], mylist[r] = mylist[r], mylist[i]  # item with another randomly chosen
    # item


mylist = [3, 2, 4, 1, 0, 5]  # define a list to sort
print(bogoSort(mylist))  # function call