关于烙饼排序问题的算法与Java实现

最近在看《编程之美》这本书，书里有一个烙饼排序问题。星期五的晚上，一帮同事在希格玛大厦附近的“硬盘酒吧”多喝了几杯。程序员多喝了几杯之后谈什么呢？自然是算法问题。有个同事说：“我以前在餐馆打工，顾客经常点非常多的烙饼。店里的饼大小不一，我习惯在到达顾客饭桌前，把一摞饼按照大小次序摆好——小的在上面，大的在下面。由于我一只手托着盘子，只好用另一只手，一次抓最上面的几块饼，把它们上下颠倒个个儿，反复几次之后，这摞烙饼就排好序了。

在书里给我们讲解了寻找最优解的方案。

但是，在我看到这个问题的时候，我是在想用什么排序方法能将烙饼排序问题解决。

假设盘里有9张饼，大小以次是{1,2,4,7,6,5,3,8,9}，我要将它以次摆好，最后摆成{1,2,3,4,5,6,7,8,9}，且我只能从前面反转饼来排序。

从头第一次遍历，发现1,2是有序的并且是从小到大。

然后找到1,2,之后3的位置，发现如果直接将1,2反转到3之前的位置，那么将会是2,1,3，很明显这是徒劳的，所以先将1,2反置成2,1，这是第一次翻转，让有序数中大的数在外前面。

{1,2,4,7,6,5,3,8,9}----->{2,1,4,7,6,5,3,8,9}

然后找到比最外层大一点数，3，翻转3之前的数。第二次翻转。

{2,1,4,7,6,5,3,8,9}------>{5,6,7,4,1,2,3,8,9}

这样再次遍历，发现前面是5,6,7并且是有序的，将其翻转，第三次翻转，让大的数在前面。

{5,6,7,4,1,2,3，8,9}------>{7,6,5,4,1,2,3,8,9}

然后我们再找比最外大一点的数，8，翻转8之前的数。第四次翻转。

{7,6,5,4,1,2,3,8,9}------->{3,2,1,4,5,6,7,8,9}

这样再次遍历发现前面的3,2,1并且是有序的，而且大的数在外面，就剩下以次翻转，直接将比3大一点的4之前的数翻转。第五次翻转

{3,2,1,4,5,6,7,8,9}------>{,1,2,3,4,5,6,7,8,9}

ok,这次遍历，发现可以从头顺到尾，没毛病，排序结束排序成功

public class CakeSorting {

	private static int[] cakeArray;
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		CakeSorting cs = new CakeSorting();
		cs.SetCakeArray();
		cs.outResult(cakeArray);
		cs.ergodic(cakeArray);
	}
	public int[] SetCakeArray(){
		cakeArray = new int[]{1,2,3,6,5,4,7,8,9};
		return cakeArray;
	}
	public void ergodic(int[] cakeArray){
		//遍历一遍
		/*
		 * 1.从头找数组中已经有序的数
		 * 2.找到翻转点
		 * 3.检测整个数组是否已经有序
		 * */
		int i = 0;
		int value = 0;
		int bigPosition = 0;
		while(true){
			value = cakeArray[i]-cakeArray[i+1];
			if(value ==1 || value ==-1 || value == 0){//说明有序
				i++;
				if(i == cakeArray.length-1){
					if(cakeArray[0] > cakeArray[i]){//倒序
						turnArray(0, cakeArray);
					}
					break;
				}
			}else{//说明无序
				if(!(cakeArray[0] >= cakeArray[i])){//说明最大值不在最外面，先反转，将最大值翻到前面
					cakeArray = turnArray(i+1, cakeArray);
				}
				//开始找比最外层大一点的数值的位置
				bigPosition = findBigPosition(cakeArray[0], cakeArray);
				//找到位置后，开始反转
				cakeArray = turnArray(bigPosition, cakeArray);
				i = 0;
			}
		}
	}
	private int findBigPosition(int n,int[] cakeArray){//寻找比n大一点的数值的位置
		int j = 0;
		int value = 0;
		for(int i = 1;i < cakeArray.length ; i++){
			if(n-cakeArray[i] < 0){
				if(value == 0 && j == 0){//第一次记录
					value = n-cakeArray[i];
				}else{
					if(value >= n-cakeArray[i]){//之前有个数与n差值更小(注意，相减为负数)
						continue;
					}else{
						value = n - cakeArray[i];
					}
				}
				j = i;//记录i的位置
			}else if(n - cakeArray[i] == 0){//如果有大小相同的值，直接返回他的坐标位置
				return i;
			}
		}
		return j ;
	}
	private int[] turnArray(int bigPosition ,int[] cakeArray){
		int temp = 0;
		int length = 0;
		//首先判断这个位置是不是0
		
		if(bigPosition == 0){//是0，说明最大值在最外层，完全反转
			length = cakeArray.length;
			
		}else{//部分反转
			length = bigPosition;
		}
		for(int i = 0; i < length/2 ; i++){
			temp = cakeArray[i];
			cakeArray[i] = cakeArray[length - i - 1];
			cakeArray[length - i - 1] = temp;
		}
		outResult(cakeArray);
		return cakeArray;
	}
	private void outResult(int[] cakeArray){
		for(int i =0 ; i < cakeArray.length ; i ++){
			System.out.print(cakeArray[i] + "---");
		}
		System.out.println();
	}
}