简单工厂模式和策略模式实现简单排序算法。

最新推荐文章于 2020-11-06 16:50:23 发布
最新推荐文章于 2020-11-06 16:50:23 发布
阅读量155 收藏
点赞数
文章标签： 算法 设计模式 J# UML JDK
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_853/article/details/82064272
版权
第一次使用设计模式编写java版的排序算法。欢迎指点，有不足之处还望不吝赐教。
本人略懒，UML图就不画了。

================Sort类，所有将要实现的算法的母类===================== 
package sort;

import java.util.Calendar;
import java.util.Random;

public abstract class Sort {

    // 存储排序数量的数组。
    int[] arrays;

    // 指定随机生成的数字的范围。
    int range;

    // 存储对应排序数量所用的时间。
    long[] sortTimes;

    Sort(){

    }

    Sort(int[] arrays, int range){
        this.arrays = arrays;
        this.range = range;
        this.sortTimes = new long[arrays.length];
    }

    // 具体排序方法。
    public abstract int[] sort(int[] array, int length);

    // 显示结果 。
    public void display(String name) {
        System.out.println("排序数量\t\t" + name + "(ms)");
        for (int n = 0; n < arrays.length; n++) {
            int turns = 10; // 排十次，求平均。
            long time = 0;
            for (int j = 0; j < turns; ++j) {
                long begin = Calendar.getInstance().getTimeInMillis();
                this.sort(this.getRandArray(arrays[n]), arrays[n]);
                long end = Calendar.getInstance().getTimeInMillis();
                time += (end - begin);
            }
            sortTimes[n] = time / turns;
        }
        for (int i = 0; i < arrays.length; ++i) {
            System.out.println("" + arrays[i] + "\t\t" + sortTimes[i]);
        }
    }

    // 生成指定长度的数组。
    public int[] getRandArray(int n) {
        int[] array = new int[n];
        Random rand = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = rand.nextInt(range);
        }
        return array;
    }

    // 测试数组是否排序成功，顺序由小到大。
    public boolean isSorted(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i] > array[i + 1]) {
                return false;
            }
        }
        return true;
    }

    //显示数组
    public void display(int[] array){
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }
    }
}


=================================工厂类============================== 
package sort;

public class SortFactory {

    public static Sort creatSort(String sortName, int[] arrays, int range) {
        Sort sort = null;
        char[] sortname = sortName.toCharArray();
        // jdk 1.7过后switch就支持String类型了。
        switch (sortname[0]) {
        case 'B': // 冒泡排序
            sort = new BubbleSort(arrays, range);
            break;
        case 'S': // 选择排序
            sort = new SelectSort(arrays, range);
            break;
        case 'I': // 插入排序
            sort = new InsertSort(arrays, range);
            break;
        case 'M': // 归并排序
            sort = new MergeSort(arrays, range);
            break;
//        case 'S': // 系统排序
//            sort = new SystemSort(arrays, range);
//            break;
        case 'H': // 堆排序
            sort = new HeapSort(arrays, range);
            break;
        }
        return sort;
    }
}

===============================测试类================================
// 其中插入排序和系统排序是策略模式实现。 

package sort;

import org.junit.Test;

public class SortTest {

	// 存储排序数量的数组。
	int[] arrays = { 1000, 2000, 5000, 10000, 20000, 50000, 100000 };

	// 指定随机生成的数字的范围(0-1000)。
	int range = 1000;

	// 使用简单工厂创建具体排序类。
	Sort sort = null;

	// 使用策略模式实现，适用于调用的方法都是做的相同的工作，只是实现不同。
	SortContext sortContext;

	// 冒泡排序，使用简单工厂实现。用户需要知道工厂类和Sort接口。
	@Test
	public void testBubbleSort() {
		sort = SortFactory.creatSort("BubbleSort", arrays, range);
		sort.display("冒泡排序");
	}

	// 选择排序。
	@Test
	public void testSelectSort() {
		sort = SortFactory.creatSort("SelectSort", arrays, range);
		sort.display("选择排序");
	}

	// 归并排序。
	@Test
	public void testMergeSort() {
		sort = SortFactory.creatSort("MergeSort", arrays, range);
		sort.display("归并排序");
	}

	// 堆排序。
	@Test
	public void testHeapSort() {
		sort = SortFactory.creatSort("HeapSort", arrays, range);
		sort.display("堆排序");
	}

	// 插入排序。
	// 使用简单工厂加策略模式实现。用户只需知道SortContext，进一步降低耦合性。
	@Test
	public void testInsertSort() {
		sortContext = new SortContext("InsertSort", arrays, range);
		sortContext.display("插入排序 ");
	}

	// 系统排序，快速排序。
	@Test
	public void testSystemSort() {
		sortContext = new SortContext("SystemSort", arrays, range);
		sortContext.display("系统排序");
	}

}

================================策略模式======================================= 
package sort;

public class SortContext {

	Sort sort = null;

	// 简单工厂实现具体策略。
	public SortContext(String sortName, int[] arrays, int range) {
		char[] sortname = sortName.toCharArray();
		// jdk 1.7过后switch就支持String类型了。
		switch (sortname[0]) {
		case 'B': // 冒泡排序
			sort = new BubbleSort(arrays, range);
			break;
		case 'I': // 插入排序
			sort = new InsertSort(arrays, range);
			break;
		case 'M': // 归并排序
			sort = new MergeSort(arrays, range);
			break;
		case 'S': // 系统排序
			sort = new SystemSort(arrays, range);
			break;
		case 'H': // 堆排序
			sort = new HeapSort(arrays, range);
			break;
		}
	}

	// 策略模式，封装公共的功能。
	public void display(String name) {
		sort.display(name);
	}
}

===============================冒泡排序======================================== 
package sort;

public class BubbleSort extends Sort {

	BubbleSort(int[] arrays, int range) {
		super(arrays, range);
		// TODO Auto-generated constructor stub
	}

	public BubbleSort() {
		// TODO Auto-generated constructor stub
	}

	// 冒泡。
	@Override
	public int[] sort(int[] array, int length) {
		int temp;
		for (int out = 0; out < length; out++)
			for (int in = length - 1; in > out; in--)
				if (array[in] < array[in - 1]) {
					temp = array[in];
					array[in] = array[in - 1];
					array[in - 1] = temp;
				}
		return array;
	}
}


=================================选择排序====================================== 
package sort;

public class SelectSort extends Sort {

	SelectSort() {

	}

	SelectSort(int[] arrays, int range) {
		super(arrays, range);
	}

	// 选择排序，从小到大。
	@Override
	public int[] sort(int[] array, int length) {
		// TODO Auto-generated method stub
		int left, right, min, temp;
		for (left = 0; left < length - 1; left++) {
			min = left;
			for (right = left + 1; right < length; right++) {
				if (array[right] < array[min])
					min = right;
			}
			temp = array[left];
			array[left] = array[min];
			array[min] = temp;
		}
		return array;
	}

}

=====================================插入排序================================== 
package sort;

public class InsertSort extends Sort {

	public InsertSort() {
		// TODO Auto-generated constructor stub
	}

	InsertSort(int[] arrays, int range) {
		super(arrays, range);
		// TODO Auto-generated constructor stub
	}

	// 插入。
	@Override
	public int[] sort(int[] array, int length) {
		int left, right, temp;

		for (right = 1; right < length; right++) {
			temp = array[right];
			left = right - 1;
			while (left >= 0 && (temp < array[left])) {
				array[left + 1] = array[left];
				left--;
			}
			array[left + 1] = temp;
		}
		return array;
	}
}


=================================归并排序====================================== 
package sort;

import java.util.Arrays;

public class MergeSort extends Sort {

	public MergeSort() {
		// TODO Auto-generated constructor stub
	}

	MergeSort(int[] arrays, int range) {
		super(arrays, range);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int[] sort(int[] array, int length) {
		// TODO Auto-generated method stub
		if (length == 0 || length == 1) {
			return null;
		}

		int mid = length / 2;
		int[] a = Arrays.copyOfRange(array, 0, mid);
		int[] b = Arrays.copyOfRange(array, mid, array.length);

		sort(a, a.length);
		sort(b, b.length);

		merge(a, b, array);
		return array;
	}

	private void merge(int[] a, int[] b, int[] ary) {
		int i = 0;
		int j = 0;
		int k = 0;
		while (i < a.length && j < b.length) {
			if (a[i] <= b[j]) {
				ary[k++] = a[i++];
			} else {
				ary[k++] = b[j++];
			}
		}

		for (; i < a.length; ++i) {
			ary[k++] = a[i];
		}
		for (; j < b.length; ++j) {
			ary[k++] = b[j];
		}
	}

}


======================================堆排序=================================== 
package sort;

public class HeapSort extends Sort {

	HeapSort() {

	}

	HeapSort(int[] arrays, int range) {
		super(arrays, range);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int[] sort(int[] array, int length) {
		// TODO Auto-generated method stub
		buildHeap(array); // 首先，建一个堆， 此时a[0] 就是最大的元素
		for (int i = length - 1; i > 0; i--) { // 选出最大的元素
			swap(array, 0, i); // 在这之后， i 以及后面的元素都是有序的
			heapify(array, 0, i - 1); // 根元素由于被交换过，所以需要进行一次调整,让他再变成堆。
		}
		return array;
	}

	void buildHeap(int[] array) {
		int n = array.length;
		for (int i = n / 2 - 1; i >= 0; --i) { // n / 2 - 1, 就是最后一个有子节点的元素
			heapify(array, i, n - 1);
		}
	}

	// 判断是否为大顶堆。
	boolean isHeap(int[] a, int i) {
		int n = a.length;
		if (i >= n) {
			return true;
		}
		int left = 2 * i + 1; // 左节点
		int right = 2 * i + 2; // 右节点
		if (left < n && a[left] > a[i]) {
			return false;
		}

		if (right < n && a[right] > a[i]) {
			return false;
		}

		return isHeap(a, left) && isHeap(a, right); // 左右子树也是大顶堆。
	}

	// 不断调整，直到整个数组变成堆。
	// i的左右子树都是堆 (j后面的元素不管，不属于堆), 我们要把他调整成堆。
	void heapify(int[] a, int i, int j) {
		int left = i * 2 + 1;
		int right = i * 2 + 2;
		if (left > j) { // 没有左子树
			return;
		}

		int large = left;
		if (right <= j && a[left] < a[right]) {
			large = right;
		}

		if (a[i] < a[large]) { // 如果根元素比 large小，重新调整。
			swap(a, i, large);
			heapify(a, large, j); // 继续操作large子树。
		}
	}

	private void swap(int[] a, int i, int j) {
		int t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
}


===================================系统排序==================================== 
package sort;

import java.util.Arrays;

public class SystemSort extends Sort {

	public SystemSort() {
		// TODO Auto-generated constructor stub
	}

	SystemSort(int[] arrays, int range) {
		super(arrays, range);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int[] sort(int[] array, int length) {
		// TODO Auto-generated method stub
		Arrays.sort(array);
		return array;
	}

}
iteye_853
关注
java策略模式（排序算法）
12-10
java设计模式中策略模式的一个实例：选择不同的排序算法（①冒泡排序；②插入排序；③选择排序）对数组进行排序。
工厂模式使用排序算法（c++实现）
Emotion的博客
08-02 327
一.设计抽象排序算法基类class AbstractSort{}； 1.析构函数~AbstractSort()和排序算法sort() 设置为虚函数 2.基类公共方法print(),作用为打印数组 3.基类公共方法setNums() 设置基类私有成员nums的值 4.基类公共方法getNums() 获取基类私有成员nums的值 //抽象排序算法 class AbstractSort { private: vector<int> nums; public: AbstractSo...
使用策略模式（strategy pattern）实现多关键字排序(1)
理想、规划局
02-27 610
C语言中函数指针的主要用途是实现Strategy（策略）模式。为了在Java程序设计语言中实现这种模式，声明一个接口来表示该策略，并且为每个具体策略声明一个实现了该接口的类。如果一个具体策略被使用一次，那么通常使用匿名类来声明和实例化这个具体策略。如果一个具体策略需要被到处去以便重复使用，那么它的类通常是一个私有的静态成员类，并且通过一个公有静态final域被导出，其类型为该策略接口。
Java策略模式--复习数组的冒泡排序、选择排序、插入排序
jiliang272的博客
10-23 527
 使用java多态特性实现策略模式，复习数组的三大排序。 public class Sort{ public static void main(String [] args){ int [] array = {4,1,6,8,41,12,45,15,123}; Isort ms = new MaopaoSort(); Isort is = new InsertSort();...
java设计模式之策略模式（Strategy）,简单工厂+策略模式
qq_41496513的博客
11-06 151
java设计模式之策略模式（Strategy）,简单工厂+策略模式 1.简要 策略模式（Strategy）： 定义了算法家族，分别封装起来，让他们直接可以相互替换，从而使得算法的改变不会影响到使用算法的一方。 ...
设计模式(策略与简单工厂结合_排序)手写代码
03-20
本篇文章将聚焦于两种重要的设计模式——策略模式和简单工厂模式，并探讨如何将它们结合应用于排序算法的实现。 **策略模式**是一种行为设计模式，它使你能在运行时改变对象的行为。在策略模式中，一个类的行为或其...
JAVA_Strategy.rar_java 策略模式、工厂模式、桥接模式_severalgdo_strategy
最新发布
09-23
在软件设计模式的世界里，Java 语言提供了丰富的工具来实现各种设计模式，如标题和描述中提到的策略模式、工厂模式以及桥接模式。这些模式是面向对象设计的重要组成部分，帮助开发者解决复杂的问题，提高代码的灵活...
61丨策略模式（下）：如何实现一个支持给不同大小文件排序的小程序？1
08-03
在代码实现上，最初的做法是将所有逻辑集中在`sortFile`函数中，根据文件大小选择不同的排序算法。但这种做法违反了单一职责原则，`sortFile`函数既负责选择排序策略，又负责执行排序。为了解决这个问题，我们可以将...
简单工厂模式-策略模式-反射源码下载
12-17
简单工厂模式、策略模式以及反射是Java编程中非常重要的概念，它们都是软件设计模式和语言特性的典型应用，对于理解和构建高效、可扩展的代码至关重要。 简单工厂模式是一种创建型设计模式，它提供一个工厂方法，...
策略模式 java 实现冒泡、快排、归并三种算法
09-25
用java实现策略模式，strategy Patten,使用三种不同的排序算法实现策略模式，可执行代码，可直接读取文件中需要排序的数据
java策略模式的排序算法例子
04-26
利用java策略模式编写的一个排序方法切换，的小例子。用于学习策略模式是很好的方式。界面写的还可以，仅供大家参考学习
策略模式在实际项目中的应用二
10-10
策略模式在实际项目中的应用二，该测试demo为普通项目，导入build path一下lib目录下的jar包，然后运行测试类即可在控制台看到测试结果
java中排序实现简单的策略模式
weixin_33739523的博客
12-26 252
2019独角兽企业重金招聘Python工程师标准>>> ...
java-简单工厂模式+策略模式的简单应用实现
momingha的博客
08-11 667
首先先来理解一下简单工厂模式和策略模式的概念： 1.简单工厂模式： 简单工厂模式是创建型模式，简单工厂模式的是工厂类根据传入的参数，决定应该创建并且返回哪一个产品类（这些产品类继承自一个父类或接口）的实例。具体的创建过程业务代码不需要关心，简单工厂模式主要用于那些创建对象少的场景。 2.策略模式： 策略模式表示的是在遇到一种问题有多种解法的时候，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。主要用在解决if/else复杂的处理逻辑，易拓展情况下的处理，减少代码臃肿。当然也...
JDP02-[策略模式]-多种排序算法
junife的专栏
11-19 252
一)  策略模式简介       策略模式的结构图如下所示：           二)  Java语言描述       用策略模式实现各种排序算法的调用：   /* * 策略模式（策略构件） * @author junin */ public class Strategy { private StrategyInter strat...
java实现多种排序算法--冒泡排序实现-2种代码
星月情缘的博客
03-07 597
** java排序算法实现-多种排序参考 import java.util.Comparator; /** * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换) * @author nnngu * */ public interface Sorter { /** * 排序 * @param list 待排序的数组 */ ...
策略模式和排序算法
haozhn的博客
06-15 1829
引言常用的排序算法有选择排序，插入排序，冒泡排序，快速排序，归并排序，希尔排序，堆排序这7种。假设现在有7个数组，他们分别需要用到这7种排序方式的其中一个进行排序应该怎么办呢。最常见的办法就是写一个这样的工具类/** * Created by hao on 2016/6/19. */ public class SortHelper { /** * 选择排序 * @pa
设计模式：策略模式，Java集合定制排序的核心思想
07-25 443
前言 前阵子面试的时候，有个面试官问我了解哪些设计模式吗？我说了策略模式。接着他问有哪些场景应用，我又回答他jdk的集合工具类有个排序方法就用到了策略模式，也就是java.util包下的Collections类，该类中有个sort方法，我们可以自定义排序规则实现集合的定制排序，这就是策略模式最直接的应用，说完之后他点点头，料想对我的回答还是比较满意吧，当然我也只是在这道面试题上装装逼而已，毕竟最后...
"设计模式与算法：工厂方法模式的实现与应用
常用的设计模式包括工厂方法模式、单例模式、策略模式、观察者模式等等，每种设计模式都有其独特的用途和优势。 工厂方法模式是一种常用的创建型设计模式，其核心思想是提供一个顶级的工厂接口，然后由具体的子类去...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值