multiplesortinganimationpainter.java

用JAVA实现排序等简单算法的演示

		if (useHeapAnimator()) {
			heapAnimator.showMoveElementScene(fromIndex, toIndex);
			if (smallAreaAnimator != null) {
				animationDriver.clear();
				smallAreaAnimator.createMoveElementAnimation(fromIndex, toIndex);
				animationDriver.run();
			}
		} else {
			animationDriver.clear();
			if (smallAreaAnimator != null) smallAreaAnimator.createMoveElementAnimation(fromIndex, toIndex);
			mainAreaAnimator.createMoveElementAnimation(fromIndex, toIndex);
			animationDriver.run();
		} 
	}

	/**
	 * 使用动画展示被选中元素与 index 处元素的交换。注意，堆排序应该不会展示这种情况！
	 */
	public void showSwapSelectedScene(int index) {
		infoAnimator.incSwapCounter();

		animationDriver.clear();
		if (smallAreaAnimator != null) smallAreaAnimator.createSwapSelectedAnimation(index);
		mainAreaAnimator.createSwapSelectedAnimation(index);
		animationDriver.run();
		if (smallAreaAnimator != null) smallAreaAnimator.swapElementView(index);
		mainAreaAnimator.swapElementView(index);
		Animator.sleep(localController.stepDelay);
	}

	/**
	 * 使用动画展示被选中元素与 index 处元素的比较
	 */
	public void showCompareSelectedScene(int index) {
		infoAnimator.incCompareCounter();
		
		if (smallAreaAnimator != null) smallAreaAnimator.showCompareSelectedScene(index);
		mainAreaAnimator.showCompareSelectedScene(index);
	}

	/**
	 * 设置正被选中的元素的颜色值，然后驱动视图在屏幕上作相应的修改，从而使用特别的颜色展示正被选中的元素
	 * @param index 待选中的元素
	 */
	public void showSelectScene(int index) {
		infoAnimator.incSelectCounter();
		
		if (smallAreaAnimator != null) smallAreaAnimator.showSelectScene(index);
		mainAreaAnimator.showSelectScene(index);
		Animator.sleep(localController.stepDelay);
	}

	/**
	 * 使用动画展示放置被选中元素到 index 处，也就是将被选中的元素移动到 index 处
	 */
	public void showPlaceScene(int index) {
		infoAnimator.incMoveCounter();

		if (useHeapAnimator()) {
			heapAnimator.showPlaceScene(index);
			if (smallAreaAnimator != null) {
				animationDriver.clear();
				smallAreaAnimator.createPlaceAnimation(index);
				smallAreaAnimator.showNormalColor(index);
				animationDriver.run();
				Animator.sleep(localController.stepDelay);
			}
		} else {
			animationDriver.clear();
			if (smallAreaAnimator != null) smallAreaAnimator.createPlaceAnimation(index);
			mainAreaAnimator.createPlaceAnimation(index);
			animationDriver.run();
			if (smallAreaAnimator != null) smallAreaAnimator.showNormalColor(index);
			mainAreaAnimator.showNormalColor(index);
			Animator.sleep(localController.stepDelay);
		}
	}

	/**
	 * 展示快速排序或合并排序时正在排序或合并的数组范围
	 */
	public void showSortingScope(int startIndex, int endIndex) {
		if (smallAreaAnimator != null) smallAreaAnimator.showSortingScope(startIndex, endIndex);
		if (!localController.useDotViewInMainArea) mainAreaAnimator.showSortingScope(startIndex, endIndex);
	}

	/**
	 * 展示快速排序时用于划分时的元素，该元素是 index 处的元素
	 */
	public void showBaseLine(int index) {
		if (smallAreaAnimator != null) smallAreaAnimator.showBaseLine(index);
		if (!localController.useDotViewInMainArea) mainAreaAnimator.showBaseLine(index);
	}
	
	/**
	 * 使用动画展示合并排序时，将startIndex（包括） 到 endIndex（包括）处的元素从合并用的临时数组拷贝回待排序数组
	 */
	public void showCopyMergeDataScene(int startIndex, int endIndex) {
		infoAnimator.incMoveCounter(endIndex - startIndex + 1);
		mergeAnimator.showCopyMergeDataScene(startIndex, endIndex);
	}

	/**
	 * 使用动画展示合并排序时，将待排序数组中 dataIndex 处的元素拷贝到合并用的临时数组的 mergeIndex 处
	 */
	public void showCopyDataScene(int mergeIndex, int dataIndex) {
		infoAnimator.incMoveCounter();
		mergeAnimator.showCopyDataScene(mergeIndex, dataIndex);
	}
	

	public void setExitMode(int mode) {
		exitMode = mode;
	}
	
	/**
	 * 监听排序按钮的监听器
	 *
	 */
	private class SortActionListener implements ActionListener {
		private int type = SortingDriver.BUBBLE_SORT;
		public SortActionListener(int sortType) {
			type = sortType;
		}
		
		public void actionPerformed(ActionEvent evt) {
			if (type == SortingDriver.EXIT_SORT) {
				if (exitMode < 0) System.exit(exitMode);
				
				for (int i = 0; i < buttonName.length; i++) {
					sortButton[i].setEnabled(false);
					sortButton[i].setVisible(false);
				}
				for (int i = 0; i < toBlock.length; i++) toBlock[i].setEnabled(true);
				if (smallAreaAnimator != null) {
					smallAreaAnimator.hide();
					smallAreaAnimator.update();
				}
				if (mainAreaAnimator != null) {
					mainAreaAnimator.hide();
					mainAreaAnimator.update();
				}
				if (infoAnimator != null) {
					infoAnimator.hide();
					infoAnimator.update();
				}
				return;
			}
			
			currentSortorType = type;
			selectAnimator();
			
			// 在演示过程中不允许再按启动按钮
			for (int i = 0; i < buttonName.length; i++) sortButton[i].setEnabled(false);
			infoAnimator.clearCounter();
			infoAnimator.setStartTime();

			SortingDriver driver = new SortingDriver(type, localController.dataSize, localController.maxDataValue);
			driver.start();							// 以新的线程方式启动选择排序算法
		}
	}
	
	/**
	 * 根据所选中的排序，选择合适的演示器
	 *
	 */
	private void selectAnimator() {
		if (useMergeAnimator()) {
			// 合并排序不使用小区域的演示器，因为它不能展示合并的过程，所以如果原先小区域有演示器的话，
			// 先需要将其隐藏起来，并刷新一次屏幕
			if (smallAreaAnimator != null) {
				smallAreaAnimator.hide();
				smallAreaAnimator.update();
			}
			smallAreaAnimator = null;				
			mainAreaAnimator = mergeAnimator;
		} else if (useHeapAnimator()) {
			smallAreaAnimator = boxAnimator;
			smallAreaAnimator.show();		// 小区域的演示器可能被隐藏，所以要先显示出来
			mainAreaAnimator = heapAnimator;
		} else  {
			smallAreaAnimator = boxAnimator;
			smallAreaAnimator.show();		// 小区域的演示器可能被隐藏，所以要先显示出来
			mainAreaAnimator = rectAnimator;
		}
		smallArea.setAnimator(smallAreaAnimator);
		mainArea.setAnimator(mainAreaAnimator);
	}

	/**
	 * 判断是否该使用堆排序的树型演示器，只有在选中堆排序，且数组元素不是很多的时候才使用该演示器
	 */
	private boolean useHeapAnimator() {
		if (currentSortorType == SortingDriver.HEAP_SORT && localController.dataSize < 64) return true;
		else return false;
	}
	
	/**
	 * 判断是否该使用合并排序 
	 */
	private boolean useMergeAnimator() {
		if (currentSortorType == SortingDriver.MERGE_SORT) return true;
		else return false;
	}
}