Java数组之八大排序
1. 冒泡排序
代码示例
package com.baidu.www;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
boolean flag = false;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if(arr[j] > arr[j + 1]){
// 交换位置
int t = arr[j];
arr[j] = arr[j+1];
arr[j+1] = t;
flag = true;
}
}
if(!flag) break;
}
System.out.println(Arrays.toString(arr));
}
}
2. 选择排序
代码示例
package com.baidu.www;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
boolean flag = false;
for (int i = 0; i < arr.length - 1; i++) {
for(int j = i + 1; j < arr.length; j++){
if(arr[i] > arr[j]){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
flag = true;
}
}
if(!flag) break;
}
System.out.println(Arrays.toString(arr));
}
}
3. 直接插入排序
代码示例
package com.baidu.www;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {24, 69, 80, 57, 13};
// 直接插入排序
for (int i = 1; i < arr.length; i++) {
int j = i;
while (j > 0 && arr[j] < arr[j-1]){
// int t = arr[j];
// arr[j] = arr[j-1];
// arr[j-1] = t;
swapValue(arr, j, j-1);
j--;
}
}
System.out.println(Arrays.toString(arr));
}
public static void swapValue(int[] arr, int i, int j){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
4. 希尔排序
希尔排序是插入排序的优化
代码示例
package com.baidu.www;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {46, 55, 13, 42, 17, 94, 5, 70};
// 直接插入排序：增量为1的希尔排序
shellSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void shellSort(int[] arr){
// 选取增量为数组长度的一半，不断减半
// for(int h = arr.length / 2; h > 0; h /= 2){ // 增量的变化
// for(int i = h; i < arr.length; i++){ //
// for(int j = i; j > h-1; j -= h){
// if(arr[j] < arr[j-h]){
// swapValue(arr, j, j-h);
// }
// }
// }
// }
// 使用克努特序列作为增量
// Knuth序列
// int h = 1;
// h = h * 3 + 1;
// 根据Knuth序列选取增量
int interval = 1;
while (interval <= arr.length / 3){
interval = interval*3 + 1;
}
System.out.println(interval);
for(int h = interval; h > 0; h = (h-1)/3){ // 增量的变化
for(int i = h; i < arr.length; i++){ //
for(int j = i; j > h-1; j -= h){
if(arr[j] < arr[j-h]){
swapValue(arr, j, j-h);
}
}
}
}
}
public static void swapValue(int[] arr, int i, int j){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
5. 快速排序
代码示例
（1）Test类
package com.baidu.www;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {10, 3, 5, 6, 1, 0, 100, 40, 50, 0};
// 调用工具类，进行快速排序
QuickSortUtils.quickSort(arr, 0, arr.length-1);
System.out.println(Arrays.toString(arr));
}
}
（2）QuickSortUtils类
package com.baidu.www;
public class QuickSortUtils {
public static void quickSort(int[] arr, int startIndex, int endIndex){
if(startIndex < endIndex){
// 找到索引位置
int index = getIndex(arr, startIndex, endIndex);
quickSort(arr, startIndex, index - 1);
quickSort(arr, index + 1, endIndex);
}
}
private static int getIndex(int[] arr, int startIndex, int endIndex){
int i = startIndex;
int j = endIndex;
int x = arr[i];
while (i < j){
while (i < j && arr[j] >= x){
j--;
}
// 找到了小的数
if(i < j){
arr[i++] = arr[j];
}
while (i < j && arr[i] < x){
i++;
}
// 找到了大于或等于的数
if(i < j){
arr[j--] = arr[i];
}
}
arr[i] = x;
return i;
}
}
6. 归并排序
代码示例
package com.baidu.www;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {10, 30, 2, 1, 0, 8, 7, 5, 19, 20};
// int[] arr = {4, 5, 7, 8, 1, 2, 3, 6};
// 拆分
chaifen(arr, 0, arr.length-1);
// 归并
System.out.println(Arrays.toString(arr));
}
private static void chaifen(int[] arr, int startIndex, int endIndex){
// 计算中间索引
int midIndex = (startIndex + endIndex) / 2;
if(startIndex < endIndex){
chaifen(arr, startIndex, midIndex);
chaifen(arr, midIndex+1, endIndex);
guiBing(arr, startIndex, midIndex, endIndex);
}
}
private static void guiBing(int[] arr, int startIndex, int midIndex, int endIndex){
// 定义一个临时数组
int[] tempArr = new int[endIndex-startIndex+1];
// 定义左边数组的起始索引
int i = startIndex;
// 定义右边数组的起始索引
int j = midIndex + 1;
// 定义临时数组的起始索引
int index = 0;
// 放数字
while(i <= midIndex && j <= endIndex){
if(arr[i] <= arr[j]){
tempArr[index++] = arr[i++];
}else{
tempArr[index++] = arr[j++];
}
}
// 处理剩余元素
while (i <= midIndex){
tempArr[index++] = arr[i++];
}
while (j <= endIndex){
tempArr[index++] = arr[j++];
}
// System.out.println(Arrays.toString(tempArr));
// 将元素取到原数组中
for (int i1 = 0; i1 < tempArr.length; i1++) {
arr[i1 + startIndex] = tempArr[i1];
}
}
}
7. 基数排序
代码示例
package com.baidu.www;
import java.util.Arrays;
public class ArrayDemo {
public static void main(String[] args) {
// 基数排序
int[] arr = {2, 1, 5, 21, 31, 444, 23, 33, 47, 10, 903, 124, 987, 10000};
// 基数排序
sortArray(arr);
System.out.println(Arrays.toString(arr));
}
private static void sortArray(int[] arr) {
// 定义二维数组，放十个桶
int[][] tempArr = new int[10][arr.length];
// 定义统计数组
int[] counts = new int[10];
// 获取最大值
int max = getMax(arr);
int len = String.valueOf(max).length();
// 开始循环
for (int i = 0, n = 1; i < len; i++, n *= 10) {
for (int j = 0; j < arr.length; j++) {
// 获取每个位置的数字
int ys = arr[j] / n % 10;
tempArr[ys][counts[ys]++] = arr[j];
}
// 取出桶中的元素
int index = 0;
for (int k = 0; k < counts.length; k++) {
if(counts[k] != 0)
for (int h = 0; h < counts[k]; h++) {
// 从桶中取出元素放回原数组
arr[index++] = tempArr[k][h];
}
counts[k] = 0; // 清除上一次统计的个数
}
}
}
private static int getMax(int[] arr){
int max = arr[0];
for (int i : arr) {
max = (i > max) ? i : max;
}
return max;
}
}
8. 堆排序
代码示例
package com.baidu.www;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
// 数组的定义
int[] arr = {1, 0, 6, 7, 2, 3, 4};
// 大顶堆
int startIndex = (arr.length - 1) / 2;
// 循环调整大顶堆
for(int i = startIndex; i >= 0; i--){
toMaxHeap(arr, arr.length, i);
}
// 大顶堆
System.out.println(Arrays.toString(arr));
// 根元素和最后一个元素调换
for(int i = arr.length-1; i > 0; i--){
// 进行调换
int t = arr[0];
arr[0] = arr[i];
arr[i] = t;
// 再把剩余元素调成大顶堆
toMaxHeap(arr, i, 0);
}
System.out.println(Arrays.toString(arr));
}
/**
*
* @param arr 排序数组
* @param size 调整的元素个数
* @param index 调整开始位置
*/
private static void toMaxHeap(int[] arr, int size, int index) {
// 获取左右字节的索引
int leftNodeIndex = index*2+1;
int rightNodeIndex = index*2+2;
// 查找最大节点所对应的索引
int maxIndex = index;
if(leftNodeIndex < size && arr[leftNodeIndex] > arr[maxIndex]){
maxIndex = leftNodeIndex;
}
if(rightNodeIndex < size && arr[rightNodeIndex] > arr[maxIndex]){
maxIndex = rightNodeIndex;
}
// 调换位置
if(maxIndex != index){
int t = arr[maxIndex];
arr[maxIndex] = arr[index];
arr[index] = t;
// 调换下面的元素为大顶堆
toMaxHeap(arr, size, maxIndex);
}
}
}
浙公网安备 33010602011771号