交换排序——冒泡、快速排序

交换排序——冒泡、快速排序

冒泡

冒泡排序算法的原理如下：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

动图演示

代码实现

package com.kc.c06_sort.test;

import java.util.Arrays;

public class T {
	public static void main(String[] args) {

		int[] arr = { 3, 9, -1, 10, -2 };

		// 冒泡排序的时间复杂度为 O(n^2)

		// 外层循环的次数为 数组长度-1
		for (int i = 0; i < arr.length - 1; i++) {
			boolean flag = false;// 标识变量，表示是否进行过交换
			// 内存循环的次数依次减少，每次大的循环都会将最大的数排在最右侧，所以在下次排序是就无需比较这些数
			for (int j = 0; j < arr.length - 1 - i; j++) {

				// 如果为逆序(从左至右)则调换两者的位置
				if (arr[j] > arr[j + 1]) {

					// 如果进行过交换则将标识变量置为false
					flag = true;

					int temp = arr[j + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}

			if (!flag) {// 如果 flag 为false 则表示在一次的的循环中没有交换一次数据 则可以表明该数组已经为有序排列了就无需再次比较
				break;
			}

			System.out.println("第" + (i + 1) + "轮循环结果：" + Arrays.toString(arr));
		}

	}
}

快排

快速排序
快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。
(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

动图演示

代码演示

package com.kc.c06_sort.test;

import java.util.Arrays;

public class T {
	public static void main(String[] args) {

		int[] arr = { -9, 78, 23, 0, -11, -50, -10, 90, -40, 9 };

		quickSort(arr, 0, arr.length - 1);

	}

	private static void quickSort(int[] arr, int left, int right) {

		int l = left;// 左下标
		int r = right;// 右下标
		int pivot = arr[(left + right) / 2];// 中轴值

		int temp = 0;

		while (l < r) {

			// 在 pivot 的左边一直找，直到找到大于等于 pivot 的值才退出
			while (arr[l] < pivot) {
				l++;
			}

			// 在 pivot 的右边一直找，直到找到小于等于 pivot 的值才退出
			while (arr[r] > pivot) {
				r--;
			}

			// 如果 l>=r 说明 pivot 的左右两边的值，已经按照左边全是小于 pivot 的值，右边全是大于等于 pivot 的值
			if (l >= r) {
				break;
			}

			temp = arr[r];
			arr[r] = arr[l];
			arr[l] = temp;

			// 交换完后 如果 arr[r] = pivot 让 l 向后移动
			if (arr[r] == pivot) {
				l++;
			}

			// 交换完后 如果 arr[l] = pivot 让 r 向前移动
			if (arr[l] == pivot) {
				r--;
			}
		}

		// 如果 l=r 必须 l++ r-- 否则会出现栈溢出
		if (l == r) {
			l++;
			r--;
		}

		// 向右递归
		if (left < r) {
			quickSort(arr, left, r);
		}

		// 向左递归
		if (right > l) {
			quickSort(arr, l, right);
		}
		
		System.out.println(Arrays.toString(arr));

	}
}

图片来源于百度！！！