在排序数组中查找元素的第一个和最后一个位置(手撕lc)

题目描述

给定一个按照升序排列的整数数组 nums,和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target,返回 [-1, -1]。

范例

输入:nums = [5,7,7,8,8,10], target = 8
输出:[3,4]
输入:nums = [5,7,7,8,8,10], target = 6
输出:[-1,-1]
输入:nums = [], target = 0
输出:[-1,-1]

方法一 暴力遍历法

在for循环里面通过每一个元素与target进行比较,如果相同,则将该元素的下标通过新建一个容器保存,最后返回容器起始下标和结束下标的值即可.

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
                int n=nums.size();
                vector<int>store;
                for(int i=0;i<n;i++)
                {
                    if(nums[i]==target)
                    {
                        store.push_back(i);
                    }
                }
                if(!store.empty())//判断容器是否为空,如果为空则说明找不到符合条件的下标
                {
                    return {store[0],store[store.size()-1]};
                }
                else{
                    return {-1,-1};
                }
    }
};

在这里插入图片描述

进阶做法 - -二分法

class Solution { 
public:
    int binarySearch(vector<int>& nums, int target, bool lower) {
        int left = 0, right = (int)nums.size() - 1, ans = (int)nums.size();
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }

    vector<int> searchRange(vector<int>& nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.size() && nums[leftIdx] == target && nums[rightIdx] == target) {
            return vector<int>{leftIdx, rightIdx};
        } 
        return vector<int>{-1, -1};
    }
};


  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 当然可以,下面是一个Python实现的堆排序的示例代码: ```python def heapify(arr, n, i): largest = i l = 2 * i + 1 r = 2 * i + 2 if l < n and arr[i] < arr[l]: largest = l if r < n and arr[largest] < arr[r]: largest = r if largest != i: arr[i],arr[largest] = arr[largest],arr[i] # 交换 heapify(arr, n, largest) def heapSort(arr): n = len(arr) for i in range(n, -1, -1): heapify(arr, n, i) for i in range(n-1, 0, -1): arr[i], arr[0] = arr[0], arr[i] # 交换 heapify(arr, i, 0) arr = [12, 11, 13, 5, 6, 7] heapSort(arr) n = len(arr) print("排序后") for i in range(n): print("%d" % arr[i]) ``` 上面的代码首先定义了两个函数:`heapify`和`heapSort`。`heapify`函数用于将数组的某个位置转换为最大堆,而`heapSort`函数用于对整个数组进行堆排序。在主程序中,我们定义了一个数组并对其进行了排序,并在最后打印出排序后的结果。 ### 回答2: 堆排序是一种基于二叉堆数据结构的排序算法。Python中可以通过构建堆、调整堆、交换元素等操作实现堆排序。 首先,构建堆的过程可以使用一个维护最大堆性质的函数实现。该函数接受一个列表和一个索引作为参数,将以该索引为根的子树调整为最大堆。具体步骤如下: 1. 初始化最大元素为根节点。 2. 将根节点与左右子节点进行比较,找出最大值。 3. 如果最大值不是根节点,则将最大值与根节点进行交换,并递归调整交换后的子树为最大堆。 其次,堆排序的过程可以通过调用构建堆函数实现。具体步骤如下: 1. 构建一个最大堆。 2. 将堆顶元素最后一个元素进行交换,并将堆大小减1。 3. 从根节点开始调整交换后的子树为最大堆。 4. 重复步骤2和3,直到堆大小为1时排序完成。 最后,将以上实现步骤整合为一个排序函数,接受一个列表作为参数,返回排序后的列表。 以下是用Python实现堆排序的代码: ```python def heapify(arr, n, i): largest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and arr[left] > arr[largest]: largest = left if right < n and arr[right] > arr[largest]: largest = right if largest != i: arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest) def heapSort(arr): n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr # 测试 arr = [12, 11, 13, 5, 6, 7] sorted_arr = heapSort(arr) print("排序结果:", sorted_arr) ``` 以上利用Python语言实现了堆排序算法,其中heapify函数用于维护最大堆性质,heapSort为堆排序函数,通过调用heapify函数构建最大堆,并依次交换堆顶元素最后一个元素进行排序。输出结果为排序后的列表。 ### 回答3: 堆排序是一种利用堆的数据结构进行排序的算法。它的主要思想是将待排序的序列构建成一个大顶堆或小顶堆,然后依次取出堆顶元素,使得取出的元素按照升序或降序排列。 在Python中,我们可以通过使用heapq模块来实现堆排序。具体的步骤如下: 1. 导入heapq模块 ```python import heapq ``` 2. 定义堆排序函数 ```python def heap_sort(arr): # 构建一个空的堆列表 heap = [] # 遍历待排序的序列,将其元素加入堆列表中 for i in arr: heapq.heappush(heap, i) # 依次取出堆顶元素,使序列有序 sorted_arr = [] while heap: sorted_arr.append(heapq.heappop(heap)) return sorted_arr ``` 3. 测试堆排序函数 ```python arr = [9, 7, 5, 3, 1, 8, 6, 4, 2] sorted_arr = heap_sort(arr) print(sorted_arr) ``` 上述代码中,我们首先构建了一个空的堆列表,然后使用heappush函数将待排序序列的元素依次加入堆中。接着,我们利用heappop函数依次取出堆顶元素,使得序列有序。最后,我们输出排序后的序列。 执行以上代码,将会输出:[1, 2, 3, 4, 5, 6, 7, 8, 9],即为使用堆排序算法后得到的有序序列。 堆排序的时间复杂度为O(nlogn),其中n为待排序序列的长度。这是一种比较高效的排序算法,适用于大规模数据的排序
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值