八种排序算法的Java实现

最新推荐文章于 2023-06-27 14:16:23 发布

圣龙LKX

最新推荐文章于 2023-06-27 14:16:23 发布

阅读量198

点赞数

分类专栏：代码文章标签： Java 算法排序算法堆排序快速排序

本文链接：https://blog.csdn.net/qq_27232757/article/details/79260515

版权

代码专栏收录该内容

6 篇文章 0 订阅

订阅专栏

package util;
/**
* 排序方法时间复杂度（平均）时间复杂度（最坏) 时间复杂度（最好) 空间复杂度稳定性复杂性
直接插入排序 O(n2)   O(n2) O(n) O(1) 稳定简单
希尔排序 O(nlog2n) O(n2) O(n) O(1) 不稳定较复杂
直接选择排序 O(n2)   O(n2) O(n2) O(1) 不稳定简单
堆排序 O(nlog2n) O(nlog2n) O(nlog2n) O(1) 不稳定较复杂
冒泡排序 O(n2)   O(n2) O(n) O(1) 稳定简单
快速排序 O(nlog2n)    O(n2) O(nlog2n) O(nlog2n) 不稳定较复杂
归并排序 O(nlog2n) O(nlog2n) O(nlog2n) O(n) 稳定较复杂
基数排序 O(d(n+r))   O(d(n+r)) O(d(n+r)) O(n+r) 稳定较复杂
* @author likexin
*
*/
public class Sort {

public static void main(String[] args) {
int[] l = new int[]{2, 34, 56, 32, 67, 90, 3, 2236,2 ,2 , 10, 10000, 325, 400000};
//bubble(l);
//select(l);
//insert(l);
//shellSort(l);
//heapSort(l);
//mergeSort(l, 0, l.length - 1);
//quickSort(l);
radixSort(l);
for (int i = 0; i < l.length; i++) {
System.out.print(l[i] + " ");
}
}

/**
* 基数排序
* @param a
*/
public static void radixSort(int[] a) {
int[][] bucket = new int[10][a.length];
int[] order = new int[a.length];//记录每个桶里面数据的数量
int n = 1;
while (true) {
boolean ret = false;
for (int num : a) {
int remainder = (num/n)%10;
if (remainder!=0) {
ret = true;
}
bucket[remainder][order[remainder]++] = num;
}
if (!ret) {
break;
}
int k = 0;
for (int i = 0; i < a.length;) {
if (order[k]!=0) {
for (int j = 0; j < order[k]; j++) {
a[i] = bucket[k][j];
i++;
}
order[k] = 0;
}
k++;
}
n*=10;
}
}

/**
* 快速排序
* @param l
*/
public static void quickSort(int[] l) {
QSort(l, 0, l.length - 1);
}

public static void QSort(int[] l, int low, int high) {
int pivot;
if (low < high) {
pivot = Partition(l, low, high);
QSort(l, low, pivot - 1);
QSort(l, pivot + 1, high);
}
}

public static int Partition(int[] l, int low, int high) {
int pivotkey = l[low];
while (low < high) {
while (low < high && l[high] >= pivotkey) {
high--;
}
swap(l, low, high);
while (low < high && l[low] < pivotkey) {
low++;
}
swap(l, low, high);
}
return low;
}

/**
* 归并排序
* @param l
*/
public static void mergeSort(int[] l, int left, int right) {
if (left >= right) {
return;
}
int center = (left + right) >> 1;
mergeSort(l, left, center);
mergeSort(l, center + 1, right);
merge(l, left, center, right);
}

private static void merge(int[] l, int left, int center, int right) {
int[] tmpArr = new int[right+1];
int mid = center + 1;
int index = left; // index记录临时数组的索引
int tmp = left;

// 从两个数组中取出最小的放入中临时数组
while (left <= center && mid <= right) {
tmpArr[index++] = (l[left] <= l[mid]) ? l[left++]: l[mid++];
}
// 剩余部分依次放入临时数组
while (mid <= right) {
tmpArr[index++] = l[mid++];
}
while (left <= center) {
tmpArr[index++] = l[left++];
}
// 将临时数组中的内容复制回原数组
for (int i = tmp; i <= right; i++) {
l[i] = tmpArr[i];
}

}

/**
* 堆排序
* @param a
*/
public static void heapSort(int[] a) {
int i;
for (i = a.length / 2 - 1; i >= 0; i--) {
adjustHeap(a, i, a.length - 1);
}
for (i = a.length - 1; i >= 0; i--) {
swap(a, i, 0);
adjustHeap(a, 0, i - 1);
}
}

/**
* 最大堆的实现
* @param a
* @param i
* @param len
*/
public static void adjustHeap(int[] a, int i, int len) {
int temp, j;
temp = a[i];
for (j = 2 * i + 1; j < len; j = 2*j + 1) {
if (a[j] < a[j + 1])
++j;
if (temp >= a[j])
break;
a[i] = a[j];
i = j;
}
a[i] = temp;
}

/**
* 希尔排序
* @param l
*/
public static void shellSort(int[] l) {
for (int r = l.length/2; r >= 1; r--) {
for (int i = 0; i < l.length-r; i++) {
if (l[i] > l[i + r]) {
swap(l, i, i+r);
}
}
}
}

/**
* 插入排序
* @param l
*/
public static void insert(int[] l) {
for (int i = 1; i < l.length; i++) {
int target = l[i];
int j = i;
while (j > 0 && target < l[j-1]) {
l[j] = l[j-1];
j--;
}
l[j] = target;
}
}

/**
* 选择排序
* @param l
*/
public static void select(int[] l) {
for (int i = 0; i < l.length; i++) {
int min = i;
for (int j = i + 1; j < l.length; j++) {
if (l[min] < l[j]) {
min = j;
}
}
if (i!=min) {
swap(l, i, min);
}
}
}

/**
* 冒泡排序
* @param l
*/
public static void bubble(int[] l) {
boolean flag = true;
for (int i = 1; i < l.length && flag; i++) {
flag = false;
for (int j = l.length - 1; j >= i; j--) {
if (l[j] < l[j - 1]) {
swap(l, j, j - 1);
flag = true;
}
}
}
}

/**
* 交换
* @param l
* @param i
* @param j
*/
public static void swap(int[] l, int i, int j) {
int temp = l[i];
l[i] = l[j];
l[j] = temp;
}