<<数据结构>> 内部排序的java实现

1. 插入排序

算法描述：	从左边开始增大序列，把右边的数插到左边排好序的数字当中，比左边大，比右边小。
稳定性：	稳定
比较次数：	n(n-1)/2
适用场合：	适用于节点个数比较少的场合。

 

package com.sam;

public class InsertionSort {

	public static void insertSort(int[] a, int n) {
		int i, j;
		int t;
		for (i = 1; i < n; i++) {
			printArray(a);
			t = a[i];
			for (j = i - 1; j >= 0 && t < a[j]; j--)
				a[j + 1] = a[j];
			a[j + 1] = t;
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = { 46, 26, 22, 68, 48, 42, 36, 84, 66 };
		int n = 9;
		insertSort(a, n);
		printArray(a);
	}

	public static void printArray(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
}

 

2. 选择排序

算法描述：	向右边减小序列，在所有的数中找一个最小的排在最左边
稳定性：	不稳定
比较次数：	n(n-1)/2
适用场合：	适用于节点个数较少的场合。

package com.sam;

public class SelectionSort {

	public static void selectionSort(int[] a, int n) {
		int i, j, k;
		int t;
		for (i = 0; i < n - 1; i++) {
			printArray(a);			
			k = i;
			for (j = i + 1; j < n; j++)
				if (a[k] > a[j])
					k = j;
			t = a[i];
			a[i] = a[k];
			a[k] = t;
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = { 46, 26, 22, 68, 48, 42, 36, 84, 66 };
		int n = 9;
		selectionSort(a, n);
		printArray(a);
	}

	public static void printArray(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
}

 

3. 冒泡排序

算法描述：	从上往下，大数往下沉，小数往上冒，排一次，最大数沉在最底下。
稳定性：	稳定
比较次数：	n(n-1)/2
适用场合：

package com.sam;

public class BubbleSort {

	public static void bubbleSort(int[] a, int n) {
		int i, j, k;
		n--;
		while (n > 0) {
			j = 0;

			for (i = 0; i < n; i++) {
				if (a[i] > a[i + 1]) {
					k = a[i + 1];
					a[i + 1] = a[i];
					a[i] = k;
					j = i;
				}

			}
			printArray(a);
			n = j;
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = { 46, 26, 22, 68, 48, 42, 36, 84, 66 };
		int n = a.length;
		bubbleSort(a, n);

	}

	public static void printArray(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
}

 

4. 快速排序

算法描述：	第一个和最后一个比，找到比它小的数，不忙，再从左边找到比它大的数，然后从小到大，三个节点重新排序，再递归。
稳定性：	不稳定
比较次数：	1.4nlog2n
适用场合：	对拍好序的节点执行效率最差

package com.sam;

public class QuickSort {

	public static void quick(int[] a, int low, int up) {
		int i, j, t;
		if (low < up) {
			i = low;
			j = up;
			t = a[low];
			while (i != j) {
				while (i < j && a[j] > t)
					j--;
				if (i < j)
					a[i++] = a[j];
				while (i < j && a[i] <= t)
					i++;
				if (i < j)
					a[j--] = a[i];
			}
			a[i] = t;
			printArray(a);
			quick(a, low, i - 1);
			quick(a, i + 1, up);
		}

	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = { 46, 26, 22, 68, 48, 42, 36, 84, 66 };
		int n = a.length;
		quick(a, 0, 8);

	}

	public static void printArray(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
}

 

 

保留行