215. 数组中的第K个最大元素

https://leetcode-cn.com/problems/kth-largest-element-in-an-array/

#include <algorithm>
#include <iostream>
#include <vector>

class Solution {
 public:
  int findKthLargest(std::vector<int>& nums, int k) {
    if (k < 1) {
      return -1;
    }
    int begin = 0, end = nums.size() - 1;
    int mid = -1;
    while (mid + 1 != k) {
      mid = partition(nums, begin, end);
      if (mid + 1 > k) {
        end = mid - 1;
      } else if (mid + 1 < k) {
        begin = mid + 1;
      }
    }

    return nums[mid];
  }

 private:
  int partition(std::vector<int>& nums, int begin, int end) {
    if (begin > end || end > nums.size() || nums.empty()) {
      return -1;
    }

    int key = nums[begin];
    int i = begin, j = end;
    while (i < j) {
      while (i < j && nums[j] <= key) --j;
      while (i < j && nums[i] >= key) ++i;
      std::swap(nums[i], nums[j]);
    }

    std::swap(nums[i], nums[begin]);
    return i;
  }
};

int main() {
  std::vector<int> nums = {3, 2, 3, 1, 2, 4, 5, 5, 6};
  Solution so;
  std::cout << so.findKthLargest(nums, 4) << std::endl;
  return 0;
}

#include <algorithm>
#include <iostream>
#include <vector>

class LittleHeap {
 public:
  void push(int n) {
    heap_.push_back(n);
    adjustUp();
  }

  void pop() {
    if (heap_.empty()) {
      return;
    }

    std::swap(heap_.front(), heap_.back());
    heap_.pop_back();
    adjustDown(0);
  }

  int top() {
    if (heap_.empty()) {
      return -1;
    }

    return heap_.front();
  }

  // debug
  void debugString() {
    std::for_each(heap_.begin(), heap_.end(),
                  [](int n) { std::cout << n << ' '; });
    std::cout << std::endl;
  }

  uint32_t size() { return heap_.size(); }

 private:
  // i = 0,1,2,3,4...
  // the child of a[i] is a[2*i + 1], a[2*i + 2]
  void adjustDown(int root) {
    if (heap_.size() < 2) {
      return;
    }

    int child = 2 * root + 1;
    while (child < heap_.size()) {
      if (child + 1 < heap_.size() && heap_[child + 1] < heap_[child]) {
        ++child;
      }

      if (heap_[root] > heap_[child]) {
        std::swap(heap_[root], heap_[child]);
        root = child;
        child = 2 * root + 1;
      } else {
        break;
      }
    }
  }

  // the parent of a[i] is a[(i-1) / 2]
  void adjustUp() {
    if (heap_.size() < 2) {
      return;
    }

    int child = heap_.size() - 1;
    int parent = (child - 1) / 2;
    while (parent >= 0) {
      if (heap_[parent] > heap_[child]) {
        std::swap(heap_[parent], heap_[child]);
        child = parent;
        parent = (child - 1) / 2;
      } else {
        break;
      }
    }
  }

 private:
  std::vector<int> heap_;
};

class Solution {
 public:
  int findKthLargest(std::vector<int>& nums, int k) {
    LittleHeap heap;
    for (const auto& i : nums) {
      heap.push(i);
      if (heap.size() > k) {
        heap.pop();
      }
    }
    return heap.top();
  }
};

int main() {
  std::vector<int> nums = {3, 2, 3, 1, 2, 4, 5, 5, 6};
  Solution so;
  std::cout << so.findKthLargest(nums, 4) << std::endl;
  return 0;
}