Java冒泡排序与直接选择排序代码随笔

　　冒泡排序：延申的有很多种，有的是先确定最大值放到后面，有的是先确定最小值放到前边，还有就是反过来，先确定最小值的位置，但是本质都是：不断两两比较，交换位置。。。第一趟确定一个最大（最小）值放到前边（后边），第二趟，排除选的最值继续排。。。。趟数是外循环控制，交换位置的事交给内循环。
　　直接选择排序：这个应该比冒泡排序快，因为它内循环只是确定最大（小）索引值，然后在外循环的内部只有一次交换最值，而冒泡排序只要值不一样，每次都要交换相对最值，下面看代码再理解一下。

　　嵌套循环中，一般把外部循环的变量导入到内循环循环条件中，这样，外部循环变量变了，势必会导致内循环循环条件的改变，减少内循环次数。

　　因为刚看了一个简单工厂模式，所以就用工厂模式来试着实践一下排序，含冒泡，直接选择还有一个排序反转（其实不应该归到排序接口里），由于刚刚接触工厂模式，代码中，就只是用的int[ ]型数组，没有考虑其他类型数组及正序/反序，正序/反序就是修改内循环里交换条件的大于小于改变。。

package javafirst;

/**

 * 此接口定义排序方法

 *

 */

interface Sort{

	/**

	 * 排序方法

	 * @param arr 需要排序的int型数组

	 * @return 返回一个int型数组

	 */

	public int[] sort(int[] arr);

}

/**

 *实现冒泡排序

 */

class BubbleSort implements Sort{

	public int[] sort(int[] arr){

		//因为外层for循环是控制循环趟数，从1开始比较直观一些

		for(int i = 1; i < arr.length; i ++){

			for(int k = 0; k < arr.length - i; k++){

				if(arr[k] > arr[k+1]){

					int temp = arr[k];

					arr[k] = arr[k+1];

					arr[k+1] = temp;

				}

			}

		}

		return arr;

	}

}

/**

 *实现直接排序

 */

class SelectSort implements Sort{

	public int[] sort(int[] arr){

		for(int i = 1; i < arr.length; i++){

			int index = 0;

			//此内循环的目的是找出最大值的索引

			for(int k = 1; k <= arr.length - i; k++){

				if(arr[k] > arr[index])

					//这里只是交换索引，而不是交换值

					index = k;

			}

			//当上边内循环循环完毕之后，会选出一个最大值，其索引值为index，然后与数组后边值交换位置

			//这里是值得交换

			int temp = arr[arr.length - i];

			arr[arr.length - i] = arr[index];

			arr[index] = temp;

		}

		return arr;

	}

}

/**

 *实现反转排序

 */

class ReverseSort implements Sort{

	public int[] sort(int[] arr){

		//就是交换数组前后的相对位置

		for(int i = 0; i < arr.length / 2; i ++){

			int temp = arr[i];

			arr[i] = arr[arr.length - 1 - i];

			arr[arr.length - 1 - i] = temp;

		}

		return arr;

	}

}

/**

 *排序类实例工厂

 */

class SortFactory{

	/**

	 * 实例化

	 * @param sortName 排序方式

	 * @return 返回一个Sort实例

	 */

	public Sort createSort(String sortName){

		String str = sortName.toLowerCase();

		Sort sor = null;

		switch (str){

		case "bubblesort":

			sor = new BubbleSort();

			break;

		case "selectsort":

			sor = new SelectSort();

			break;

		case "reversesort":

			sor = new ReverseSort();

			break;

		}

		return sor;

	}

}

/**

 *遍历数组类

 */

class Show{

	public void showArray(int[] arr){

		for(int i : arr){

			System.out.print(i + " ");

		}

		System.out.println();

	}

}

public class Test13 {

	public static void main(String[] args){

		Show show = new Show();

		//使用冒泡排序

		int[] arr1 = new int[]{2,4,5,3,6,1,12,14,17,22,15,18,16,12,13,18,10};

		System.out.println("输出原数组：");

		show.showArray(arr1);

		Sort so1 = new SortFactory().createSort("BubbleSort");

		int[] arrBubble = so1.sort(arr1);

		System.out.println("冒泡排序结果：");

		show.showArray(arrBubble);

		//使用直接排序

		int[] arr2 = new int[]{2,4,5,3,6,1,12,14,17,22,15,18,16,12,13,18,10};

		System.out.println("输出原数组：");

		show.showArray(arr2);

		Sort so2 = new SortFactory().createSort("SELECTSORT");

		int[] arrSelect = so2.sort(arr2);

		System.out.println("直接排序结果：");

		show.showArray(arrSelect);

		//反转排序，得使用排序好的数组

		Sort so3 = new SortFactory().createSort("ReverseSORT");

		int[] arrReverse = so3.sort(arr2);

		System.out.println("反转已排好序数组排序结果：");

		show.showArray(arrReverse);

	}

}

　　输出结果

巴特西

Java冒泡排序与直接选择排序代码随笔

最新文章

热门文章