分治算法思想

1.思想

  • 分治思想顾名思义,分而治之。我们把一个规模n的问题进行划分为一个一个我们能简单解决的问题,然后合并结果得到n规模问题的解。


2.前提条件

  • 第一,n规模的问题划分后的的子问题之间是相同的,即可以用同一个思维,同一套代码解决。
  • 第二,这些子问题的解合并后就是原问题的解。
  • 第三,子问题之间最好不要包含相同的部分,否则效率会下降。


3.问题


  • 合并子问题的解然后得到原问题的解,怎么去实现呢?

如果我手动一个一个去合并,那是不行的。这种方式我们需要预测问题划分的子问题数,代码效率极低。所以递归的使用就是去合并子问题的解。使用递归去不断的划分问题,直到触发划分停止条件。并且递归的使用也是因为我们的子问题是一样的,同一套代码是可以重复解决不同的子问题的,所以使用了递归。分治与递归像一对孪生兄弟,经常同时应用在算法设计之中,并由此产生许多高效算法。

3.列子


  • 快速排序

快速排序取出一个数,然后让序列中数与之比较,小的在它的左边,大的在它的右边。如果我们把这个方式从两组两个数使用,然后再通过同样的方式排序两组数,结果就是这四个数的正确排序结果。所以衍生出了快速排序的方式去解决问题。


private int sort(int l, int r, int [] data){
        int curValue = data[l]; //保存要被比较的那个值,然后最后再把它放入那个应该在的位置

        while(l < r){ // 外层循环为了不断推进l,r,直到l = r
            while(l < r && data[r] > curValue )
                r --;

            if(data[r] < curValue){
                data[l ++ ] = data[r];
            }

            while(l < r && data[l] < curValue )
                l ++;

            if(data[l] > curValue){
                data[r -- ] = data[l];
            }
        }

        data[l] = curValue; //最后l = r的时候,这个位置就是被比较的值的最终位置
        return l;
    }

    private void mergeSort(int l, int r, int [] data){
       //先排序,再拆分
        if(l < r){
            int cur =  sort(l,r,data);
            mergeSort(l,cur-1,data);
            mergeSort(cur+1,r,data);
        }

    }

代码中需要注意的地方是交换的方式有些特别,平交换我们是首先把一个值保存到临时的变量,然后把另一个值赋值给前一个值,最后把临时变量的值赋予后一个值。但是在代码中每一个的交换都没有去做最后一步,这可以理解为,交换了第一次后,虽然没有把临时变量赋值到交换的位置,假装它在那个位置,反正继续向后走,那个位置还会被需要交换的值覆盖,如此我只要把这个临时变量赋值给最后的那个位置,我就做了它和好几个的变量的交换。




  • 归并排序

归并排序的思想也是分治,它是先拆分再排序和快速排序是相反的。它的做法是,我把一个序列拆分为两个序列,然后使用第一个序列的,第一个值取比较第二个序列的第一个值,然后小的放入新数组,两个序列被取过的序列,游标向前一步,直到其中一个序列取完,另一个序列的剩余部分自动补到新数组中。如果这两个序列都是有序的,那么这样操作就结果就是排序好的一个数组了。如果我们使用这种思维,从最小的两个数,划分两个序列进行比较,然后再合并再和其他同样方式的序列进行这样的方式。那么一个规模为n的问题就不是问题了,所以出现了归并。


 private void mergeSort(int l, int r,Integer [] data){
        //先拆分,再排序
        if(l < r){
            int mid = (l + r)/2;
            mergeSort(l,mid,data);
            mergeSort(mid+1,r,data);
            sort(l,r,data);
        }
    }

    private void sort(int l, int r, Integer [] data){
        int center = (l + r)/2;
        int ll = l;
        int lr = center;
        int rl = center +1;
        int rr = r;
        Integer[] temp = new Integer[data.length]; //需要和原数组一样长,在复制回去的时候,才能按原来的位置来复制
        int tempIndex = ll;//起始的位置是l,也是因为上面的原因

        while(ll < lr +1 && rl < rr+1){ //加1是为了最后一个数不被忽略
            if(data[ll] < data[rl]){
                temp[tempIndex ++ ] = data[ll ++];
            }else {
                temp[tempIndex ++ ] = data[rl ++];
            }
        }

        //如果有一边没有比较,那么直接顺延的数组
        while(ll < lr +1){
            temp[tempIndex ++] = data[ll ++];
        }
        while(rl < rr+1){
            temp[tempIndex ++] = data[rl ++];
        }

        System.arraycopy(temp,l,data,l,r-l+1);
    }
<think>好的,我现在要解答用户关于归并排序的分治算法思想及实现步骤的问题。首先,我需要回顾归并排序的基本概念,确保自己理解正确。归并排序是分治法的典型应用,分治法的核心思想是将大问题分解成小问题,解决小问题后再合并结果。 用户提到分治算法思想,我需要明确分治的三个步骤:分解、解决、合并。归并排序的分解阶段是将数组分成两半,递归地对子数组进行排序,最后合并已排序的子数组。要详细说明每个步骤的具体操作,比如分解到何时停止(即子数组长度为1时),合并时如何比较元素并合并成有序数组。 接下来,实现步骤部分需要分点说明。可能包括递归分解、合并操作的具体过程,比如如何将两个有序数组合并成一个。这里需要确保逻辑清晰,步骤正确。例如,在合并时使用双指针法,逐个比较元素,将较小的放入结果数组,直到所有元素合并完成。 还要考虑是否需要代码示例,用户提供的引用中有Python和Java的例子,但用户问题可能更关注思想而非具体代码。不过,适当的伪代码或代码片段可能有助于理解。例如,引用中的MergeSort函数展示了递归分解和合并的过程,可以引用说明。 另外,需要结合用户提供的引用内容,确保回答中的引用标识正确。例如,分治法的基本概念在引用[2]和[5]中有提到,归并排序的具体实现步骤在引用[4]中有代码示例,性能分析可能涉及引用[4]中的内容。 最后,生成相关问题时要围绕归并排序和分治法的扩展,比如性能分析、优化方法、应用场景等,确保问题与主题相关且有参考价值。例如,时间复杂度、空间复杂度分析,如何优化归并排序的空间使用,或者与其他排序算法的比较等。 需要检查是否有遗漏的分治步骤,或者合并过程中的关键点没有说明清楚。例如,分解到最小单位后的处理方式,以及合并时的稳定性问题。同时,确保所有数学表达式和公式按照要求使用正确的LaTeX格式,如时间复杂度用$O(n \log n)$表示。 总结思考过程,确保回答结构清晰,分点明确,引用正确,并符合用户要求的格式和内容。</think>### 归并排序的分治算法思想与实现步骤 #### 一、分治算法思想 归并排序是分治算法(Divide and Conquer)的经典应用,其核心思想可概括为以下三步: 1. **分解(Divide)**:将待排序数组递归地划分为两个规模相近的子数组,直到子数组长度为1(此时单个元素天然有序)[^2][^5]。 2. **解决(Conquer)**:对每个子数组递归地进行排序(若子数组长度大于1,则继续分解)。 3. **合并(Merge)**:将两个已排序的子数组合并为一个有序数组,最终得到完整的有序序列[^3][^4]。 分治策略的关键在于**子问题与原问题形式相同但规模更小**,且子问题之间相互独立[^5]。 --- #### 二、实现步骤详解 1. **递归分解** - 初始数组为$arr[low, high]$,计算中点$mid = \lfloor (low + high)/2 \rfloor$。 - 递归分解左半部分$arr[low, mid]$和右半部分$arr[mid+1, high]$,直到子数组长度为1。 2. **合并操作(关键步骤)** - 创建临时数组存储合并结果。 - 使用双指针分别遍历左右子数组,比较当前元素大小,将较小的元素加入临时数组。 - 若某一子数组遍历完毕,将另一子数组剩余元素直接追加到临时数组。 - 将临时数组复制回原数组的对应位置。 #### 三、时间复杂度分析 - 分解过程的时间复杂度为$O(\log n)$(递归树高度)。 - 合并操作每次需遍历所有元素,时间复杂度为$O(n)$。 - 总时间复杂度为$O(n \log n)$,且无论数据是否有序,性能稳定[^4]。 --- #### 四、代码示例(Python实现) ```python def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left = merge_sort(arr[:mid]) right = merge_sort(arr[mid:]) return merge(left, right) def merge(left, right): result = [] i = j = 0 while i < len(left) and j < len(right): if left[i] < right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 result += left[i:] result += right[j:] return result ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值