排序算法
综述
本文主要是整理几种常见的排序算法（选择排序，插入排序，希尔排序，归并排序、快速排序，堆排序）源码Github地址
排序时需要的方法
package org.jpractice.algorithm.sort;
/** * @author: 作者： xuefei * @date: 创建时间：2019-02-23 17:54:44 * @Description: 排序算法需要的公共方法 * @version V1.0 */
public class AbstractSort {
/** * 判断两个变量的大小 * * @param v * @param w * @return */
public static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
/** * 交换指定的两个变量 * * @param a * @param i * @param j */
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
/** * 判断集合是否已经排序 * * @param a * @return */
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
/** * 用来展示排序的结果 * * @param a */
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println("");
}
}
选择排序
package org.jpractice.algorithm.sort;
/** * @author: 作者： xuefei * @date: 创建时间：2018-08-14 06:47:16 * @Description: 选择排序算法 * @version V1.0 */
public class SelectionSort extends AbstractSort {
public static void sort(Comparable[] a) {
int length = a.length;
int min = 0;
for (int i = 0; i < length; i++) {
for (int j = i + 1; j < length; j++) {
if (less(a[j], a[min])) {
min = j;
}
System.out.println(min);
exch(a, min, i);
}
}
show(a);
}
public static void main(String[] args) {
Integer[] numbsers = new Integer[] { 5, 3, 7, 11, 22, 4, 3 };
sort(numbsers);
}
}
插入排序
package org.jpractice.algorithm.sort;
/** * @author: 作者： xuefei * @date: 创建时间：2018-08-16 17:32:43 * @Description: 插入排序 * @version V1.0 */
public class InsertionSort extends AbstractSort{
public static void sort(Comparable[] a) {
int length = a.length;
for (int i = 0; i < length - 1; i++) {
for (int j = i + 1; j >= 1; j--) {
if (less(a[j], a[j - 1])) {
exch(a, j, j - 1);
}
}
}
show(a);
}
public static void main(String[] args) {
Integer[] aa = { 11, 9, 8, 7, 3, 9, 2 };
sort(aa);
}
}
希尔排序
package org.jpractice.algorithm.sort;
/** * @author: 作者： xuefei * @date: 创建时间：2018-08-23 08:20:35 * @Description: 希尔排序 * @version V1.0 */
public class ShellSort extends AbstractSort {
public void sort(Comparable[] a) {
int length = a.length;
int h = 1;
while (h < length / 3) {
h = 3 * h + 1;
}
while (h >= 1) {
for (int i = h; i < length; i++) {
for (int j = i; j >= h && less(a[j], a[j - h]); j -= h) {
exch(a, j - h, j);
}
}
h = h / 3;
}
show(a);
}
public static void main(String[] args) {
Integer[] arrays = { 1, 3, 6, 2, 13, 7, 9, 2, 1 };
ShellSort shellSort = new ShellSort();
shellSort.sort(arrays);
}
}
归并排序
/** * */
package org.jpractice.algorithm.sort;
/** * @author: 作者： xuefei * @date: 创建时间：2018-12-18 13:12:01 * @Description: TODO * @version V1.0 */
public class MergeSort extends AbstractSort {
public void sort(Comparable[] a) {
int length = a.length;
sort(a, 0, length - 1);
}
private void sort(Comparable[] a, int low, int high) {
if (low < high) {
int mid = (low + high) / 2;
sort(a, low, mid);
sort(a, mid + 1, high);
merge(a, low, mid, high);
}
}
private void merge(Comparable[] arr, int low, int mid, int high) {
System.out.println(low + "-" + mid + "-" + high);
show(arr);
Comparable[] aux = new Comparable[arr.length];
// Find sizes of two subarrays to be merged
int n1 = mid - low + 1;
int n2 = high - mid;
/* Create temp arrays */
Comparable L[] = new Comparable[n1];
Comparable R[] = new Comparable[n2];
/* Copy data to temp arrays */
for (int i = 0; i < n1; ++i)
L[i] = arr[low + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[mid + 1 + j];
/* Merge the temp arrays */
// Initial indexes of first and second subarrays
int i = 0, j = 0;
// Initial index of merged subarry array
int k = low;
while (i < n1 && j < n2) {
if (less(L[i], R[j])) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
/* Copy remaining elements of L[] if any */
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
/* Copy remaining elements of R[] if any */
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
// Driver method
public static void main(String args[]) {
String arr[] = { "M", "E", "R", "G", "E", "S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E" };
// String arr[] = { "M", "E", "R", "G", "E", "S" };
System.out.println("Given Array");
show(arr);
MergeSort ob = new MergeSort();
ob.sort(arr);
System.out.println("Sorted array");
// printArray(arr);
}
}
快速排序
/** * */
package org.jpractice.algorithm.sort;
import edu.princeton.cs.algs4.StdRandom;
/** * @author: 作者： xuefei * @date: 创建时间：2019-02-04 18:05:14 * @Description: 快速排序 * @version V1.0 */
public class QuickSort {
private static int partition(Comparable[] a, int lo, int hi) {
int i = lo, j = hi + 1;
while (true) {
while (less(a[++i], a[lo])) {
if (i == hi) {
break;
}
}
while (less(a[lo], a[--j])) {
if (j == lo) {
break;
}
}
if (i >= j) {
break;
}
exch(a, i, j);
}
exch(a, lo, j);
return j;
}
public static void sort(Comparable[] a) {
StdRandom.shuffle(a);
// print(a);
sort(a, 0, a.length - 1);
}
private static void print(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
System.out.println("");
}
public static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo) {
return;
}
int j = partition(a, lo, hi);
sort(a, lo, j - 1);
sort(a, j + 1, hi);
}
private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
private static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
public static void main(String[] args) {
String[] a = new String[] { "Q", "U", "I", "C", "K", "S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E" };
QuickSort.sort(a);
print(a);
}
}
堆排序
/** * */
package org.jpractice.algorithm.sort;
/** * @author: 作者： xuefei * @date: 创建时间：2019-02-15 09:10:14 * @Description: 堆排序 * @version V1.0 */
public class HeapSort {
public static void main(String[] args) {
String[] a = { "1", "4", "2", "66", "22", "45" };
sort(a);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
public static void sort(Comparable[] a) {
int n = a.length;
for (int k = n / 2; k >= 1; k--)
sink(a, k, n);
while (n > 1) {
exch(a, 1, n);
sink(a, 1, --n);
}
}
private static void sink(Comparable[] pq, int k, int n) {
while (2 * k <= n) {
int j = 2 * k;
if (j < n && less(pq, j, j + 1))
j++;
if (!less(pq, k, j))
break;
exch(pq, k, j);
k = j;
}
}
private static boolean less(Comparable[] a, int i, int m) {
return a[i - 1].compareTo(a[m - 1]) < 0;
}
private static void exch(Object[] a, int i, int m) {
Object swap = a[i - 1];
a[i - 1] = a[m - 1];
a[m - 1] = swap;
}
}
