【设计模式】16.行为型模式-策略（Strategy）

浅浅的花香味﹌ 2023-10-05 23:25 120阅读 0赞

一、描述

定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。

1.角色

(1)抽象类：定义算法方法。

(2)具体实现类：继承抽象类，实现算法方法。

2.类图

![0485e60b2178c89ae03cdc8fe09de3af.png][]

二、

以快速排序算法、合并排序算法为例，类图很简单，和上面的类图差不多，所以就不画了。直接上代码：

1.抽象计算类

public interface Calculate {
        void order(int[] values);
    }

2.快速排序算法(想了解该算法的话参考我的文章：[算法-快速排序][-])

public class FastSortCalculate implements Calculate {
        @Override
        public void order(int[] values) {
            int left = 0;
            int right = values.length - 1;
            sort(values, left, right);
            System.out.println("快速排序："); for (int i = 0; i < values.length; i++) { System.out.print(" " + values[i]); } System.out.println(); } private void sort(int[] a, int left, int right) { if (left > right) { return; } int i = left; int j = right; int sign = a[left]; while (i != j) { //查找比sign小的元素位置 while (a[j] >= sign && i < j) { j--; } //查找比sign大的元素位置 while (a[i] <= sign && i < j) { i++; } //交换 if (i < j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } } //相遇或者遇到(8)(10)(11)等情况，直接交换 a[left] = a[j]; a[j] = sign; //分割数组重新排序 sort(a, left, j - 1); sort(a, j + 1, right); } }

3.合并排序算法(想了解该算法的话参考我的文章：[算法-合并排序][- 1])

public class MergeSortCalculate implements Calculate {
        @Override
        public void order(int[] values) {
            //定义下标
            int right = values.length - 1;
            int left = 0;
            int[] b = new int[values.length]; mergeSort(values, b, left, right); //合并 System.out.println("合并排序："); for (int i = 0; i < b.length; i++) { System.out.print(" " + b[i]); } System.out.println(); } public static void mergeSort(int[] a, int[] b, int left, int right) { if (left == right) { //分到最小单位 return; } if (left < right) { //当未拆分完时继续拆分 int mid = (left + right) / 2; //分组  mergeSort(a, b, left, mid); mergeSort(a, b, mid + 1, right); //拆分完合并 //i定义为左边数组起点 int i = left; //i定义为右边数组起点 int j = mid + 1; //新数组下标 int t = 0; //当前两边数组未排序完成时 while (i <= mid && j <= right) { //定义min接收较小数据 int min; if (a[i] < a[j]) { //若当前左边数组i位置上的数据小于右边数组j位置上的数据，说明右边数组j后面位置的数据都大于i对应的数据， // 所以i++向后移动比较下一个左边数组的数据与当前右边数据j的数据。 min = a[i]; i++; } else { //若左边数组i位置上的数据大于j位置上的数据，则i位置要继续与右边数组剩下的数据进行比较，j++ min = a[j]; j++; } //将较小数据放到b数组对应位置上，并且下标向后移动一位 b[t++] = min; } //若左边数组上还有剩余数据，则放到数组中 while (i <= mid) { b[t++] = a[i++]; } //若右边数组上还有剩余数据，则放到数组中 while (j <= right) { b[t++] = a[j++]; } //将b数组中的有序数组放到a对应的位置上。 t = 0; while (left <= right) { a[left++] = b[t++]; } } } }

4.调用

public class Client {
        public static void main(String[] args) {
            int[] a = {9, 5, 2, 7, 12, 4, 3, 1, 11};
            Calculate fastSortCalculate = new FastSortCalculate();
            fastSortCalculate.order(a);
    
            Calculate mergeSortCalculate = new MergeSortCalculate(); mergeSortCalculate.order(a); } }

5.效果

![795990e125ebe264e04e3066e461a876.png][]

[0485e60b2178c89ae03cdc8fe09de3af.png]: https://img-blog.csdnimg.cn/img_convert/0485e60b2178c89ae03cdc8fe09de3af.png
[-]: https://blog.csdn.net/CAT_cwds/article/details/113401307
[- 1]: https://blog.csdn.net/CAT_cwds/article/details/113694609?spm=1001.2014.3001.5502
[795990e125ebe264e04e3066e461a876.png]: https://img-blog.csdnimg.cn/img_convert/795990e125ebe264e04e3066e461a876.png