- 直接插入排序:
- 算法概念
- 每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。
- 算法思想
- 假设待排序的记录存放在数组R[1..n]中。初始时，R[1]自成1个有序区，无序区为R[2..n]。从i=2起直至i=n为止，依次将R[i]插入当前的有序区R[1..i-1]中，生成含n个记录的有序区
- 实现思路
- 用一个临时变量temp存储第i个元素（i>=1，下标从0开始）
- 比较R[i] 和R[i+1]，如果R[i+1].compareTo(R[i])<0,则R[i+1] = R[i],即比R[i+1]的集合元素依次往右移动一个单位
- 将temp的值赋给R[i]
- 实现代码
/** * @desc 直接插入排序 * @autor lhli * @modify 2016-7-20 * * @param original 需要排序的数组 * @param from 起始位置，以0为基准 * @param length 数据长度 * @return */ public static void sisort(String[] original, int from, int length) throws Exception { if (from < 0 || length < 0 || from + length > original.length) { throw new IllegalArgumentException("Array out of bound ."); } for (int i = from + 1; i < from + length; i++) { String temp = original[i]; int j = i - 1; while (j >= 0) { if (temp.compareTo(original[j]) < 0) { original[j + 1] = original[j]; } else { break; } j--; } original[j + 1] = temp; } }
- 算法概念
-
希尔排序
- 算法概念
- 又称为缩小增量排序，输入插入排序算法，是对直接排序算法的一种改进。本文介绍希尔排序算法。
对于插入排序算法来说，如果原来的数据就是有序的，那么数据就不需要移动，而插入排序算法的效率主要消耗在数据的移动中。因此可知：如果数据的本身就是有序的或者本身基本有序，那么效率就会得到提高。
- 又称为缩小增量排序，输入插入排序算法，是对直接排序算法的一种改进。本文介绍希尔排序算法。
- 算法思想
- 将需要排序的序列划分成为若干个较小的子序列，对子序列进行插入排序，通过则插入排序能够使得原来序列成为基本有序。这样通过对较小的序列进行插入排序，然后对基本有序的数列进行插入排序，能够提高插入排序算法的效率。
- 实现思路
- 在希尔排序中首先解决的是子序列的选择问题。对于子序列的构成不是简单的分段，而是采取相隔某个增量的数据组成一个序列。增量一般的选择原则是：取上一个增量的一半作为此次序列的划分增量。首次选择序列长度的一半为增量。
先假如：数组的长度为10，数组元素为：25、19、6、58、34、10、7、98、160、0
整个希尔排序的算法过程如下如所示：
上图是原始数据和第一次选择的增量 d = 5。本次排序的结果如下图：
上图是第一次排序的结果，本次选择增量为 d=2。 本次排序的结果如下图：
当d=1 是进行最后一次排序，本次排序相当于冒泡排序的某一次循环。最终结果如下：
在实际使用过程中，带排序的数据肯定不是只有十个，但是上述是希尔排序的思想。其实希尔排序只是插入排序的一种优化。
- 在希尔排序中首先解决的是子序列的选择问题。对于子序列的构成不是简单的分段，而是采取相隔某个增量的数据组成一个序列。增量一般的选择原则是：取上一个增量的一半作为此次序列的划分增量。首次选择序列长度的一半为增量。
- 实现代码
public static void shellSort(int[] data) { int j = 0; int temp = 0; for (int increment = data.length / 2; increment > 0; increment /= 2) { for (int i = increment; i < data.length; i++) { temp = data[i]; for (j = i; j >= increment; j -= increment) { if(temp > data[j - increment]){ data[j] = data[j - increment]; }else{ break; } } data[j] = temp; } } }
- 算法概念
-
冒泡排序
- 算法概念
- 冒泡排序是一种简单的交换类排序。其基本思路是，从头开始扫描待排序的元素，在扫描过程中依次对相邻元素进行比较，将关键字值大的元素后移。每经过一趟排序后，关键字值最大的元素将移到末尾，此时记下该元素的位置，下一趟排序只需要比较到此位置为止，直到所有元素都已有序排列。
- 算法思想
- 一般地，对n个元素进行冒泡排序，总共需要进行n-1趟。第1趟需要比较n-1次，第2趟需要比较n-2次，......第i趟需要比较n-i次
- 实现代码
public static void bubblesort(int[] values) { int temp; for (int i = 0; i < values.length; i++) {// 趟数 for (int j = 0; j < values.length - i - 1; j++) {// 比较次数 if (values[j] > values[j + 1]) { temp = values[j]; values[j] = values[j + 1]; values[j + 1] = temp; } } } }
- 算法概念
-
快速排序
- 算法概念
- 快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。
- 算法思想
- 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
- 实现思路
- 以第一个关键字 K 1 为控制字，将 [K 1 ,K 2 ,…,K n ] 分成两个子区，使左区所有关键字小于等于 K 1 ，右区所有关键字大于等于 K 1 ，最后控制字居两个子区中间的适当位置。在子区内数据尚处于无序状态
- 把左区作为一个整体，用①的步骤进行处理，右区进行相同的处理。（即递归）
- 重复第①、②步，直到左区处理完毕。
- 实现代码
/** * description : 快速排序 * @autor lhli * modify :2016-7-20 * * @param n * @param left * @param right * @return */ public static void quicksort(int n[], int left, int right) { int dp; if (left < right) { dp = partition(n, left, right); quicksort(n, left, dp - 1); quicksort(n, dp + 1, right); } } static int partition(int n[], int left, int right) { int pivot = n[left]; while (left < right) { while (left < right && n[right] >= pivot) right--; if (left < right) n[left++] = n[right]; while (left < right && n[left] <= pivot) left++; if (left < right) n[right--] = n[left]; } n[left] = pivot; return left; }
- 算法概念
-
直接选择排序
- 算法概念
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，直接选择排序然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕
- 算法思想
- 从待排序的数据元素集合中选取最小的元素放到原始数据的第一个元素的位置上。然后不包括第一个元素的数据元素集合中找到最小的元素放到此集合中，依次类推，即可完成排序。
- 实现代码
/** * 直接选择排序 * @param a 用于排序的数组 **/ public void selectSort(double[] a) { for (int i = 0; i < a.length - 1; i++) { int smallIndex = i; for (int j = i; j < a.length; j++) {// 找到最小的值及其下标位置 if (a[j] < a[smallIndex]) { smallIndex = j; } } if (i != smallIndex) {// 将最小元素放到当前i位置，将i位置元素放到最小元素的位置，完成交换 double temp = a[i]; a[i] = a[smallIndex]; a[smallIndex] = temp; } } }
- 算法概念
-
堆排序
- 算法概念
- 是指利用堆积树（堆）这种资料结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。堆排序是不稳定的排序方法，辅助空间为O(1)， 最坏时间复杂度为O(nlog2n) ，堆排序的堆序的平均性能较接近于最坏性能。 堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。
- 算法思想
-
先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区
-
再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key
-
由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
-
- 实现代码
public static void main(String[] args) { int[] data5 = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 }; print(data5); heapSort(data5); System.out.println("排序后的数组："); print(data5); } public static void swap(int[] data, int i, int j) { if (i == j) { return; } data[i] = data[i] + data[j]; data[j] = data[i] - data[j]; data[i] = data[i] - data[j]; } public static void heapSort(int[] data) { for (int i = 0; i < data.length; i++) { createMaxdHeap(data, data.length - 1 - i); swap(data, 0, data.length - 1 - i); print(data); } } public static void createMaxdHeap(int[] data, int lastIndex) { for (int i = (lastIndex - 1) / 2; i >= 0; i--) { // 保存当前正在判断的节点 int k = i; // 若当前节点的子节点存在 while (2 * k + 1 <= lastIndex) { // biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点 int biggerIndex = 2 * k + 1; if (biggerIndex < lastIndex) { // 若右子节点存在，否则此时biggerIndex应该等于 lastIndex if (data[biggerIndex] < data[biggerIndex + 1]) { // 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值 biggerIndex++; } } if (data[k] < data[biggerIndex]) { // 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k swap(data, k, biggerIndex); k = biggerIndex; } else { break; } } } } public static void print(int[] data) { for (int i = 0; i < data.length; i++) { System.out.print(data[i] + "\t"); } System.out.println(); }
- 算法概念
-
归并排序
- 算法概念
- （Merge）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
- 算法思想
-
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
归并排序算法稳定，数组需要O(n)的额外空间，链表需要O(log(n))的额外空间，时间复杂度为O(nlog(n))，算法不是自适应的，不需要对数据的随机读取。
-
-
实现思路
-
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
-
设定两个指针，最初位置分别为两个已经排序序列的起始位置
-
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
-
重复步骤3直到某一指针达到序列尾
-
将另一序列剩下的所有元素直接复制到合并序列尾
-
- 实现代码
public class MergeSort { public static void main(String[] args) { int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 }; print(data); mergeSort(data); System.out.println("排序后的数组："); print(data); } public static void mergeSort(int[] data) { sort(data, 0, data.length - 1); } public static void sort(int[] data, int left, int right) { if (left >= right) return; // 找出中间索引 int center = (left + right) / 2; // 对左边数组进行递归 sort(data, left, center); // 对右边数组进行递归 sort(data, center + 1, right); // 合并 merge(data, left, center, right); print(data); } /** * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序 * * @param data * 数组对象 * @param left * 左数组的第一个元素的索引 * @param center * 左数组的最后一个元素的索引，center+1是右数组第一个元素的索引 * @param right * 右数组最后一个元素的索引 */ public static void merge(int[] data, int left, int center, int right) { // 临时数组 int[] tmpArr = new int[data.length]; // 右数组第一个元素索引 int mid = center + 1; // third 记录临时数组的索引 int third = left; // 缓存左数组第一个元素的索引 int tmp = left; while (left <= center && mid <= right) { // 从两个数组中取出最小的放入临时数组 if (data[left] <= data[mid]) { tmpArr[third++] = data[left++]; } else { tmpArr[third++] = data[mid++]; } } // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个） while (mid <= right) { tmpArr[third++] = data[mid++]; } while (left <= center) { tmpArr[third++] = data[left++]; } // 将临时数组中的内容拷贝回原数组中 // （原left-right范围的内容被复制回原数组） while (tmp <= right) { data[tmp] = tmpArr[tmp++]; } } public static void print(int[] data) { for (int i = 0; i < data.length; i++) { System.out.print(data[i] + "\t"); } System.out.println(); } }
- 算法概念
-
基数排序
- 算法概念
- 则是属于“分配式排序”（distribution sort），基数排序法又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。
-
实现思路
-
最高位优先(Most Significant Digit first)法，简称MSD法：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后。再将各组连接起来，便得到一个有序序列。
-
最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。
-
- 实现代码
public class RadixSort { public static void sort(int[] number, int d) { int k = 0; int n = 1; int m = 1; int[][] temp = new int[number.length][number.length]; int[] order = new int[number.length]; while (m <= d) { for (int i = 0; i < number.length; i++) { int lsd = ((number[i] / n) % 10); temp[lsd][order[lsd]] = number[i]; order[lsd]++; } for (int i = 0; i < d; i++) { if (order[i] != 0) for (int j = 0; j < order[i]; j++) { number[k] = temp[i][j]; k++; } order[i] = 0; } n *= 10; k = 0; m++; } } public static void main(String[] args) { int[] data = { 73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100 }; RadixSort.sort(data, 10); for (int i = 0; i < data.length; i++) { System.out.print(data[i] + " "); } } }
- 算法概念
扫一扫
422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
