Hướng dẫn two sum binary search python - hai tổng tìm kiếm nhị phân python

Hôm nay là ngày 27 tháng 4, và đó là ngày chúng tôi đạt 1 triệu trường hợp được xác nhận của các quốc gia. Đó là một con số đáng buồn, nhưng thang đo log cho thấy tốc độ tăng trưởng đã bị chậm lại và đường cong đã được làm phẳng.

Đây là vấn đề LeetCode đầu tiên, nổi tiếng nổi tiếng. Nó có vẻ dễ dàng nhưng nó có thể là khó khăn. Không có hashtable, tôi chỉ có thể thực hiện cách tiếp cận vũ phu, chỉ đơn giản là xây dựng 2 vòng cho các vòng lặp và đi qua các mục trong từng mảng một.

Phương pháp này là chính xác nhưng không hiệu quả với O (N²). Có cách nào để cải thiện hiệu quả thành O (logn) không?

May mắn thay, vâng. Cách tiếp cận mới là tìm kiếm nhị phân. Bên dưới hình ảnh gif là một cách nhanh chóng để hiểu cách tìm kiếm nhị phân hoạt động. Binary Search. Below gif picture is a quick way to understand how binary search works.

https://brilliant.org/wiki/binary-search/

Cho một mảng số nguyên được sắp xếp (theo thứ tự tăng dần) nums của các phần tử n và giá trị target, hãy viết một hàm để tìm kiếm target trong nums. Nếu target tồn tại, sau đó trả về chỉ mục của nó, nếu không thì hãy trả lại

def twoSumNaive(num_arr, pair_sum):
  # search first element in the array
  for i in range(len(num_arr) - 1):
    # search other element in the array
    for j in range(i + 1, len(num_arr)):
      # if these two elemets sum to pair_sum, print the pair
      if num_arr[i] + num_arr[j] == pair_sum:
        print("Pair with sum", pair_sum,"is: (", num_arr[i],",",num_arr[j],")")
# Driver Code
num_arr = [3, 5, 2, -4, 8, 11]
pair_sum = 7
# Function call inside print
twoSumNaive(num_arr, pair_sum) 

def twoSumNaive(num_arr, pair_sum):
  # search first element in the array
  for i in range(len(num_arr) - 1):
    # search other element in the array
    for j in range(i + 1, len(num_arr)):
      # if these two elemets sum to pair_sum, print the pair
      if num_arr[i] + num_arr[j] == pair_sum:
        print("Pair with sum", pair_sum,"is: (", num_arr[i],",",num_arr[j],")")



# Driver Code
num_arr = [3, 5, 2, -4, 8, 11]
pair_sum = 7
# Function call inside print
twoSumNaive(num_arr, pair_sum) 

Không giống như cách tìm kiếm lực lượng vũ phu mà đi qua từng mục một, tìm kiếm nhị phân chia mảng được sắp xếp thành một nửa. Có hai điểm chính ở đây:

1. Sắp xếp mảng. Nếu mảng của bạn không được sắp xếp, xin vui lòng sắp xếp mảng trước khi bắt đầu. Độ phức tạp thời gian để sắp xếp mảng là o (nlogn)
2. Chúng tôi chia mảng thành một nửa và bắt đầu tìm kiếm mục tiêu. Hãy để xác định điểm giữa là một trục, nếu trục nhỏ hơn mục tiêu, chúng tôi di chuyển trục sang phải, còn lại +1; Nếu trục lớn hơn mục tiêu, thì chúng ta di chuyển vị trí trục từ phải sang trái bằng cách giảm một chỉ số.

Bây giờ chúng ta cần nói về cách thực hiện tìm kiếm nhị phân thành 2 tổng. Điều quan trọng là sắp xếp mảng trước khi bắt đầu.

Dạy lập trình cho trẻ em - Hai khoản tiền trong cây tìm kiếm nhị phân thông qua inorder và hai thuật toán con trỏ

Dạy lập trình trẻ em: Video về cấu trúc dữ liệu và thuật toán: Videos on Data Structures and Algorithms

Với gốc của cây tìm kiếm nhị phân và số mục tiêu K, hãy trả về đúng nếu có hai phần tử trong BST sao cho tổng của chúng bằng với mục tiêu đã cho.

Ví dụ 1: Đầu vào: Root = [5,3,6,2,4, NULL, 7], K = 9 Đầu ra: Đúng
Input: root = [5,3,6,2,4,null,7], k = 9
Output: true

Ví dụ 2: Đầu vào: Root = [5,3,6,2,4, NULL, 7], K = 28 Đầu ra: Sai
Input: root = [5,3,6,2,4,null,7], k = 28
Output: false

Ví dụ 3: Đầu vào: Root = [2,1,3], K = 4 đầu ra: Đúng
Input: root = [2,1,3], k = 4
Output: true

Ví dụ 4: Đầu vào: Root = [2,1,3], K = 1 đầu ra: Sai
Input: root = [2,1,3], k = 1
Output: false

Ví dụ 5: Đầu vào: Root = [2,1,3], K = 3 Đầu ra: Đúng
Input: root = [2,1,3], k = 3
Output: true

Hai thuật toán tổng trong cây tìm kiếm nhị phân thông qua inorder và hai thuật toán con trỏ

Chúng ta có thể thực hiện một inorder (LNR) trên cây tìm kiếm nhị phân (BST) để có được một danh sách được sắp xếp. Điều này đòi hỏi thời gian và không gian O (N). Sau đó, chúng ta có thể thực hiện một thuật toán hai con trỏ (o (n)) để tìm hiểu xem có hai số tổng hợp lên mục tiêu. Thời gian tổng thể là O (N) và độ phức tạp không gian là O (N).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findTarget(self, root: Optional[TreeNode], k: int) -> bool:
        data = []
        def dfs(root):
            if not root:
                return
            dfs(root.left)
            data.append(root.val)
            dfs(root.right)
        dfs(root)
        i, j = 0, len(data) - 1
        while i < j:
            t = data[i] + data[j]
            if t == k:
                return True
            if t > k:
                j -= 1
            else:
                i += 1
        return False            

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findTarget(self, root: Optional[TreeNode], k: int) -> bool:
        data = []
        def dfs(root):
            if not root:
                return
            dfs(root.left)
            data.append(root.val)
            dfs(root.right)
        dfs(root)
        i, j = 0, len(data) - 1
        while i < j:
            t = data[i] + data[j]
            if t == k:
                return True
            if t > k:
                j -= 1
            else:
                i += 1
        return False            

Hai thuật toán tổng:

• Dạy lập trình trẻ em - Thuật toán đệ quy để tìm tổng của hai số trong BSTS
• Dạy lập trình trẻ em - Hai thuật toán tổng khi được sắp xếp mảng đầu vào
• Các thuật toán để kiểm tra tổng của hai số trong cây tìm kiếm nhị phân
• Dạy lập trình cho trẻ em - Hai khoản tiền trong cây tìm kiếm nhị phân thông qua inorder và hai thuật toán con trỏ

Hàng

Tải xếp hạng sao GD ...
loading...

582 Bài viết Wordslast: Dạy lập trình trẻ em - Thuật ngữ tiền tố ma trận Bài tiếp theo: Dạy lập trình trẻ em - Tìm tất cả các đường dẫn từ nguồn đến mục tiêu trong biểu đồ Acyclic (DAG) theo hướng sử dụng thuật toán tìm kiếm độ sâu đệ quy đầu tiên
Last Post: Teaching Kids Programming - Matrix Prefix Sum Algorithm
Next Post: Teaching Kids Programming - Finding All Paths from Source to Target in a Directed Acyclic Graph (DAG) using Recursive Depth First Search Algorithm

URL vĩnh viễn là: Dạy lập trình cho trẻ em - hai tổng trong cây tìm kiếm nhị phân thông qua inorder và hai thuật toán con trỏ (phiên bản AMP)AMP Version)