乱序算法: 将整数集合中的元素按一定规则打乱排序，N个相等的数之后从后方不同的数中插入该位置

最近在工作中遇到个打乱算法，需求是一个对象集合，经过一定规则排序后，需要将相同类型的n个元素中插入一个不同类型的元素（从后方元素中查找），网上也没搜索到相应的算法，所以经过一个晚上的思考，最终将此算法安排了。

这里我将该算法分享出来，如果有性能更好的算法，也请大伙一起做个分享，也顺带当做笔记记录下来。

这里我已整数集合为例子：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class OutOfOrder {
	public static void main(String[] args) {
		List<Integer> originalList = new ArrayList<Integer>();
		List<Integer> outOfOrderList = new ArrayList<Integer>();
		Random random = new Random(3);
		for(int i = 0; i < 80; i++){
			originalList.add(random.nextInt(3));
		}
		for(int i = 0; i < 10; i++){
			originalList.add(3);
		}
		System.out.println("原集合："+originalList.toString());
		Integer compareObject = null;
		List<Integer> list = outOfOrder(outOfOrderList, originalList, 3, 0, compareObject);	
		System.out.println("乱序后集合:"+list.toString());
	}
	/**
	 * 
	 * @param outOfOrderList 乱序后的集合
	 * @param originalList	原集合	
	 * @param num	相同的num个元素
	 * @param currentNumber 当前计数
	 * @param compareObject 当前比较对象
	 * @return
	 */
	public static List<Integer> outOfOrder(List<Integer> outOfOrderList, 
			List<Integer> originalList, 
			int num, 
			int currentNumber, 
			Integer compareObject){
		//如果原集合为空，则返回打乱排序后的集合
		if(originalList.size() == 0){
			return outOfOrderList;
		}
		//如果比较对象为空，则原集合中的第一个对象赋值给比较对象
		if(compareObject == null){
			compareObject = originalList.get(0);
		}
		//如果原集合中的第一个元素与比较的元素不相同，则将该元素插入乱序后的集合，并且将该元素移除，当前计数置为1
		if(originalList.get(0) != compareObject){
			outOfOrderList.add(originalList.get(0));
			compareObject = originalList.get(0);
			originalList.remove(0);
			currentNumber = 1;
		}
		//如果原集合中的首元素与比较元素不相同且当前计数与num不相同，则将该元素插入乱序后的集合，并且将该元素移除，当前计数自增1
		else if(originalList.get(0) == compareObject && currentNumber != num){
			outOfOrderList.add(originalList.get(0));
			originalList.remove(0);
			currentNumber ++;
		}
		//如果原集合中的首元素与比较元素不相同且当前计数与num相等，则从原集合后续的元素中找到不相同的元素插入乱序集合，并且将该元素移除，当前计数置为1
		else if(originalList.get(0) == compareObject && currentNumber == num ){
			int origSize = originalList.size();
			int loopCount = 0;
			for (int i = 0; i < originalList.size(); i++) {
				if(originalList.get(i) != compareObject){
					outOfOrderList.add(originalList.get(i));
					compareObject = originalList.get(i);
					originalList.remove(i);
					currentNumber = 1;
					break;
				}
				loopCount ++;
			}
			//若后续集合中都为相同的元素则将所有元素添加至乱序后的集合，并且将原集合中所有元素移除
			if(loopCount == origSize){
				outOfOrderList.addAll(originalList);
				originalList.removeAll(originalList);
			}
		}
		//递归计算
		return outOfOrder(outOfOrderList, originalList, num, currentNumber, compareObject);
	}
}

至此可以实现该算法需求，如果有更快速的算法，请各路大神跟我做个分享