荷兰国旗问题，快速排序，堆排序

已于 2023-02-09 21:54:35 修改
阅读量420 收藏
点赞数
分类专栏： 算法 文章标签： 算法 java 排序算法
于 2020-04-25 16:48:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43912367/article/details/105631850
版权

目录

1.荷兰国旗问题

给定一个数组arr，和一个数num，请把小于num的数放在数组的 左边，等于num的数放在数组的中间，大于num的数放在数组的右边。
要求额外空间复杂度O(1)，时间复杂度O(N)

public class Code_08_NetherlandsFlag {

	public static int[] partition(int[] arr, int l, int r, int p) {
		int less = l - 1;
		int more = r + 1;
		while (l < more) {
			if (arr[l] < p) {
				swap(arr, ++less, l++);
			} else if (arr[l] > p) {
				swap(arr, --more, l);
			} else {
				l++;
			}
		}
		return new int[] { less + 1, more - 1 };
	}

	// for test
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static int[] generateArray() {
		int[] arr = new int[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * 3);
		}
		return arr;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int[] test = generateArray();

		printArray(test);
		int[] res = partition(test, 0, test.length - 1, 1);
		printArray(test);
		System.out.println(res[0]);
		System.out.println(res[1]);

	}
}

具体解释

2.快速排序

2.1经典快排

如果明白了上面的荷兰国旗问题的话，快排就很容易理解了。
荷兰国旗问题是将指定的一个数字放在中间，两边分别是大于它和小于它的数字。我们将指定数字两侧的数字再进行如此操作，循环往复，直到全部有序，就ok了，这就是快速排序！！！
当然，也有可能有人会问，两侧随机的时候，怎么随机指定一个数字？很简单，我们默认每次都指定最后的一个元素即可。

java代码：

package basic_class_01;

import java.util.Arrays;

public class Code_04_QuickSort {

	public static void quickSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		quickSort(arr, 0, arr.length - 1);
	}

	public static void quickSort(int[] arr, int l, int r) {
		if (l < r) {
			
			int[] p = partition(arr, l, r);
			quickSort(arr, l, p[0] - 1);
			quickSort(arr, p[1] + 1, r);
		}
	}

	public static int[] partition(int[] arr, int l, int r) {
		int less = l - 1;
		int more = r;
		while (l < more) {
			if (arr[l] < arr[r]) {
				swap(arr, ++less, l++);
			} else if (arr[l] > arr[r]) {
				swap(arr, --more, l);
			} else {
				l++;
			}
		}
		swap(arr, more, r);
		return new int[] { less + 1, more };
	}

	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			quickSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		quickSort(arr);
		printArray(arr);

	}

}

2.2随机快排

随机快排是对快排的优化，效率更高！
经典快排划出来的左边区域和右边区域，很有可能是不平等的。这样可能每次只搞定一次数，在最差情况下，快排时间复杂为O(n2)，和数据状况有关系！

随机快排，就是在数组中，随机选择一个数字，然后用这个数和数组最后一个元素换位置，这样说，就不能说，轻易找到最差情况，当然也有可能。随机快排的复杂度是一个长期期望的复杂度O(N*logN)，额外控件复杂度O(logN)

代码上面来说，只是加上一行，随机数组中一个数和数组最后的元素的进行交换的代码

swap(arr, l + (int) (Math.random() * (r - l + 1)), r);

3.堆排序

堆排本身就很重要了，但是更重要的是，堆这一个结构！！!

3.1堆

堆这结构其实就是一个完全二叉树。

二叉树我们都知道，就是一棵树下面有俩孩子，那什么是完全二叉树哪？
要么是一个满二叉树或者每一层是从左到右依次补齐的。

什么是满二叉树哪？就是最后一层都是叶节点，剩下的部分两个节点都全。
(注：叶节点就是下面没有节点)

二叉树其实我们可以用数组去表示
举个例子：
在这里插入图片描述
那这到底要怎么对应呢？一个下标为i，它的孩子是什么呢？
2i+1,就是他的左节点
2i+2,就是他的右节点
而一个i他的父节点是什么呢？
（i-1）/2,就是他父节点的小标
所以当你有一个数组，有上面的关系，你就可以脑补出一个完全二叉树。
换句话说，并不存在实际的完全二叉树，他就是数组结构，只是在数组结构中，定义了一个规则，我们可以在这个规则中，产生与之相对应的完全二叉树。

3.2大根堆和小根堆

堆就是完全二叉树，谈到堆，就有一个隐藏含义：到底是大根堆还是小根堆。那他俩都是啥含义呢？
先说大根堆，在一个完全二叉树中，任何一个子树的最大值，都是头部。
举个例子：
在这里插入图片描述
小根堆同理，任何一个子树的最小值，都是头部，就是小根堆。

问题来了，我给你一个数组，你怎么把它调成大根堆？
我们假设有一个数组，把它想象成一个完全二叉树。让它每一个节点的头部，和它的两个孩子做比较，如果大于等于。那就不用动，如果小于，那就让大的那个孩子和头部换位置，以此，循环往复。

java代码：

private static void a(int[] arr) {
        if(arr==null||arr.length<2){
            return;
        }
        //把数组变成大根堆
        for (int i=0;i<arr.length;i++){
            b(arr,i);
        }
    }

    private static void b(int[] arr, int index) {
        while (arr[index]>arr[(index-1)/2]){
            s(arr,index,(index-1)/2);
            index = (index-1)/2;
        }
    }

    private static void s(int[] arr, int x, int y) {
        int t = x;
        x = y;
        y = t;
    }

那将一个数组转化为大根堆的事件复杂度为O(N)

那我们假设数组中有一个值发生变化了，变小了，怎么样调整才能让它继续还是大根堆？

那就找出他的两个孩子中的最大值，让他和他的两个孩子进行比较，如果他大，不用动，如果他小，就和他较大的儿子换位置，以此往复

public static void heapify(int[] arr, int index, int size) {
		int left = index * 2 + 1;
		while (left < size) {
			int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
			largest = arr[largest] > arr[index] ? largest : index;
			if (largest == index) {
				break;
			}
			swap(arr, largest, index);
			index = largest;
			left = index * 2 + 1;
		}
	}

3.3堆排序

第一步：让这个数组变成大根堆
第二步：把最后一个位置和第一个位置做交换
第三步：让堆的大小减一
第四步：在剩下的数组中，做上面改变一个数组的值的过程，就重新调整成大根堆
第五步：把堆顶和数组第二个位置交换
循环往复，减完为止。

package basic_class_01;

import java.util.Arrays;

public class Code_03_HeapSort {

	public static void heapSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			heapInsert(arr, i);
		}
		int size = arr.length;
		swap(arr, 0, --size);
		while (size > 0) {
			heapify(arr, 0, size);
			swap(arr, 0, --size);
		}
	}

	public static void heapInsert(int[] arr, int index) {
		while (arr[index] > arr[(index - 1) / 2]) {
			swap(arr, index, (index - 1) / 2);
			index = (index - 1) / 2;
		}
	}

	public static void heapify(int[] arr, int index, int size) {
		int left = index * 2 + 1;
		while (left < size) {
			int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
			largest = arr[largest] > arr[index] ? largest : index;
			if (largest == index) {
				break;
			}
			swap(arr, largest, index);
			index = largest;
			left = index * 2 + 1;
		}
	}

	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			heapSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		heapSort(arr);
		printArray(arr);
	}

}
weixin_43912367
关注
专栏目录
荷兰国旗问题的解决：额外空间复杂度O(1),时间复杂度O(N)
Smartbbbb的博客
11-11 607
荷兰国旗问题：Dutch National Flag Problem a、给定一个序列arr，和一个数字num，把 > num的放在数组右边,把 <= num的放在数组左边 b、给定一个序列arr，和一个数字num，把>num的放在数组右边,把 < num的放在数组左边，等于的放在数组中间 a，b题目的要求：额外空间复杂度O(1)，时间复杂度O(N) 思路： 题目a思路：对应leftRightPart()方法 ...
左神算法笔记之基于比较的排序——快速排序及堆排序（荷兰国旗问题、堆化）
weixin_43801264的博客
04-06 491
一、快速排序 ①快排1.0，时间复杂度O(N²) 取数组最后一个数num，根据这个num，把数组分成两边，左边是≤num的，右边是＞num的 然后将num插入到≤中最后一个数后，即num的位置确定了 再将左右两边的区域重复上面两步操作，最后全有序（一次确定一个元素的位置） ②快排2.0，时间复杂度O(N²)，基于荷兰国旗问题优化 取数组最后一个数（如最后一个数为5），将数组分成<、=、>三个区域 当排好序后将num和>num的第一个数交换，中间就确定了一批=num的数 最后左右&lt
排序算法--荷兰国旗问题
niceYF的博客
03-04 241
问题1 ：给定一个数组，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数组的右边，要求额外空间复杂度O（1），时间复杂度O（N） 把一个数组分为两个区域，分别为小于等于区域和待定区域。假设num = 4； 1）i指针位置的数小于等于num，交换i指针位置的数和小于等与区域的前一个数 图中所示情况就是3和自己交换，因为i指针是3，小于等于区前一个数也是3 2）i指针位置大于num，i加1就行。 当i到达2的位置时，交换2和5然后小于等于区加1，i加1。 .
算法 - 快速排序 - 荷兰国旗问题
ChenBin113
11-19 248
问题一 给定一个数组 arr，和一个数 num，请把小于等于 num 的数放在数组的左边，大于 num 的数放在数组的右边。 要求额外空间复杂度O(1)，时间复杂度O(N)。 思路：遇到 arr[i] 小于等于 number 的数，交换 index + 1 和 arr[i]，此时 index + 1 位置的数变成小于等于 number，index++；遇到 arr[i] 大于 number 的数，...
算法初级02——荷兰国旗问题、随机快速排序、堆排序，快排的两种方法
byteyoung
09-21 724
1,荷兰国旗 package zuosuanfa; import java.util.Arrays; public class helanguoqi { public static int[] partition(int[]arr,int l,int r,int num) { int less = l-1; int more = r+1; ...
【算法】基于荷兰国旗算法思想上的快速排序实现
weixin_43389122的博客
12-11 330
【算法】基于荷兰国旗算法思想上的快速排序实现荷兰国旗快排思路代码 荷兰国旗 链接：荷兰国旗算法 荷兰国旗中的基准数是选定的，而这里快速排序我们默认每次的基准数都是最后一个数。 快排思路 基准数选定为最后一个数x L用于正在遍历的元素的下标，初始值为0，从左向右遍历，当L>=more时遍历结束。 less用于记录小于x的区域的最右边的下标，初始为-1，代表不存在。 more 用于记录大于 x区...
荷兰国旗问题
10-14
解决荷兰国旗问题的经典算法通常基于快速排序的思路，但针对此问题进行了优化。快速排序的随机化版本在最坏情况下具有O(n log n)的时间复杂度，但在处理荷兰国旗问题时，由于我们只关心特定值的划分，可以进一步优化...
算法笔记——左神初级（2）快速排序、堆排序
现实 理想青年的博客
02-26 997
快速排序 快速排序的核心思想是按基准值分区： 荷兰国旗问题： public static int[] partition(int[] arr, int L, int R, int p) { int less = L - 1; int more = R + 1; while (L < more) { if (arr[L] < p) { swap(arr, ++...
计算机科学导论课程设计 1. 荷兰国旗问题 2. 幻方 3. 链表实现约瑟夫环 4. 逆序对个数
最新发布
11-05
首先，荷兰国旗问题是由Dijkstra提出的经典排序问题，主要目标是将一个数组分为三个部分：小于、等于和大于目标值的元素。此问题通常使用快速选择或三向切分快排来解决，它体现了排序算法中的高效处理能力，有助于...
快速排序 三平均分区法 java_快速排序 三平均划分
weixin_39864101的博客
02-13 605
快速排序也是一种采用分治法解决问题的一个典型应用。在很多编程语言中，对数组，列表进行的非稳定排序在内部实现中都使用的是快速排序。而且快速排序在面试中经常会遇到。本文首先介绍快速排序的思路，算法的实现、分析、优化及改进，最后分析了.NET 中列表排序的内部实现。一 原理快速排序的基本思想如下：对数组进行随机化。从数列中取出一个数作为中轴数(pivot)。将比这个数大的数放到它的右边，小于或等于它的数...
荷兰国旗问题------排序3
qq_43193797的博客
01-31 484
问题一    给定一个数组arr，和一个数num，请把小于等于num的数放在数 组的左边，大于num的数放在数组的右边。 要求额外空间复杂度O(1)，时间复杂度O(N) 思路：遍历的过程指针指向的位置如果小于等于num，则小于等于区域的下一个数和  遍历过程的指针指向的数进行交换   问题二 （荷兰国旗问题） 给定一个数组arr，和一个数num，请把小于num的数放在数组的 左边，...
荷兰国旗问题(对三个数排序)
weixin_42326997的博客
11-24 176
对{1，0，0，2，2，1，0，2}进行排序 算法思路 如图以1为分届小于一的在1的左边，大于1的数在1的右边这样就可以进行三个数的排序。 算法思路： 1、当cur小于划分值的时候：当前数与小于区的下一个数做交换，并且小于区范围扩一、cur+1; 2、当cur等于划分值的时候：cur+1; 3、当cur大于划分值的时候，cur与大于区的前一个做交换，大于区域+1,cur不变。 include<iostream> using namespace std; void swap(int *arr,i
荷兰国旗算法
JunglerOfChina的博客
03-06 708
问题：现有红，白，蓝三个不同颜色的小球，乱序排列在一起，请重新排列这些小球，使得红白蓝三色的同颜色的球在一起。问题转化为：给定数组A[0...N-1]，元素只能取0,1,2三个值，设计算法，使得数组排列成00..0011...1122...222的形式。借鉴快速排序中partition的过程。定义三个指针：begin=0，current=0，end=N-1;A[cur] == 2，则A[cur]与...
算法：快速排序与荷兰国旗问题
m0_47268721的博客
09-22 909
文章目录荷兰国旗算法描述荷兰国旗代码展示快排算法描述快排代码展示 在聊快速排序之前，我们先解释一下荷兰国旗，即把一个数组分成三个部分，我们一般选最后一个元素作为基准值，即大于这个数的全部在左边，小于这个数的全部在右边，等于的在中间。 举个例子：arr{1，5，3，7，4，2，3，4}，选取4做基准值，把他排成{1，3，2，3，4，4，7，5}大于小于区域的数顺序不要求。 荷兰国旗算法描述 首先第一步设less指针为-1，more指针为length-1。你可以想象成less是一个小于区域的右边界而more是大
【左神算法】基础班第二课(一)——荷兰国旗
Rubik_xie
07-19 216
问题：荷兰国旗问题，给定一个数组，让小于0的在左边，大于0的在右边，0在中间 如输入 [1, -2, 3, 0, -3, 0] 输出: [-2, -3, 0, 0, 3, 1] 思路：设置3个游标l = 0, r = n - 1, current = 0;l的左边小于0，r的右边大于0，中间为0 三种情况 a[current] < 0时， swap(a[current++]...
算法学习系列（2）——荷兰国旗问题，快排，堆排，树
zzhou——blog
01-07 691
入门基础21.荷兰国旗问题（用的是快排思想）2.快速排序 1.荷兰国旗问题（用的是快排思想） 提法1：给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。 要求额外空间复杂度O(1)，时间复杂度O(N) 提法2：给定一个数组arr，和一个数num，请把小于num的数放在数组的:左边，等于num的数放在数组的中间，大于num的数放在数组的右边。 要...
荷兰国旗算法及随机快排原理详解
零栀
07-21 557
荷兰国旗问题 给定一个数组arr，和一个数num，请把小于num的数放在数组的 左边，等于num的数放在数组的中间，大于num的数放在数组的 右边。 要求额外空间复杂度O(1)，时间复杂度O(N) 解决思路： 遍历，如果index的值小于num，与less区域的下一个值交换并扩大less区域，index++；如果大于num，则more区域的前一个值交换，并扩大more区域，index不变，继续判断；如果相等，则index++。 代码实现： public static int[] partition(int
荷兰国旗问题快速排序
10-11
快速排序算法可以用来解决荷兰国旗问题。该算法基于分治的思想，通过多次划分和交换元素来达到排序的目的。以下是快速排序算法解决荷兰国旗问题的步骤： 1. 选择一个枢轴元素（一般是数组的最后一个元素）。 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值