【数据结构】数组复习-二分查找法

最新推荐文章于 2024-08-08 21:53:48 发布
最新推荐文章于 2024-08-08 21:53:48 发布
阅读量308 收藏 3
点赞数 1
分类专栏： leetcode 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54096215/article/details/140174612
版权

写这篇博客的起因：

刚开始刷力扣，发现没有一个很好的做题方法，在网络上发现了这个博主的评论，如下。感觉挺适合我，所以开始复习一下数据结构。

c++基础主要是看：

刷题主要是看：

  • 3.leetcode-labuladong系列

《labuladong 的算法笔记》纸质书 | labuladong 的算法笔记

一、数组-二分法

问题1：左闭右闭，左闭右开，左开右闭

一般使用左闭右闭和左闭右开比较多

1：左闭右开（left<right）

left=0
right=len(num)-1
m1 = (right - left) // 2 + left
while(left<right):
    m1>t,right=m1
    m1<t,left=m1+1
    m1=t,m1

2：左闭右闭（left<=right）

left=0
right=len(num)-1
m1 = (right - left) // 2 + left
while(left<=right):
    m1>t,right=m1-1
    m1<t,left=m1+1
    m1=t,m1

二、力扣相关例题

704题：二分查找

python语言-左闭右开

from typing import List

class Solution:
    def search(self, nums: List[int], target: int) -> int:

    # self: 这是一个特殊的参数，用来引用类的实例本身。在类方法中，self 是必须的，但在调用方法时通常不需要显式传入，Python会自动处理。
    # nums: List[int]: 这是函数的第一个参数，命名为 nums，类型注解指示它应该是一个整数列表。
    # target: int: 这是函数的第二个参数，命名为 target，类型注解指示它应该是一个整数。
    # -> int: 这部分指定了函数的返回类型，即该函数会返回一个整数。

        left, right = 0, len(nums)

        while left < right:
            middle = left + (right - left) // 2

            if nums[middle] > target:
                right = middle
            elif nums[middle] < target:
                left = middle + 1
            else:
                return middle

        return -1

def main():
    # Example usage:
    nums = [-1, 0, 3, 5, 9, 12]
    target = 9
    solution = Solution()
    result = solution.search(nums, target)
    print(f"Index of {target} in {nums}: {result}")

if __name__ == "__main__":
    main()

python语言-左闭右闭

from typing import List

class Solution:
    def search(self, nums: List[int], target: int) -> int:

    # self: 这是一个特殊的参数，用来引用类的实例本身。在类方法中，self 是必须的，但在调用方法时通常不需要显式传入，Python会自动处理。
    # nums: List[int]: 这是函数的第一个参数，命名为 nums，类型注解指示它应该是一个整数列表。
    # target: int: 这是函数的第二个参数，命名为 target，类型注解指示它应该是一个整数。
    # -> int: 这部分指定了函数的返回类型，即该函数会返回一个整数。

        left, right = 0, len(nums) - 1  # 定义target在左闭右闭的区间里，[left, right]

        while left <= right:
            middle = left + (right - left) // 2
            
            if nums[middle] > target:
                right = middle - 1  # target在左区间，所以[left, middle - 1]
            elif nums[middle] < target:
                left = middle + 1  # target在右区间，所以[middle + 1, right]
            else:
                return middle  # 数组中找到目标值，直接返回下标
        return -1  # 未找到目标值

def main():
    # Example usage:
    nums = [-1, 0, 3, 5, 9, 12]
    target = 9
    solution = Solution()
    result = solution.search(nums, target)
    print(f"Index of {target} in {nums}: {result}")

if __name__ == "__main__":
    main()

c++语言-左闭右开

# include <vector>

class Solution {
public:
    int search(std::vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // right is the index just beyond the end of the vector

        while (left < right) {
            int middle = left + (right - left) / 2;

            if (nums[middle] > target) {
                right = middle; // target in left half, [left, middle)
            } else if (nums[middle] < target) {
                left = middle + 1; // target in right half, [middle + 1, right)
            } else {
                return middle; // target found at index middle
            }
        }

        return -1; // target not found
    }
};

// Example usage
#include <iostream>

int main() {
    Solution solution;
    std::vector<int> nums = {-1, 0, 3, 5, 9, 12};
    int target = 9;
    int result = solution.search(nums, target);
    std::cout << "Index of " << target << " in nums: " << result << std::endl;
    return 0;
}

c++语言-左闭右闭

# include <vector>

class Solution {
public:
    int search(std::vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // right is the index just beyond the end of the vector

        while (left <= right) {
            int middle = left + (right - left) / 2;

            if (nums[middle] > target) {
                right = middle-1; // target in left half, [left, middle)
            } else if (nums[middle] < target) {
                left = middle + 1; // target in right half, [middle + 1, right)
            } else {
                return middle; // target found at index middle
            }
        }

        return -1; // target not found
    }
};

// Example usage
#include <iostream>

int main() {
    Solution solution;
    std::vector<int> nums = {-1, 0, 3, 5, 9, 12};
    int target = 9;
    int result = solution.search(nums, target);
    std::cout << "Index of " << target << " in nums: " << result << std::endl;
    return 0;
}

相关题目：

35题：搜索插入位置


#
# @lc app=leetcode.cn id=35 lang=python
#
# [35] 搜索插入位置
#

# @lc code=start
from typing import List
class Solution():
    def searchInsert(self, nums: List[int], target: int) -> int:
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        left = 0

        right = len(nums)  # 左闭右开区间 [left, right)

        while left < right:  # 区间不为空

            # 循环不变量：

            # nums[left-1] < target

            # nums[right] >= target

            mid = left + (right - left) // 2

            if nums[mid] < target:

                left = mid + 1  # 范围缩小到 [mid+1, right)

            else:

                right = mid  # 范围缩小到 [left, mid)

        return left  # 或者 right


def main():
    nums = [-1, 0, 3, 5, 9, 12]
    target = 8
    solution = Solution()
    result = solution.searchInsert(nums, target)
    print(f"Index of {target} in {nums}: {result}")       

if __name__ == "__main__":
    main()


# @lc code=end


34题：在排序数组中查找元素的第一个和最后一个位置

#
# @lc app=leetcode.cn id=34 lang=python
#
# [34] 在排序数组中查找元素的第一个和最后一个位置
#

# @lc code=start
from typing import List

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        left = 0
        right = len(nums) - 1
        result = [-1, -1]

        # Edge case: empty list
        if not nums:
            return result

        # Binary search for the left boundary of target
        while left <= right:
            middle = left + (right - left) // 2
            if nums[middle] < target:
                left = middle + 1
            else:
                right = middle - 1
        # After the loop, `left` is the index of the first occurrence of `target`
        if left < len(nums) and nums[left] == target:
            result[0] = left
        else:
            return result

        # Binary search for the right boundary of target
        left = 0
        right = len(nums) - 1
        while left <= right:
            middle = left + (right - left) // 2
            if nums[middle] <= target:
                left = middle + 1
            else:
                right = middle - 1
        # After the loop, `right` is the index of the last occurrence of `target`
        result[1] = right

        return result

def main():
    nums = [-1, 0, 3, 5, 9, 9, 12]
    target = 10
    solution = Solution()
    result = solution.searchRange(nums, target)
    print(f"Indices of {target} in {nums}: {result}")

if __name__ == "__main__":
    main()

c++
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result = {-1, -1};
        int left = 0;
        int right = nums.size() - 1;

        // First binary search to find the leftmost index of target
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else {
                // Found target, adjust right to search left part
                result[0] = mid;
                right = mid - 1;
            }
        }

        // Second binary search to find the rightmost index of target
        left = 0;
        right = nums.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else {
                // Found target, adjust left to search right part
                result[1] = mid;
                left = mid + 1;
            }
        }

        return result;
    }
};

int main() {
    vector<int> nums = {-1, 0, 3, 5, 9, 9, 9, 12};
    int target = 9;
    Solution solution;
    vector<int> result = solution.searchRange(nums, target);
    cout << "Indices of " << target << " in nums: [" << result[0] << ", " << result[1] << "]" << endl;
    return 0;
}

367题：有效的完全平方数

#include <iostream>
using namespace std;

bool isPerfectSquare(int num) {
    if (num == 0 || num == 1) {
        return true;
    }
    long left = 1;
    long right = num;
    long mid = 0;
    while (left <= right) {
        mid = (left + right + 1) / 2; // 保证处理到右边界
        long long res = mid * mid; // 使用 long long 来存放结果，避免整数溢出
        if (res == num) {
            return true;
        } else if (res > num) {
            // [left, mid-1] 区间继续找
            right = mid - 1;
        } else {
            // [mid+1, right] 区间继续找
            left = mid + 1;
        }
    }
    return false;
}

int main() {
    // 测试数据
    int nums[] = {16, 14, 25, 0, 1, 100, 99};
    int n = sizeof(nums) / sizeof(nums[0]);

    for (int i = 0; i < n; ++i) {
        cout << "Number " << nums[i] << (isPerfectSquare(nums[i]) ? " is" : " is not") << " a perfect square." << endl;
    }

    return 0;
}

#include <iostream>
using namespace std;

bool isPerfectSquare(int num) {
    if (num == 0 || num == 1) {
        return true;
    }
    long left = 1;
    long right = num;
    long mid = 0;
    while (left <= right) {
        mid = (left + right + 1) / 2; // 保证处理到右边界
        long long res = mid * mid; // 使用 long long 来存放结果，避免整数溢出
        if (res == num) {
            return true;
        } else if (res > num) {
            // [left, mid-1] 区间继续找
            right = mid - 1;
        } else {
            // [mid+1, right] 区间继续找
            left = mid + 1;
        }
    }
    return false;
}

int main() {
    // 测试数据
    int nums[] = {16, 14, 25, 0, 1, 100, 99};
    int n = sizeof(nums) / sizeof(nums[0]);

    for (int i = 0; i < n; ++i) {
        cout << "Number " << nums[i] << (isPerfectSquare(nums[i]) ? " is" : " is not") << " a perfect square." << endl;
    }

    return 0;
}

weixin_54096215
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法复习（Java）：排序、字符串、数组、链表、二分查找、二叉树.zip
01-15
排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界...
C语言数据结构-北方工业大学复习题
12-03
查找是在有序或无序数据中寻找特定元素的方法，如线性查找、二分查找和哈希查找。 7. **哈希表**：哈希表提供了一种快速查找的方法，通过哈希函数将键映射到表中的位置。冲突解决是哈希表的关键问题，常见的解决...
沈阳工业大学-数据结构-期末复习.pdf
12-31
本文档是沈阳工业大学数据结构期末复习资料，涵盖了数据结构的基本概念、数据结构类型、树、图、查找、排序、栈和队列等多个方面的知识点。 一、数据结构基本概念 * 数据结构是一种组织和存储数据的方式 * 数据...
数据结构期末复习大纲
02-08
5.1 查找：理解顺序查找、二分查找、哈希查找的原理和性能分析。 5.2 排序：掌握冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序的实现及复杂度分析。 5.3 排序算法的稳定性：讨论各种排序算法对相等元素...
杭电数据结构期末复习题.pdf
04-26
- **查找与排序**：各种查找算法（如二分查找）和排序算法（如快速排序、归并排序）等。 ### 3. 期末考试复习策略 #### 3.1 复习计划制定 - **时间规划**：合理分配复习时间和重点，确保每个章节都能得到充分的...
高阶数据结构——B树
weixin_74310945的博客
08-08 664
B树：有序数组+平衡多叉树；B+树：有序数组链表+平衡多叉树；B*树：一棵更丰满的，空间利用率更高的B+树。单论树的高度，查找效率来看B树系列确实不错，但是也存在一些缺点。1.空间利用率低，占用的空间大。2.插入和删除数据时，需要进行分裂，涉及到数据的挪动，效率低。3.虽然比起红黑树等，高度更低，但是在内存中都是一个量级的，搜索效率并不比红黑树快多少（在内存中没什么优势）
树和二叉树
2401_83720143的博客
08-08 299
2、如果对一颗有n个结点的完全二叉树（深度为 | log以2为底n的对数 | +1 ）的结点。1、在二叉树的第i层上至多有2的 i-1次方个结点（i>=1），至少有i个结点。1、具有n个结点的完全二叉树的深度为 ： | log以2为底n的对数 | +1。2、深度为k的二叉树至多有2的k次方减1个结点（k>=1），至少有k个结点。2、如果2i>n,则结点i为叶子结点，无左孩子，否则其左孩子是结点 2i。3、如果2i+1>n，则结点 i无右孩子，否则其右孩子是结点 2i+1。根结点：非空树中无前驱结点的结点。
常见8种数据结构
qq_43575301的博客
08-08 121
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
C语言练习--数组作为函数参数
lovemelater618的博客
08-08 94
题目练习
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 340
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
【Redis】数据结构篇
最新发布
小新的博客
08-08 512
Redis为什么那么快？除了它是内存数据库，使得所有的操作都在内存上进行之外，还有一个重要因素，它实现的数据结构，使得我们对数据进行增删查改操作时，Redis 能高效的处理。
[数据结构] 万字解析排序算法
Kevin ’ s blog
08-08 571
详细讲解快速排序，归并排序，计数排序全过程，万字忧讲
数据结构之Map与Set（上）
我要学编程的博客
08-08 519
二叉搜索树 Map和Set的介绍与使用：常用方法的介绍 哈希表：冲突以及避免冲突
【数据结构的——红黑树】
Pumpkin_O的博客
08-08 473
红黑树是一种自平衡的二叉查找树，是一种高效的查找树，可以在Olog2n时间内完成查找、增加和删除等操作。有了二叉搜索树，为什么需要平衡二叉树？对于二叉搜索树，如果插入的数据是随机的，那么它就是接近平衡的二叉树，平衡二叉树（AVLTree）的操作效率较高，查增删的时间复杂度都是Olog2n。但是当插入的数据有序时，二叉搜索树的结点就会只在根结点的一侧，就变成了一个链表，操作效率也因此变低，时间复杂度变为了O(n)。
初阶数据结构4 二叉树
Yusei_0523的博客
08-04 661
树的概念 二叉树的概念 堆 堆排序 二叉树的链式结构 二叉树的性质
数据结构240808作业
m0_68379095的博客
08-08 42
自定义顺序表，实现顺序表按照位置插入和删除功能（上传到作业连接）。
数据结构与算法 - 二叉树
ltt159264的博客
08-04 896
二叉树是这么一种树状结构：每个节点最多有两个孩子，左孩子和右孩子完全二叉树：是一种二叉树结构，除了最后一层以外，每一层都必须填满，填充时要遵循从左到右平衡二叉树：是一种二叉树结构，其中每个节点的左右子树高度相差不超过1。
leetcode-二叉树oj题1（共三道 965,100,144）--c语言
2303_77756141的博客
08-03 699
leetcode题目的讲解，共三道
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值