剑指Offer（六）
文章目录
- 1、最小的K个数
- 2、数据流中的中位数
- 3、连续子数组的最大和
- 4、1-n整数中1出现的次数
- 5、数组中的逆序对
1、最小的K个数
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
if (arr.length == 0 || k == 0) return new int[0];
//使用Java提供的优先级队列：PriorityQueue
//构造方法
//PriorityQueue(Comparator comparator) 创建具有默认初始容量的 PriorityQueue ，并根据指定的比较器对其元素进行排序。
Queue<Integer> queue = new PriorityQueue<>((o1, o2)->o2-o1);
//选择大顶堆
for (int num : arr) {
if (queue.size() < k) {
queue.offer(num);
} else if (num < queue.peek()){
queue.poll();
queue.offer(num);
}
}
int[] res = new int[queue.size()];
int i = 0;
for (Integer number : queue) {
res[i++] = number;
}
return res;
}
}
2、数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5
设计一个支持以下两种操作的数据结构：
- void addNum(int num) - 从数据流中添加一个整数到数据结构中。
- double findMedian() - 返回目前所有元素的中位数。
class MedianFinder {
//使用一个大顶堆和一个小顶堆解决
public PriorityQueue<Integer> bigQueue;
public PriorityQueue<Integer> smallQueue;
/** initialize your data structure here. */
public MedianFinder() {
bigQueue = new PriorityQueue<>((o1,o2)->o2-o1);
//存储较小的部分
smallQueue = new PriorityQueue<>();
//存储较小的部分
}
public void addNum(int num) {
if (bigQueue.size() == smallQueue.size()) {
bigQueue.offer(num);
smallQueue.offer(bigQueue.poll());
} else {
smallQueue.offer(num);
bigQueue.offer(smallQueue.poll());
}
}
public double findMedian() {
return bigQueue.size() == smallQueue.size() ? (bigQueue.peek() + smallQueue.peek()) / 2.0 : smallQueue.peek();
}
}
/**
* Your MedianFinder object will be instantiated and called as such:
* MedianFinder obj = new MedianFinder();
* obj.addNum(num);
* double param_2 = obj.findMedian();
*/
在该解法中，小顶堆存储的元素个数 - 大顶堆存储的元素个数 == 0 || 1。
3、连续子数组的最大和
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
要求时间复杂度为O(n)。
输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
class Solution {
public int maxSubArray(int[] nums) {
if (nums == null || nums.length == 0) return 0;
int res = nums[0];
int maxSub = 0;
for (int num : nums) {
if (maxSub < 0) {
maxSub = 0;
}
maxSub += num;
res = Math.max(res, maxSub);
}
return res;
}
}
4、1-n整数中1出现的次数
输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。
例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。
分类讨论：（digit = 10，讨论十位上出现1的个数）
1、2304，当cur == 0时，
0010 - 2219 中十位1的个数，左侧 = 22 - 0 + 1 = 23，右侧 = 10，与digit有关，所以 high * digit；
2、2314，当cur == 1时，
0010 - 2314中十位1的个数， 因为不可能23xx全部取到，只能把22xx全部取到，所以 左侧 22 - 0 + 1 = 23，右侧 = low - 0 + 1 = low + 1，所以 high * digit + low + 1；
3、2324，当cur = 2,3,4,5,6,7,8,9时，
0010 - 2319中十位1的个数，左侧 = 23 - 0 + 1 = 24，右侧 = 10，与digit有关，所以 （high + 1 ) * digit；
class Solution {
public int countDigitOne(int n) {
if (n == 0) return 0;
int high = n / 10, cur = n % 10, low = 0, digit = 1;
int res = 0;
while (high != 0 || cur != 0) {
if (cur == 0) {
res += high * digit;
} else if (cur == 1) {
res += high * digit + low + 1;
} else {
res += (high + 1) * digit;
}
low += digit * cur;
cur = high % 10;
digit *= 10;
high /= 10;
}
return res;
}
}
5、数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
输入: [7,5,6,4]
输出: 5
class Solution {
public int count = 0;
public int reversePairs(int[] nums) {
if (nums == null || nums.length == 0) return 0;
merge(nums, 0, nums.length - 1);
return count;
}
public void merge(int[] nums, int lo, int hi) {
if (hi > lo) {
int mi = lo + hi >> 1;
merge(nums, lo, mi);
merge(nums, mi + 1, hi);
int[] newArray = new int[hi-lo+1];
int index = 0;
int i = lo, j = mi + 1;
while (i <= mi && j <= hi) {
if (nums[i] > nums[j]) {
//如果nums[i] > nums[j]，那么nums[j]与nums[i,mi]的元素都互为逆序对
count += mi - i + 1;
newArray[index++] = nums[j++];
//归并
} else {
newArray[index++] = nums[i++];
}
}
while (i <= mi) {
newArray[index++] = nums[i++];
}
while (j <= hi) {
newArray[index++] = nums[j++];
}
System.arraycopy(newArray, 0, nums, lo, hi - lo + 1);
//复制newArray数组到nums原数组
}
}
}