当前位置：首页 > wzjs >正文

企业网站建设费网站推广业务

wzjs 2025/8/22 8:25:59

企业网站建设费,网站推广业务,南通网站建设空间,做家乡的网站文章目录直接刷题链接直达把数组排成最小的数删除有序数组中的重复项求两个排序数组的中位数求一个循环递增数组的最小值数组中的逆序对如何找到一个无序数组的中位数链表排序从一大段文本中找出TOP K 的高频词汇直接刷题链接直达把一个数组排成最大的数剑指 Offer 45. 把…

文章目录

直接刷题链接直达
把数组排成最小的数
删除有序数组中的重复项
求两个排序数组的中位数
求一个循环递增数组的最小值
数组中的逆序对
如何找到一个无序数组的中位数
链表排序
从一大段文本中找出TOP K 的高频词汇

直接刷题链接直达

把一个数组排成最大的数
- 剑指 Offer 45. 把数组排成最小的数
- 面试官说需要通过补位思想（普通的compare再sort并不满意，但补位思想似乎不适用于有重复元素的情况）
如何给一个很大的无序数组去重
- 26. 删除排序数组中的重复项（给排序数组去重）
求两个排序数组的中位数
- 要求时间复杂度 O(log(m+n))
- 二分查找，递归求整个数组中第K大的元素，完整代码需要仔细考虑多种边界条件
- 4.寻找两个有序数组的中位数
求一个循环递增数组的最小值
- 153. 寻找旋转排序数组中的最小值（无重复元素，二分，总有一半有序，注意边界）
- 154. 寻找旋转排序数组中的最小值 II （有重复元素，需要解除相等时的死循环）
数组中的逆序对
- 归并排序 && 递归的应用
- 引入辅助数组临时存放排序好的数据
- 归并时指向两个指针末尾，逐次向前并统计
- 面试题51. 数组中的逆序对
如何找到一个无序数组的中位数
- 295. 数据流的中位数（建立两个堆，最大堆&最小堆，复杂度分析）
- 找出一个无序数组的中位数（快排，缩小Partition区域 / 取一半元素建堆）
链表排序
- 需要 nlog(n) 时间复杂度和常数级空间复杂度
- 归并排序的应用（Bottom Up）
- 找到中点，断开链表（通过快慢两个指针）
- 交替双指针合并
- 148. 排序链表
手写主流排序算法 & 各种算法的复杂度/稳定性分析
- 常见问题
  - 手写快排 / 堆排
  - 快排的复杂度分析（最好/最坏/平均）
  - 堆排中建堆的时间复杂度分析 --> O(n)
    - 堆排序中建堆过程时间复杂度O(n)怎么来的？
    - 为什么建堆的时间复杂度是O(n)？
  - 归并排序的 Top-Down & Bottom-up 策略
  - 不同排序的稳定性分析
  - 冒泡排序的优化策略（华为）
    - 设置flag位，一轮未交换数据即已完成排序，提前结束
    - 记住本轮最后一次交换发生的位置lastExchange，下次内层循环到此终止即可
- 排序算法稳定性
- 排序算法可视化
- 快排 Wiki / 堆排 Wiki / 归并排序 Wiki
- 堆排序(Heapsort) （特别好的讲解）
- 冒泡排序算法及其两种优化
（Top K 问题）给定一个无符号，包含10亿个数的数组，如何取出前100大的数
- 答题思路
  - 首先询问资源 --> 内存 / 核数 / 单机or多机，如可用多机 --> MapReduce思想
  - 堆排 O(nlogk)，可以单机处理海量数据（在内存受限情况下），如果k较小，趋近于 O(n)
    - 建立一个容量为k的大/小顶堆
    - n个元素逐一比较，O(logk) 完成删除和插入操作
  - 全局排序， O(nlogn) （数据量较小时才可行）
  - 冒泡（k个），O(kn)
  - 快排划分 O(n)，每次递归处理一侧的数据，理论上可以理解为每次折半，缺点 --> 存在内存不够的问题，因为需要一次读入所有数据
- 算法必学：经典的 Top K 问题（基本思路篇）
- 海量数据处理 - 10亿个数中找出最大的10000个数（top K问题）（各种资源场景分析，面试前可参考）
- 最小的K个数（代码实现，首选堆排）
Java自带的 sort() 方法是如何实现的
- Array.sort() / Collections.sort()
- DualPivotQuicksort（双轴快速排序）
- Arrays.sort和Collections.sort实现原理解析
- Collections.sort()和Arrays.sort()排序算法选择
写一个快速划分数据集的算法，要求测试集用新数据，训练集用老数据
- 数据格式为 Record（id, timestamp）
- 函数签名为 division(ArrayList dataset, double ratio)， ratio为(0,1)的划分比例
- 要求复杂度为O(n)
从一大段文本中找出TOP K 的高频词汇
- System Design Interview - Top K Problem (Heavy Hitters) （系统设计角度思考本题，如何权衡性能和效率，较为高阶）
- 347. 前K 个高频元素（数字频次代码实现，建堆，时间复杂度为nlog(k)）
- 692. 前K个高频单词（词汇频次代码实现，思路一致）

把数组排成最小的数

题目：闯关游戏需要破解一组密码，闯关组给出的有关密码的线索是：

一个拥有密码所有元素的非负整数数组 password
密码是 password 中所有元素拼接后得到的最小的一个数

class Solution {public String crackPassword(int[] password) {String[] strs = new String[password.length];for (int i=0; i < password.length; i++) {strs[i] = password[i] + "";}Arrays.sort(strs, (a, b) -> (a + b).compareTo(b + a));StringBuilder sb = new StringBuilder();for (int i=0; i < password.length; i++) {sb.append(strs[i]);}return sb.isEmpty() ? "0":sb.toString();}
}

删除有序数组中的重复项

给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

class Solution {public int removeDuplicates(int[] nums) {if (nums.length == 0) return 0;int k = 0;for (int i = 1; i < nums.length; i++) {if (nums[i] != nums[k]) {nums[++k] = nums[i];}}return k+1;}
}

求两个排序数组的中位数

题目：
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。

算法的时间复杂度应该为 O(log (m+n)) 。

解法：
这道题的关键是 二分查找+数组切割，核心思路是在较短数组上二分查找，然后通过数学推导找到合适的中位数。

设定两个数组 nums1 和 nums2，保证 nums1 总是最短的数组（这样可以减少二分查找的搜索范围）。
对短数组进行二分查找，设 nums1 的长度为 m，nums2 的长度为 n，则我们希望找到一个分割点 i（在 nums1 中），同时 j = (m + n + 1) / 2 - i（在 nums2 中）。
确保分割点左侧的所有元素 ≤ 右侧的所有元素：
nums1[i-1] <= nums2[j]
nums2[j-1] <= nums1[i]
确定中位数：
如果 m + n 是奇数，中位数是左半部分的最大值 max(nums1[i-1], nums2[j-1])。
如果 m + n 是偶数，中位数是 (max(nums1[i-1], nums2[j-1]) + min(nums1[i], nums2[j])) / 2。

public double findMedianSortedArrays(int[] nums1, int[] nums2) {// 保证 nums1 是较短的数组if (nums1.length > nums2.length) {return findMedianSortedArrays(nums2, nums1);}int m = nums1.length, n = nums2.length;int left = 0, right = m;int medianPos = (m + n + 1) / 2; // 中位数的位置while (left <= right) {int i = left + (right - left) / 2;  // nums1的分割点int j = medianPos - i;             // nums2的分割点int nums1LeftMax = (i == 0) ? Integer.MIN_VALUE : nums1[i - 1];int nums1RightMin = (i == m) ? Integer.MAX_VALUE : nums1[i];int nums2LeftMax = (j == 0) ? Integer.MIN_VALUE : nums2[j - 1];int nums2RightMin = (j == n) ? Integer.MAX_VALUE : nums2[j];if (nums1LeftMax <= nums2RightMin && nums2LeftMax <= nums1RightMin) {// 找到合适的分割点if ((m + n) % 2 == 0) {return (Math.max(nums1LeftMax, nums2LeftMax) + Math.min(nums1RightMin, nums2RightMin)) / 2.0;} else {return Math.max(nums1LeftMax, nums2LeftMax);}} else if (nums1LeftMax > nums2RightMin) {// 需要向左移动right = i - 1;} else {// 需要向右移动left = i + 1;}}throw new IllegalArgumentException("输入的数组不符合条件");
}

求一个循环递增数组的最小值

题目： 已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

class Solution {public int findMin(int[] nums) {if (nums == null || nums.length == 0) {throw new IllegalArgumentException("数组不能为空");}int left = 0, right = nums.length - 1;while (left < right) { // 这里是 left < right，而不是 left <= rightint mid = left + (right - left) / 2;if (nums[mid] > nums[right]) {  // 最小值一定在 mid 右侧left = mid + 1;} else {// 最小值可能在 mid 或左侧right = mid;}}return nums[left]; // 最终 left == right，返回最小值}
}

题目：已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：

若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]

class Solution {public int findMin(int[] nums) {if (nums == null || nums.length == 0) {return 0;}int left = 0, right = nums.length - 1;while (left < right) {int mid = left + (right - left) / 2;if (nums[mid] > nums[right]) {left = mid + 1;}else if (nums[mid] < nums[right]) {right = mid;}else {// nums[mid] == nums[right]right--;}}return nums[left];}
}

数组中的逆序对

题目：在股票交易中，如果前一天的股价高于后一天的股价，则可以认为存在一个「交易逆序对」。请设计一个程序，输入一段时间内的股票交易记录 record，返回其中存在的「交易逆序对」总数。

class Solution {public int reversePairs(int[] record) {if (record == null || record.length < 2) return 0;mergeSort(record, 0, record.length - 1);return count;}public void mergeSort(int[] record, int left, int right) {if (left >= right) return;int mid = left + (right-left)/2;mergeSort(record, left, mid);mergeSort(record, mid+1, right);// 合并merge(record, left, mid, right);}int count = 0;public void merge(int[] record, int left, int mid, int right) {int[] temp = new int[right - left +1];int i = left, j = mid+1;int k = 0;while (i <= mid && j <= right) {if (record[i] <= record[j]) {temp[k++] = record[i++];}else {//当左边数组的大与右边数组的元素时，就对当前元素以及后面的元素的个数进行统计，//此时这个数就是，逆序数//定义一个计数器，记下每次合并中存在的逆序数。count += mid - i + 1;temp[k++] = record[j++];}}while (i <= mid) temp[k++] = record[i++];while (j <= right) temp[k++] = record[j++];//将新数组中的元素，覆盖nums旧数组中的元素。//此时数组的元素已经是有序的for(int t =0; t< temp.length;t++){record[left+t] = temp[t];}}
}

如何找到一个无序数组的中位数

中位数是有序整数列表中的中间值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。

例如 arr = [2,3,4] 的中位数是 3 。
例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5 。
实现 MedianFinder 类:

MedianFinder() 初始化 MedianFinder 对象。

void addNum(int num) 将数据流中的整数 num 添加到数据结构中。

double findMedian() 返回到目前为止所有元素的中位数。与实际答案相差 10-5 以内的答案将被接受。

class MedianFinder {PriorityQueue<Integer> left;PriorityQueue<Integer> right;public MedianFinder() {left = new PriorityQueue<>((a,b)->b-a); // 最大堆right = new PriorityQueue<>(); // 最小堆}public void addNum(int num) {if (left.size() == right.size()) {right.offer(num);left.offer(right.poll());} else {left.offer(num);right.offer(left.poll());}}public double findMedian() {if (left.size() > right.size()) {return left.peek();}return (left.peek() + right.peek()) / 2.0;}
}

链表排序

class Solution {public ListNode sortList(ListNode head) {if (head == null || head.next == null) return head;// 归并排序ListNode slow = head;ListNode fast = head.next;while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;}ListNode newHead = slow.next;slow.next = null;ListNode left = sortList(head);ListNode right = sortList(newHead);ListNode dm = new ListNode(0);ListNode curr = dm;while (left != null && right != null) {if (left.val < right.val) {curr.next = left;left = left.next;curr = curr.next; }else {curr.next = right;right = right.next;curr = curr.next;}}if (left != null) {curr.next = left;}if (right != null) {curr.next = right;}return dm.next;}
}

从一大段文本中找出TOP K 的高频词汇

题目：给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。

class Solution {public int[] topKFrequent(int[] nums, int k) {PriorityQueue<int[]> pq = new PriorityQueue<>((a,b)->a[1]-b[1]);Map<Integer, Integer> map = new HashMap<>();for (int i = 0; i < nums.length; i++) {map.put(nums[i], map.getOrDefault(nums[i], 0)+1);}for (int key : map.keySet()) {if (pq.size() < k) {pq.offer(new int[]{key, map.get(key)});}else {if (pq.peek()[1] < map.get(key)) {pq.poll();pq.offer(new int[]{key, map.get(key)});}}}int[] ans = new int[k];for (int i = 0; i < k; i++) {ans[i] = pq.poll()[0];}return ans;}
}

题目： 给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。

返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字典顺序排序。

class Solution {public List<String> topKFrequent(String[] words, int k) {Map<String, Integer> map = new HashMap<>();for (int i = 0; i < words.length; i++) {map.put(words[i], map.getOrDefault(words[i], 0)+1);}PriorityQueue<String> pq = new PriorityQueue<>((a,b)->{//如果不同的单词有相同出现频率， 按字典顺序 排序if (map.get(a) == map.get(b)) {return b.compareTo(a);}return map.get(a) - map.get(b);});for (String s:map.keySet()) {pq.offer(s);if (pq.size() > k) {pq.poll();}}String[] ans = new String[k];for (int i = k-1; i >= 0; i--) {ans[i] = pq.poll();}return Arrays.asList(ans);}
}