分而治之思想(Java)

53545552

public class SumArray {
    public static void main(String[] args){
        int[] arr = {1,2,4,5,6,7,8,9};
        int sum = sumArray(arr, 0, arr.length-1);
        System.out.println(sum);
    }

    public static int sumArray(int[] A, int lo, int hi){
        //判断递归基的情况 如果lo和hi相撞了返回A[lo]或A[hi]都行
        if(lo == hi || lo > hi){
            return A[lo];
        }
        int mid = (lo + hi) / 2;
        /*将大问题分成两个小问题,分别得到结果后,再将小问题的答案合并
        * 就得到大问题的答案,(分而治之)
        * 分而治之与减而治之还有所区别,分而治之是分成两个规模大致相当的小问题解决
        * 而减而治之是每次分出来一个很小的子问题逐渐的减小问题的规模
        * */
        return sumArray(A, lo, mid) + sumArray(A, mid+1, hi);
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的并行性可以使用多线程来实现,并行快速排序也是一种常见的并行算法。 快速排序是一种基于思想的排序算法,它的基本思想是选取一个基准元素,将待排序序列划为两个子序列,一个子序列中的所有元素都小于基准元素,另一个子序列中的所有元素都大于基准元素。然后对这两个子序列别进行递归排序,最终得到有序序列。 在并行快速排序中,可以将待排序序列成多个子序列,并且对每个子序列使用一个线程进行排序。每个线程会选取一个基准元素,将该子序列划为两个子序列,并在两个子序列中别继续使用线程进行排序。当所有子序列都排序完成后,将它们合并成一个有序序列。 Java中实现并行快速排序可以使用Java并发包中的Fork/Join框架,该框架提供了一种方便的方式来实现任务的割和合并。具体实现可以参考以下代码: ```java import java.util.Arrays; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.RecursiveAction; public class ParallelQuickSort { private static class SortTask extends RecursiveAction { private static final int THRESHOLD = 1000; private final int[] array; private final int start; private final int end; public SortTask(int[] array, int start, int end) { this.array = array; this.start = start; this.end = end; } @Override protected void compute() { if (end - start <= THRESHOLD) { Arrays.sort(array, start, end); } else { int pivotIndex = partition(array, start, end); SortTask left = new SortTask(array, start, pivotIndex); SortTask right = new SortTask(array, pivotIndex + 1, end); invokeAll(left, right); } } private int partition(int[] array, int start, int end) { int pivot = array[start]; int i = start - 1; int j = end + 1; while (true) { do { i++; } while (array[i] < pivot); do { j--; } while (array[j] > pivot); if (i >= j) { return j; } swap(array, i, j); } } private void swap(int[] array, int i, int j) { int tmp = array[i]; array[i] = array[j]; array[j] = tmp; } } public static void parallelSort(int[] array) { ForkJoinPool pool = new ForkJoinPool(); SortTask task = new SortTask(array, 0, array.length - 1); pool.invoke(task); } } ``` 以上代码中,SortTask是一个继承自RecursiveAction的内部类,它表示并行排序的任务。如果待排序的子序列大小小于等于THRESHOLD(1000),则直接使用Arrays.sort方法进行排序;否则,选取一个基准元素将子序列划为两个子序列,别创建两个SortTask并使用invokeAll方法同时执行。在执行过程中,Fork/Join框架会自动将任务配给空闲的线程,从而实现并行化处理。 最后,在parallelSort方法中创建一个ForkJoinPool对象和一个SortTask对象,并使用invoke方法执行SortTask任务即可实现并行快速排序。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值