Sort and Shuffle 排序和打乱

最新推荐文章于 2020-06-09 10:19:02 发布
最新推荐文章于 2020-06-09 10:19:02 发布
阅读量2.7k 收藏
点赞数
分类专栏： Princeton Algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Geurney/article/details/46968805
版权

排序可视化

Sort 排序：


定义数组排序的基本方法：

public abstract class ArraySort {
	public static boolean INCREASE = true;
	public static boolean DECREASE = false;

	protected static <T extends Comparable<? super T>> boolean compare(T a,
			T b, boolean order, Comparator<T> comparator) {
		int cmp = COMPARE(a, b, comparator);
		if (order == INCREASE) {
			return cmp < 0;
		} else {
			return cmp > 0;
		}
	}

	public static <T extends Comparable<? super T>> int COMPARE(T a, T b,
			Comparator<T> comparator) {
		if (comparator != null) {
			return comparator.compare(a, b);
		} else {
			return a.compareTo(b);
		}
	}

	protected static void swap(Object[] array, int i, int j) {
		Object temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}

	public static <T extends Comparable<? super T>> boolean isSorted(T[] array) {
		return isSorted(array, INCREASE, null);
	}

	public static <T extends Comparable<? super T>> boolean isSorted(T[] array,
			boolean order) {
		return isSorted(array, order, null);
	}

	public static <T extends Comparable<? super T>> boolean isSorted(T[] array,
			Comparator<T> comparator) {
		return isSorted(array, INCREASE, comparator);
	}

	public static <T extends Comparable<? super T>> boolean isSorted(T[] array,
			boolean order, Comparator<T> comparator) {
		for (int i = 1; i < array.length; i++) {
			if (compare(array[i], array[i - 1], order, comparator)) {
				return false;
			}
		}
		return true;
	}

	public <T extends Comparable<? super T>> void sort(T[] array) {
		sort(array, INCREASE, null);
	}

	public <T extends Comparable<? super T>> void sort(T[] array, boolean order) {
		sort(array, order, null);
	}

	public <T extends Comparable<? super T>> void sort(T[] array,
			Comparator<T> comparator) {
		sort(array, INCREASE, comparator);
	}

	public abstract <T extends Comparable<? super T>> void sort(T[] array,
			boolean order, Comparator<T> comparator);
}

排序基于Decision Tree，算法至少NlogN。

In-place是说sort用的memory不超过 c*logN.

凡是长距离swap的都是unstable的。

HeapSort 对于cash memory的利用很差，特别是大数组的情况。


1. Selection Sort 选择排序：

每次在剩余的元素中选择最小的，和当前待定排序位置的元素交换位置。Unstable, in-place, O(N^2)

public class SelectionSort extends ArraySort {

	@Override
	public <T extends Comparable<? super T>> void sort(T[] array,
			boolean order, Comparator<T> comparator) {
		for (int i = 0; i < array.length - 1; i++) {
			int base = i;
			for (int j = i + 1; j < array.length; j++) {
				if (compare(array[j], array[base], order, comparator)) {
					base = j;
				}
			}
			swap(array, i, base);
		}
	}

}

2. Insertion Sort 插入排序：

每次将当前元素放到已排序队列的合适位置，利用元素交换，自后向前，逐个比较。Stable, in-palce, O(N^2)

public class InsertionSort extends ArraySort {

	@Override
	public <T extends Comparable<? super T>> void sort(T[] array,
			boolean order, Comparator<T> comparator) {
		for (int i = 1; i < array.length; i++) {
			int j = i;
			while (j > 0) {
				if (compare(array[j], array[j - 1], order, comparator)) {
					swap(array, j, j - 1);
					--j;
				} else {
					break;
				}
			}
		}
	}

}

3. Shell Sort:

每次将给定间隔的元素进行插入排序，间隔为3x+1。 Unstable, in-place, O(N^1.5)

public class ShellSort extends ArraySort {

	@Override
	public <T extends Comparable<? super T>> void sort(T[] array,
			boolean order, Comparator<T> comparator) {
		int N = array.length;
		int step = 1;
		while (step < N / 3) {
			step = 3 * step + 1;
		}
		while (step >= 1) {
			for (int i = step; i < N; i++) {
				for (int j = i; j >= step
						&& compare(array[j], array[j - step], order, comparator); j -= step) {
					swap(array, j, j - step);
				}
			}
			step = step / 3;
		}
	}

}


4. Merge Sort  归并排序：

树形结构，依次将两个有序数组合并成一个。Stable, O(NlgN)

O(N) = O(N/2)+O(N/2)+N

Top-down 递归：

public class MergeSort extends ArraySort {

	// Recursive Merge Sort
	@Override
	public <T extends Comparable<? super T>> void sort(T[] array,
			boolean order, Comparator<T> comparator) {
		@SuppressWarnings("unchecked")
		T[] aux = (T[]) new Comparable[array.length];
		sort(array, aux, 0, array.length - 1, order, comparator);
	}

	private static <T extends Comparable<? super T>> void merge(T[] array,
			T[] aux, int start, int mid, int end, boolean order,
			Comparator<T> comparator) {
		int i = start;
		int j = mid + 1;
		int k = start;
		while (true) {
			if (compare(array[j], array[i], order, comparator)) {
				aux[k++] = array[j++];
			} else {
				aux[k++] = array[i++];
			}
			if (i == mid + 1) {
				while (j <= end) {
					aux[k++] = array[j++];
				}
				break;
			}
			if (j == end + 1) {
				while (i <= mid) {
					aux[k++] = array[i++];
				}
				break;
			}
		}
		System.arraycopy(aux, start, array, start, end - start + 1);
	}

	private static <T extends Comparable<? super T>> void sort(T[] array,
			T[] aux, int start, int end, boolean order, Comparator<T> comparator) {
		if (end - start + 1 < 8) {
			insertionSort(array, start, end, order, comparator);
			return;
		}
		int mid = start + ((end - start) >> 1);
		sort(array, aux, start, mid, order, comparator);
		sort(array, aux, mid + 1, end, order, comparator);
		if (!compare(array[mid + 1], array[mid], order, comparator)) {
			return;
		}
		merge(array, aux, start, mid, end, order, comparator);
	}

	private static <T extends Comparable<? super T>> void insertionSort(
			T[] array, int start, int end, boolean order,
			Comparator<T> comparator) {
		for (int i = start; i <= end; i++) {
			for (int j = i; j > 0; j--) {
				if (compare(array[j], array[j - 1], order, comparator)) {
					swap(array, j, j - 1);
				} else {
					break;
				}
			}
		}
	}

}

Divide and Conquer 方法。aux作为辅助数组用于暂存，只作一次声明。less（后，前）来保证stable。每次merge后要将aux拷贝回原array。

优化：

1. 当数组长度小于8时用插入排序。

2. 两段排序后，当第一段最后的元素不大于第二段第一个元素时，不用merge。

Bottom-up merge sort 非递归：

public static <T extends Comparable<? super T>> void sortBU(T[] array, boolean order, Comparator<T> comparator) {
	int N = array.length;
	@SuppressWarnings("unchecked")
	T[] aux = (T[]) new Comparable[array.length];
	for (int size = 1; size < N; size <<= 1) {
		for (int start = 0; start < N - size; start += size << 1) {
			merge(array, aux, start, start + size - 1, Math.min(start + (size << 1) - 1, N - 1), order, comparator);
		}
	}
}

树形结构自下而上，每两个相邻大小为size的数组进行归并。end要注意，最后一个数组大小够不够size。

5. Quick Sort 快排：

每次分割两部分，左边都比分割点小，右边都比分割点大。

普通Quick Sort：

public class QuickSort extends ArraySort {

	/**** Normal Quick Sort ****/
	@Override
	public <T extends Comparable<? super T>> void sort(T[] array, boolean order, Comparator<T> comparator) {
		sort(array, 0, array.length - 1, order, comparator);
	}

	private static <T extends Comparable<? super T>> void sort(T[] array,
			int start, int end, boolean order, Comparator<T> comparator) {
		if (end - start + 1 <= 10) {
			insertionSort(array, start, end, order, comparator);
			return;
		}
		int mid = partition(array, start, end, order, comparator);
		sort(array, start, mid - 1, order, comparator);
		sort(array, mid + 1, end, order, comparator);
	}

	private static <T extends Comparable<? super T>> int partition(T[] array,
			int start, int end, boolean order, Comparator<T> comparator) {
		int i = start;
		int j = end + 1;
		while (true) {
			// array[start] >= array[++i]
			while (compare(array[++i], array[start], order, comparator)) {
				if (i == end) {
					break;
				}
			}
			// array[start] < array[--j]
			while (compare(array[start], array[--j], order, comparator)) {
				if (j == start) {
					break;
				}
			}
			if (i >= j) {
				break;
			}
			swap(array, i, j);
		}
		swap(array, start, j);
		return j;
	}

	private static <T extends Comparable<? super T>> void insertionSort(
			T[] array, int start, int end, boolean order,
			Comparator<T> comparator) {
		for (int i = start; i <= end; i++) {
			for (int j = i; j > 0; j--) {
				if (compare(array[j], array[j - 1], order, comparator)) {
					swap(array, j, j - 1);
				} else {
					break;
				}
			}
		}
	}
}
3-way Quick Sort:
循环中分割点一直移动，与分割点相等的元素会和分割点排在一起。有利于处理duplicate。 
public static <T extends Comparable<? super T>> void sort3Way(T[] array,
			boolean order, Comparator<T> comparator) {
	sort3(array, 0, array.length - 1, order, comparator);
}

public static <T extends Comparable<? super T>> void sort3(T[] array,
		int start, int end, boolean order, Comparator<T> comparator) {
	if (end - start + 1 <= 10) {
		insertionSort(array, start, end, order, comparator);
		return;
	}
	int lt = start;
	int gt = end;
	T v = array[start];
	int i = start;
	while (i <= gt) {
		int cmp = COMPARE(array[i], v, comparator);
		if (order == INCREASE) {
			if (cmp < 0) {
				swap(array, lt++, i++);
			} else if (cmp > 0) {
				swap(array, i, gt--);
			} else {
				i++;
			}
		} else {
			if (cmp < 0) {
				swap(array, i, gt--);
			} else if (cmp > 0) {
				swap(array, lt++, i++);
			} else {
				i++;
			}
		}
	}
	sort3(array, start, lt - 1, order, comparator);
	sort3(array, gt + 1, end, order, comparator);
}

6. 堆排序

建立最大堆，然后依次把堆顶元素放到末尾。

public static <T extends Comparable<T>> void sort(T[] array) {
		int tail = array.length - 1;
		// 建立heap
		for (int i = array.length / 2 - 1; i >= 0; i--) {
			percolateDown(array, i, tail);
		}
		// 排序。依次将最大值移除堆放在数组末尾。通过tail控制堆大小
		while(tail > 0) {
			swap(array, 0, tail--);
			percolateDown(array, 0, tail);
		}
	}

	private static <T extends Comparable<T>> void percolateDown(T[] array, int k, int tail) {
		// 初始化max为左child
		int max = k * 2 + 1;
		if (max > tail) {
			return;
		}
		// 如果右child存在，且大，则max为右child。
		if (max + 1 <= tail && array[max + 1].compareTo(array[max]) > 0) {
			max = max + 1;
		}
		if (array[k].compareTo(array[max]) < 0) {
			swap(array, k, max);
			k = max;
			percolateDown(array, k, tail);
		}
	}

	private static <T> void swap(T[] array, int i, int j) {
		T temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}

Shuffle 打乱：

定义接口：

public interface MyShuffle {
	public <T> void shuffle(T[] array);
}

1. Sort Shuffle 排序打乱：

将每个元素给定一个随机值，将值排序，则元素被打乱

public class SortShuffle implements MyShuffle {
	@Override
	public <T> void shuffle(T[] array) {
		int N = array.length;
		HashMap<Double, T> map = new HashMap<Double, T>();
		double[] val = new double[N];
		for (int i = 0; i < N; i++) {
			val[i] = Math.random() + Math.random();
			map.put(val[i], array[i]);
		}
		Arrays.sort(val);
		for (int i = 0; i < N; i++) {
			array[i] = map.get(val[i]);
		}
	}
}


2. Knuth Shuffle 逐步打乱：

每次当前元素和前面（含自身）的元素随机交换。

public class KnuthShuffle implements MyShuffle {
	public static <T> void swap(T[] array, int i, int j) {
		T temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
	
	@Override
	public <T> void shuffle(T[] array) {
		int N = array.length;
		Random rand = new Random();
		for (int i = 1; i < N; i++) {
			swap(array, i, rand.nextInt(i + 1));
		}
	}
}

Select 选择：

在数组中选择大小为第k的数字。

定义接口：

public interface MySelect {
	// Check if a < b
	public default <T extends Comparable> boolean less(T a, T b) {
		// public default boolean less(Comparable a, Comparable b)
		return a.compareTo(b) < 0;
	}

	public default <T> boolean less(T a, T b, Comparator<T> comparator) {
		return comparator.compare(a, b) == -1;
	}

	// Swap i and j in array
	public default <T> void swap(T[] array, int i, int j) {
		T temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}

	// Sort method
	public <T> Comparable<T> select(Comparable<T>[] array, int k);

	public <T> T select(T[] array, int k, Comparator<T> comparator);

}

1. Quick Select 快速选择：

基于Quick Select 快排。 
public class QuickSelect implements MySelect {
	@Override
	public <T> Comparable<T> select(Comparable<T>[] array, int k) {
		int start = 0;
		int end = array.length - 1;
		while (start < end) {
			int mid = partition(array, start, end);
			if (mid < k) {
				start = mid + 1;
			} else if (mid > k) {
				end = mid - 1;
			} else {
				return array[k];
			}
		}
		return array[k];
	}

	@Override
	public <T> T select(T[] array, int k, Comparator<T> comparator) {
		int start = 0;
		int end = array.length - 1;
		while (start < end) {
			int mid = partition(array, start, end, comparator);
			if (mid < k) {
				start = mid + 1;
			} else if (mid > k) {
				end = mid - 1;
			} else {
				return array[k];
			}
		}
		return array[k];
	}

	private <T> int partition(Comparable<T>[] array, int start, int end) {
		int i = start;
		int j = end + 1;
		while (true) {
			// array[start] >= array[++i]
			while (less(array[++i], array[start])) {
				if (i == end) {
					break;
				}
			}
			// array[start] < array[--j]
			while (less(array[start], array[--j])) {
				if (j == start) {
					break;
				}
			}
			if (i >= j) {
				break;
			}
			swap(array, i, j);
		}
		swap(array, start, j);
		return j;
	}

	private <T> int partition(T[] array, int start, int end,
			Comparator<T> comparator) {
		int i = start;
		int j = end + 1;
		while (true) {
			// array[start] >= array[++i]
			while (less(array[++i], array[start], comparator)) {
				if (i == end) {
					break;
				}
			}
			// array[start] < array[--j]
			while (less(array[start], array[--j], comparator)) {
				if (j == start) {
					break;
				}
			}
			if (i >= j) {
				break;
			}
			swap(array, i, j);
		}
		swap(array, start, j);
		return j;
	}
}



Geurney
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Shell脚本实现乱序排列文件内容的多种方法（洗牌问题）
09-15
主要介绍了Shell脚本实现乱序排列文件内容的多种方法（洗牌问题）,本文给出3个Shell脚本和一个Python脚本解决乱序排列文件内容问题,需要的朋友可以参考下
shuffle-and-sort
03-06
综上所述，"shuffle-and-sort"涵盖了数据处理的两个关键步骤，即随机打乱和有序排列，这些在前端开发中有着广泛的应用，尤其是在增强用户体验和创建动态效果方面。结合CSS，我们可以将这些抽象的操作转化为直观且...
hadoop shuffle过程
后知后觉的it路
03-18 170
    1 处理过程图：       　　MapReduce确保每个reducer的输入都按键排序。系统执行排序的过程——将map输出作为输入传给reducer——称为shuffle。shuffle属于不断被优化和改进的代码库的一部分，从许多方面来看，shuffle是MapReduce的“心脏”，是奇迹发生的地方。事实上，shuffle这个说法并不准确。因为在某些语境中，它只代...
shuffle过程中sort总结
浩先生的博客
03-03 4465
写在前面的话： 新学期开学想重新复习一下Hadoop的知识，不断更新自己的知识库，在今天晚上阅读的过程中发现，有人已经总结了Mapreduce在shuffle过程中sort的实施。我以前从来都没有深入探究过sort过程应用的算法，以及sort的次数。今天我将其总结一下： 排序贯穿于Map任务和Reduce任务，是MapReduce非常重要的一环，排序操作属于MapReduce计算
shuffle和排序
qq_34796981的博客
01-26 690
shuffle概述： MapReduce的Map阶段已经按照key来排好序。系统执行排序的过程---Map作为Reduce的输入，这个过程称为shuffle（洗牌）。  了解shuffle的过程有利于我们更好的掌握MapReduce的过程从而能够进行调优。从许多方面来看shuffle 是Map-Reduce的心脏，是奇迹发生的地方。  MapReduce的shuffle过程如下图： Ma
MapReduce的工作机制
awe12arisdadfjkv的专栏
07-10 188
MapReduce作业的运行过程包含4个独立的实体： 1）Client:提交MapReduce作业.（2）JobTracker：协调作业的运行。（3）TaskTracker:运行作业划分后的Map任务或Reduce任务。（4）Shared FileSystem(一般为HDFS），用来在其他实体间共享作业文件。     1.作业的提交 Job的waitForCompletion(tru...
排序算法-基于Java实现的排序算法之BogoSort实现.zip
最新发布
03-27
在上述代码中，`sort`方法负责整个排序过程，它会一直调用`shuffle`方法对数组进行随机打乱，直到数组通过`isSorted`方法验证为已排序。`isSorted`方法检查数组中的每个元素是否大于前一个元素，如果是，则返回false...
ddz.zip_java 斗地主发牌与排序
09-20
3. 使用Collections.sort()函数，传入玩家的手牌列表和自定义的比较器，对玩家的手牌进行排序。 除了基本的发牌和排序，斗地主游戏还有其他高级功能，例如判断是否可以出牌、计算牌型等。这些功能可以通过扩展上述...
排序
02-12
- 使用`Collections.shuffle()`在排序前打乱数据，可以提高快速排序等算法的平均性能。 - 考虑数据特性，例如如果数据已部分排序，插入排序可能比高级算法更快。 5. 实际应用： - 数据分析：排序可以帮助快速...
php常用经典函数集锦【数组、字符串、栈、队列、排序等】
10-16
- `shuffle()`：随机打乱数组元素的顺序。 - `is_array()`：检查变量是否为数组，返回布尔值。 - `array_search()`：根据值搜索数组，返回匹配项的键，区分大小写可以通过第三个参数设置。 - `array_keys()`：...
Shuffle和排序
qiezikuaichuan的专栏
09-28 652
MR确保每个reduce 的输入都是按键排序的，系统执行排序的过程（即map输出作为输入传给reduce）称为shuffle，， shuffle术语不断被优化和改进的代码库的一部分 ，从许多方面来看， shuffle是MR的心脏， 是奇迹发生的地方。 1、map端   map函数开始产生输出时， 并不是简单的将它写到磁盘， 这个过程 更加复杂，他利用缓冲的方式 写到内存中并处于效率
Shuffle和排序
njufighter的专栏
06-04 596
shuffle和排序 MapReduce确保每个Reducer的输入都按照键排序。系统执行排序的过程--将map输出作为输入传给reducer--称为shuffle。 Map端 每个Map任务都有一个Ring Buffer，用于存储任务的输出。一旦Buffer内容达到阈值，一个后台线程便开始把内容写到磁盘中（按轮询方式写到指定子目录下）。在写磁盘过程中，map输出继续被写到缓冲区，但如果在此
shuffle与排序
caoxiaofang0703的专栏
04-25 418
将shuffle http://langyu.iteye.com/blog/992916
Hadoop 之 Shuffle and Sort
乄浅醉的专栏
05-31 2625
Mapreduce 确保每个reducer的input都是按照key 排序的。系统将 map ouputs 变成 reduce inputs输入的过程被称为 shuffle。shuffle是Mapreduce的 心脏，是奇迹发生的地方。Map side当 map函数开始产生输出时，并不简单的将它写到磁盘。它利用buffer的方式写到内存，并除以效率的考虑，进行预排序。 每个map任务都有一个环形的
spark的shuffle（hash shuffle and sort shuffle）
hyy_blog
06-09 193
可以对比hadoop shuffle spark是对mapreduce的封装 SparkShuffle： SparkShuffle概念 reduceByKey会将上一个RDD中的每一个key对应的所有value聚合成一个value，然后生成一个新的RDD，元素类型是<key,value>对的形式，这样每一个key对应一个聚合起来的value。 问题：聚合之前，每一个key对应的value不一定都是在一个partition中，也不太可能在同一个节点上，因为RDD是分布式的弹性...
Hadoop MapReduce Shuffle and Sort
Nathan Yan
11-21 1035
Hadoop 确保每个reduce 的输入都是按 key 排序的。系统执行排序的过程称为shuffle. Map 端，map 产生输出时，并不是简单的把数据写到磁盘。会先缓冲在内存中，并进行一些预排序。 每个map 任务都有一个环形内存缓冲区，默认为100M，通过io.sort.mb设置，一旦缓冲区内容达到80%(io.sort.spill.percent，设置为0.80)，后台线
shuffle & sort解释
BlackWing
04-16 189
转载请标明出处：http://blackwing.iteye.com/blog/1848401 MR任务，充分利用了缓存进行读写。 1）map端 每个map任务，都会先把数据写到一个环形缓存中，该缓存默认大小是100MB，由io.sort.mb（默认值是100MB）和io.sort.spill.percent（默认值是0.8）共同决定。在默认情况下，当缓存达到80MB时，后台线程就开...
MapReduce Shuffle and Sort职责
bigdata
10-15 117
1。决定Mapper的输出到那个Reducer,是由Partition决定的 2。Reducer接收到的key都是排序好的
Map集合的顺序问题
weixin_42286273的博客
12-02 5224
如果把一个有顺序的list集合放入到map中，ta还会保持原来的顺序吗？ import java.util.*; /** * map集合的顺序问题 * @author liuyu */ public class MapSortTest { public static void main(String[] args){ String[] dateArr = {"2...
shuffle sort
09-25
shuffle是一个方法，它可以对集合中的元素进行随机...在给定的示例中，get_sort方法接受一个List参数，并使用Collections.sort方法对其进行升序排序。该方法将列表中的元素按照升序进行排序，并返回一个排序后的列表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值