目录
一.基本概念:
🐻在计算机科学中，分治法是一种很重要的算法。字面上的解释就是“分而治之”，就是把一个复杂的问题分成两个或则更多个相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法（快速排序，归并排序），傅立叶变换(快速傅立叶变换)……
任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。例如，对于n个元素的排序问题，当n=1时，不需任何计算。n=2时，只要作一次比较即可排好序。n=3时只要作3次比较即可，…。而当n较大时，问题就不那么容易处理了。要想直接解决一个规模较大的问题，有时是相当困难的。🧐分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。
当我们对分治算法有了以上的一定了解后，来练习几道题目加深理解~~
二.归并排序：
归并排序的流程充分的体现了「分⽽治之」的思想，⼤体过程分为两步：
- 分：将数组⼀分为⼆为两部分，⼀直分解到数组的⻓度为1 ，使整个数组的排序过程被分为 「左半部分排序」+「右半部分排序」；
- 治：将两个较短的「有序数组合并成⼀个⻓的有序数组」，⼀直合并到最初的⻓度。
大致图解过程（图中例子为主）：
咱们以leetcode排序数组题目为例：912. 排序数组 - 力扣（LeetCode）
代码详解：
class Solution {
int[] tmp;
public int[] sortArray(int[] nums) {
int n = nums.length;
tmp = new int[n];
mergeSort(nums,0,n - 1);
return nums;
}
public void mergeSort(int[] nums,int left,int right){
if(left >= right) return ;
//取中点划分区域
//[left,mid] [mid + 1,right];
int mid = left + (right - left) / 2;
//排序划分的左数组和右数组
mergeSort(nums,left,mid);
mergeSort(nums,mid + 1,right);
//合并两个有序数组
int cur1 = left,cur2 = mid + 1,i = 0;
while(cur1 <= mid && cur2 <= right){
if(nums[cur1] <= nums[cur2]){
tmp[i++] = nums[cur1++];
}else{
tmp[i++] = nums[cur2++];
}
}
//处理没有完全合并的数组
while(cur1 <= mid) tmp[i++] = nums[cur1++];
while(cur2 <= right) tmp[i++] = nums[cur2++];
//还原数组
for(int j = left;j <= right;j++){
nums[j] = tmp[j - left];
}
}
}我们提取一下主要框架，大致就是：
看这个框架，也就明白那句经典的总结：归并排序就是先把左半边数组排好序，再把右半边数组排好序，然后把两半数组合并。
运行结果：
三.交易逆序对总数：
题目链接：LCR 170. 交易逆序对的总数 - 力扣（LeetCode）
题目描述：
在股票交易中，如果前一天的股价高于后一天的股价，则可以认为存在一个「交易逆序对」。请设计一个程序，输入一段时间内的股票交易记录 record，返回其中存在的「交易逆序对」总数。
代码详解：
class Solution {
int[] tmp;
public int reversePairs(int[] record) {
int n = record.length;
tmp = new int[n];
return mergeSort(record,0,n - 1);
}
public int mergeSort(int[] nums,int left,int right){
if(left >= right) return 0;
//取中间点划分区间
int mid = left + (right - left)/ 2;
//[left,mid][mid + 1,right];
int res = 0;//记录结果
res += mergeSort(nums,left,mid);
res += mergeSort(nums,mid + 1,right);
//合并两个有序数组，计算逆序对个数
int cur1 = left,cur2 = mid + 1,i = 0;
while(cur1 <= mid && cur2 <= right){
if(nums[cur1] <= nums[cur2]){
tmp[i++] = nums[cur1++];
}else{
res += mid - cur1 + 1;
tmp[i++] = nums[cur2++];
}
}
//处理没有完全合并的数组
while(cur1 <= mid) tmp[i++] = nums[cur1++];
while(cur2 <= right) tmp[i++] = nums[cur2++];
//还原数组
for(int j = left;j <= right;j++){
nums[j] = tmp[j - left];
}
return res;
}
}运行结果：
四.计算右侧小于当前元素的个数：
题目链接：315. 计算右侧小于当前元素的个数 - 力扣（LeetCode）
题目描述：给你一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。
代码详解：
class Solution {
int[] tmp1;
int[] tmp2;
int[] index;//记录数组下标位置
int[] res;//记录结果
List<Integer> ret = new ArrayList<>();//记录返回结果
public List<Integer> countSmaller(int[] nums) {
int n = nums.length;
tmp1 = new int[n];
tmp2 = new int[n];
res = new int[n];
index = new int[n];
//初始化坐标位置
for(int i = 0;i < n;i++) index[i] = i;
mergeSort(nums,0,n - 1);
for(int i = 0;i < n;i++) ret.add(res[i]);
return ret;
}
public void mergeSort(int[] nums,int left,int right){
if(left >= right) return ;
//取中间划分区域
int mid = left + (right - left) / 2;
mergeSort(nums,left,mid);
mergeSort(nums,mid + 1,right);
//合并数组，计算逆序对个数
int cur1 = left,cur2 = mid + 1,i = 0;
while(cur1 <= mid && cur2 <= right){
if(nums[cur1] <= nums[cur2]){
tmp1[i] = nums[cur2];
tmp2[i++] = index[cur2++];
}else{
res[index[cur1]] += right - cur2 + 1;
tmp1[i] = nums[cur1];
tmp2[i++] = index[cur1++];
}
}
//处理没有完全合并的数组
while(cur1 <= mid){
tmp1[i] = nums[cur1];
tmp2[i++] = index[cur1++];
}
while(cur2 <= right){
tmp1[i] = nums[cur2];
tmp2[i++] = index[cur2++];
}
//还原数组
for(int j = left;j <= right;j++){
nums[j] = tmp1[j - left];
index[j] = tmp2[j - left];
}
}
}运行结果：
五.翻转对：
题目链接：493. 翻转对 - 力扣（LeetCode）
题目描述：
给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个重要翻转对。
你需要返回给定数组中的重要翻转对的数量。
代码详解：
class Solution {
int[] tmp;
public int reversePairs(int[] nums) {
int n = nums.length;
tmp = new int[n];
return mergeSort(nums,0,n - 1);
}
public int mergeSort(int[] nums,int left,int right){
if(left >= right) return 0;
//取中间点划分区间
int mid = left + (right - left) / 2;
int res = 0;//记录结果
//[left,mid] [mid + 1,right]
res += mergeSort(nums,left,mid);
res += mergeSort(nums,mid + 1,right);
int cur1 = left,cur2 = mid + 1,i = 0;
//计算翻转对
while(cur1 <= mid){
//注意处理越界情况
while(cur2 <= right && nums[cur2] >= nums[cur1] / 2.0) cur2++;
if(cur2 > right){
break;
}
res += right - cur2 + 1;
cur1++;
}
//合并有序数组
cur1 = left;cur2 = mid + 1;//重置一下
while(cur1 <= mid && cur2 <= right){
if(nums[cur1] <= nums[cur2]){
tmp[i++] = nums[cur2++];
}else {
tmp[i++] = nums[cur1++];
}
}
//处理还没有完全合并的数组
while(cur1 <= mid) tmp[i++] = nums[cur1++];
while(cur2 <= right) tmp[i++] = nums[cur2++];
//还原数组
for(int j = left;j <= right;j++){
nums[j] = tmp[j - left];
}
//返回结果
return res;
}
}运行结果：
六.合并k个有序链表：
题目链接：23. 合并 K 个升序链表 - 力扣（LeetCode）
题目描述：
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
-
解法一：分治
代码详解：
class Solution {
ListNode[] tmp;
public ListNode mergeKLists(ListNode[] lists) {
if(lists.length == 0) return null;
return mergeSort(lists,0,lists.length - 1);
}
public ListNode mergeSort(ListNode[] lists,int left,int right){
if(left >= right) return lists[left];
//取中间节点划分两部分
int mid = (left + right) / 2;
//[left,mid] [mid + 1,right]
ListNode l1 = mergeSort(lists,left,mid);
ListNode l2 = mergeSort(lists,mid + 1,right);
//合并两个有序链表
return merge(l1,l2);
}
public ListNode merge(ListNode l1,ListNode l2){
if(l1 == null) return l2;
if(l2 == null) return l1;
ListNode cur1 = l1,cur2 = l2;
ListNode res = new ListNode(-1);//虚拟节点
ListNode pre = res;
while(cur1 != null && cur2 != null){
if(cur1.val <= cur2.val){
pre.next = cur1;
pre = cur1;
cur1 = cur1.next;
}else{
pre.next = cur2;
pre = cur2;
cur2 = cur2.next;
}
}
if(cur1 != null) pre.next = cur1;
if(cur2 != null) pre.next = cur2;
return res.next;
}
}-
解法二：利用数据结构---堆
代码详解：
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
//定义一个优先级队列，排序规则是从小到大
PriorityQueue<ListNode> heap = new PriorityQueue<>((v1,v2)-> v1.val - v2.val);
//将所有头节点放入到优先级队列中
for(ListNode head : lists){
if(head != null){
heap.offer(head);
}
}
//合并链表
ListNode res = new ListNode(-1);//虚拟节点
ListNode pre = res;
while(!heap.isEmpty()){
ListNode t = heap.poll();
pre.next = t;
pre = t;
if(t.next != null) heap.offer(t.next);
}
return res.next;
}
}运行结果：
结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！
