八大排序，java代码

冒泡排序

两两比较，每一次都把最大的排在后面

public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int a[] = new int[n + 1];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n - i; j++) {
				if (a[j] > a[j + 1]) {
					int temp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp;
				}
                //用于查看每次的结果
				for (int k = 1; k <= n; k++) {
					System.out.print(a[k] + " ");
				}
				System.out.println();
			}

		}
	}
}

时间复杂度

• 若初始数据是逆序的，则需要进行N-1趟排序。每趟排序都要进行N-i次比较，且每次比较都必须移动三次来达到交换就位置。

  故C=N(N-1)=O(N^2);

• 冒泡排序是一种稳定的算法，即当前后两个数字相等时，不会因为排序而改变相同元素的前后顺序。

冒泡排序的优化

对冒泡排序常见的改进方法是加入标志性变量exchange，用于标志某一趟排序过程中是否有数据交换。

如果该趟没有出现顺序的改变则已经排好序了

否则当初始数据已经是正序的时候，会出现依然要扫描N-1趟并且每趟都要进行N-i次比较

插入排序

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

• 一般是从后往前比较

public class Sort2_zhijie {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int a[] = new int[n + 2];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}
		for (int i = 2; i <= n; i++) {

			int num = a[i];
			int j = i - 1;
			// 从后往前,所有比它大的都往后移
			for (; j >= 1 && a[j] >= num; j--) {
				a[j + 1] = a[j];
			}
			a[j + 1] = num;
			for (int k = 1; k <= n; k++) {
				System.out.print(a[k] + " ");
			}
			System.out.println();
		}

	}
}

时间复杂度

• 直接插入排序的时间复杂度和冒泡的相似，与前面的元素后移有关;当正序时，不用移动前面的元素，直接是O(N)
• 当是逆序的时候，每次插入都要移动前面的元素，故时间复杂度O(N^2)
• 直接插入排序也是稳定的，稳定的理解同上。

希尔排序

算法最开始以一定的步长进行排序，然后会继续以更小的步长进行排序，最终算法以步长为 1 进行排序。当步长为 1 时，算法变为直接插入排序，这就保证了数据一定会被全部排序。

public class Sort3_xier {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int a[] = new int[n + 2];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}

		for (int gap = n >> 1; gap > 0; gap >>= 1) {
			// 在gap之后一个数开始比较
			for (int i = gap + 1; i <= n; i++) {
				int j = i - gap;
				int num = a[i];
				// 直到找到比当前数小的
				for (; j >= 0 && a[j] >= num; j -= gap) {
					a[j + gap] = a[j];
				}
				a[j + gap] = num;
			}
			int res = 0;
			for (int i = 1; i <= n; i++) {
				System.out.print(a[i] + " ");
				res++;
				if (res == gap) {
					System.out.println();
					res = 0;
				}

			}
			System.out.println();
		}
	}
}

时间复杂度

由于算法的步长序列不同，导致最坏的时间复杂度也会不同。

• 当采用的是N/2的步长
• 希尔排序是不稳定的
• 希尔排序的比较次数和移动次数都要比直接插入排序少，当N越大时，效果越明显。

快排

通过一趟排序将要排序的数据分割成独立的两部分：分割点左边都是比它小的数，右边都是比它大的数。

• 先排一部分，再合起来；

代码结构类似树的先序遍历

package Sort0424;

import java.util.Scanner;

public class Sort4_quick {
	/*
	 * 快速排序
	 */
	static int a[];
	static int n;

	static void quick(int l, int r) {
		int mid = (l + r) / 2;
		int i = l, j = r;
		int num = a[mid];
		while (i <= j) {
			while (a[i] < num) {
				i++;
			}
			while (a[j] > num) {
				j--;
			}
			if (i <= j) {
				int temp = a[j];
				a[j] = a[i];
				a[i] = temp;
				i++;
				j--;
			}
		}
		System.out.print("l:" + l + " " + "r:" + r + " " + "mid:::" + mid + "  ");
		for (int k = l; k <= r; k++) {
			System.out.print(a[k] + " ");
		}
		System.out.println();
		if (l < j)
			quick(l, j);
		if (i < r)
			quick(i, r);

	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
		a = new int[n + 2];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}
		quick(1, n);
		for (int i = 1; i <= n; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();

	}

}

时间复杂度

简单选择排序

选择排序：每趟从待排序的记录中选出关键字最小的记录，顺序放在已排序的记录序列末尾，直到全部排序结束为止。

public class Sort5_xuanze {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int a[] = new int[n + 2];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}
		for (int i = 1; i <= n; i++) {
			int index = i;
			for (int j = i + 1; j <= n; j++) {
				if (a[j] < a[index]) {
					index = j;
				}
			}
			int temp = a[i];
			a[i] = a[index];
			a[index] = temp;
			for (int k = 1; k <= n; k++) {
				System.out.print(a[k] + " ");
			}
			System.out.println();
		}
		for (int i = 1; i <= n; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
	}
}

时间复杂度

• 简单选择排序，如果比较长度是N，则一定要进行N（N-1）/2次比较
• 当是正序排列时，则不需要多余的移动
• 当时逆序排列时，需要进行3N(N-1)次移动

空间复杂度

• 需要占用一个临时空间，用来保存最小值

堆排序

（1）根据初始数组去构造初始堆（构建一个完全二叉树，保证所有的父结点都比它的孩子结点数值大）。

（2）每次交换第一个和最后一个元素，输出最后一个元素（最大值），然后把剩下元素重新调整为大根堆。

package Sort0424;

import java.util.Scanner;

public class Sort6_dui {
	static int a[];
	static int n;

	// 建最大堆，需要从最后一个非叶子节点开始
	static void buid_heap(int p) {
		// 从最后一个非叶子节点开始
		for (int i = p; i >= 1; i--) {
			heapify(n, i);
		}
	}

	// 当堆顶被换了之后
	/*
	 * 每个元素被更新之后，都要一直往下走
	 */
	static void heapify(int n, int i) {
		if (i > n) {
			return;
		}
		int son1 = 2 * i;
		int son2 = 2 * i + 1;
		int max = i;
		if (son1 <= n && a[son1] > a[max]) {
			max = son1;
		}
		if (son2 <= n && a[son2] > a[max]) {
			max = son2;
		}
		if (max != i) {
			int temp = a[max];
			a[max] = a[i];
			a[i] = temp;
			heapify(n, max);
		}
	}

	// 将堆顶元素与最后一个元素交换，不用删除，下次的更新范围设置为i-1即可
	static void heap_sort() {
		for (int i = n; i >= 1; i--) {
			int temp = a[i];
			a[i] = a[1];
			a[1] = temp;
			heapify(i - 1, 1);
		}
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
		a = new int[n + 2];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}
		int p = n / 2;
		buid_heap(p);
		for (int i = 1; i <= n; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
		heap_sort();
		for (int i = 1; i <= n; i++) {
			System.out.print(a[i] + " ");
		}
	}

}

时间复杂度

• 建堆的时间

n个结点，从第0层至logN层，对于第i层的2i个点，如果需要往下走logN-i，则把走的所有的步相加得：

• 排序的时间

logN*N

则O(NlogN)

堆排序的优点

当想得到一个序列中第k个最小的元素之前的部分排序序列，最好采用堆排序

归并排序

• 先把很小很小的位置换好然后

  代码结构相当于后序排列

import java.util.Scanner;

public class Sort7_gui {
	static int n;
	static int a[];
	static int c[];

	static void gui_sort(int l, int r) {
		if (l == r)
			return;
		int mid = (l + r) / 2;
		int i = l, j = mid + 1;
		int cnt = l;
		gui_sort(l, mid);
		gui_sort(mid + 1, r);
		while (i <= mid && j <= r) {
			if (a[i] <= a[j]) {
				c[cnt++] = a[i++];
			} else {
				c[cnt++] = a[j++];
				// ans+=mid-i+1;
			}
		}
		while (i <= mid) {
			c[cnt++] = a[i++];
		}
		while (j <= r) {
			c[cnt++] = a[j++];
		}
		for (int k = l; k <= r; k++) {
			a[k] = c[k];
		}
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
		a = new int[n + 1];
		c = new int[n + 1];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}
		gui_sort(1, n);
		for (int i = 1; i <= n; i++) {
			System.out.print(a[i] + " ");
		}
	}
}

时间复杂度

• 归并排序就是一颗二叉树，需要遍历的次数就是二叉树的深度O(N*log2N).（递归的时间复杂度是：递归的深度 * 递归本身的时间复杂度）

空间复杂度

需要一个大小为n的临时存储空间来做处理。

基数排序

//按位数上的大小，依次从个位排到最高位
//存到桶里

import java.util.Arrays;
import java.util.Scanner;

public class Sort8_ji {
	static int n;
	static int a[];

	static int digit(int num, int index) {
		while (--index > 0) {
			num /= 10;
		}
		return num % 10;
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
		a = new int[n + 1];
		int maxn = 0;
		for (int i = 0; i < n; i++) {
			a[i] = scanner.nextInt();
			maxn = Math.max(a[i], maxn);
		}
		// 计算最大多少位
		int count = 0;
		while (maxn > 0) {
			maxn /= 10;
			count++;
		}
		// System.out.println(count);
		// System.out.println(digit(1234567, 4));
		// 用于临时存储数据的数组
		int[][] temp = new int[10][n];
		// 用于每个桶内元素的位置
		int[] counts = new int[10];
		// 进行这么多次比较
		for (int i = 1; i <= count; i++) {
			Arrays.fill(counts, 0);
			for (int j = 0; j < n; j++) {
				int mod = digit(a[j], i);
				temp[mod][counts[mod]] = a[j];
				counts[mod]++;
			} // 存放到新的桶内
			int index = 0;
			// if (i == 1) {
			// // 打印二维数组，测试
			// for (int[] nums : temp) {
			// System.out.println("///");
			// System.out.println(Arrays.toString(nums));
			// }
			// }
			for (int j = 0; j < 10; j++) {
				if (counts[j] != 0) {
					for (int k = 0; k < counts[j]; k++) {
						a[index] = temp[j][k];
						index++;
					}
				}

			}

		}
		for (int i = 0; i < n; i++) {
			System.out.print(a[i] + " ");
		}
	}

}

时间复杂度

• count * N,其中count是数组的最高的位数

空间复杂度

• 10+N ----O(N)