各种常用排序算法的Java实现，不废话直接上代码

最新推荐文章于 2024-09-27 14:28:55 发布

一叶知秋乔一

最新推荐文章于 2024-09-27 14:28:55 发布

阅读量137

点赞数 1

分类专栏：数据结构文章标签：算法数据结构

本文链接：https://blog.csdn.net/pxyyoona/article/details/109287928

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

先来个汉诺塔

package Hannuota;

import java.util.Scanner;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 */
public class Hanna {
    private static int i = 0;//记录移动步骤总数
    private static int n;//盘子总数
    private static long startTime;//程序开始执行时间
    private static long endTime;//程序结束执行时间

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        startTime = System.currentTimeMillis();
        HanNuo(n, 'A', 'B', 'C');
        endTime = System.currentTimeMillis();
        System.out.println(n + "个盘子从A柱移动到C柱最少共需要" + i + "步");
        System.out.println("当前程序的执行时间为" + (endTime - startTime) + "ms");
    }

    /**
     * @param n    盘子个数
     * @param from 开始的柱子
     * @param in   中间柱子
     * @param to   目标柱子
     */

    static void HanNuo(int n, char from, char in, char to) {
        if (n == 0) {
            throw new RuntimeException("The number of columns cannot be zero");
        }
        if (n == 1) {
            i++;
            System.out.println("第" + n + "个盘子从" + from + "移动到" + to);
        } else {
            //移动上面n-1个盘子到中间位置
            i++;
            HanNuo(n - 1, from, to, in);
            System.out.println("第" + n + "个盘子从" + from + "移动到" + to);
            //移动中间柱子n-1个盘子到目标位置
            HanNuo(n - 1, in, from, to);
        }
    }
}

选择排序

package Sort.SelectSort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 */
public class Select {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//要排序的个数
        int[] arr = new int[n];//待排序的数组
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(Arrays.toString(arr) + "选择排序的结果是:" + Arrays.toString(select(arr)));
    }

    static int[] select(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) {
                    minIndex = j;
                }
            }
            if (i != minIndex) {
                int temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }
        }
        return arr;
    }
}

冒泡排序

package Sort.BubbleSort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 * 冒泡排序
 */
public class Bubble {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//要排序的个数
        int[] arr = new int[n]; //要排序的数组
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(Arrays.toString(arr) + "从小到大冒泡排序结果为" + Arrays.toString(BubbleSort(arr)));
        System.out.println(Arrays.toString(arr) + "从大到小冒泡排序结果为" + Arrays.toString(DecBubbleSort(arr)));
    }

    static int[] BubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                int temp;//临时存放
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

    static int[] DecBubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                int temp;//临时存放
                if (arr[j] < arr[j + 1]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

}

快速排序

package Sort.BubbleSort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 */
public class QuickSort {
    public static void main(String[] args) {
        int n;//要排序的数的数目
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int[] arr = new int[n];//要排序的数
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(Arrays.toString(arr) + "快速排序的结果是:" + Arrays.toString(quickSort(0, n - 1, arr)));
    }

    static int[] quickSort(int start, int end, int[] arr) {
        //如果start<end进行排序
        if (start < end) {
            //设置排序的标准数
            int stand = arr[start];
            //设置两个下标
            int low = start;
            int high = end;
            while (low < high) {
                //如果大于标准数
                while (low < high && arr[high] >= stand) {
                    high--;
                }

                arr[low] = arr[high];
                //如果小于标准数
                while (low < high && arr[low] <= stand) {
                    low++;
                }

                arr[high] = arr[low];
            }
            arr[low] = stand;
            //小的一边递归
            quickSort(start, low, arr);
            //大的一边递归
            quickSort(low + 1, end, arr);
        }
        return arr;
    }
}

直接插入排序

package Sort.InsertSort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 */
public class Insert {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//要排序的个数
        int[] arr = new int[n];//待排序的数组
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(Arrays.toString(arr) +"插入排序的结果是:"+ Arrays.toString(insert(arr)));
    }

    static int[] insert(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            //若小于上一个数
            if (arr[i] < arr[i - 1]) {
                int temp = arr[i];
                //不断向前遍历直到找到小于或等于当前的数
                int j;
                for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                    //把前边的数赋值给后边的数
                    arr[j+1] = arr[j];
                }
                arr[j + 1] = temp;
            }
        }
        return arr;
    }
}

希尔排序

package Sort.InsertSort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 */
public class Shell {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//要排序的个数
        int[] arr = new int[n];//待排序的数组
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(Arrays.toString(arr) + "希尔排序的结果是:" + Arrays.toString(shell(arr)));
    }

    static int[] shell(int[] arr) {
        //遍历所有的步长
        for (int d = arr.length / 2; d > 0; d /= 2) {
            // 遍历所有的元素
            for (int i = d; i < arr.length; i++) {
                //遍历本组中所有元素
                for (int j = i - d; j >= 0; j -= d) {
                    //如果当前元素大于加上步长后的元素
                    if (arr[j] > arr[j + d]) {
                        int temp = arr[j];
                        arr[j] = arr[j + d];
                        arr[j + d] = temp;
                    }
                }
            }
        }
        return arr;
    }
}

归并排序

package Sort.MergeSort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 */
public class Merge {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//要排序的个数
        int[] arr = new int[n];//待排序的数组
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println(Arrays.toString(arr) + "归并排序的结果是:" + Arrays.toString(mergeSort(arr, 0, arr.length - 1)));
    }


    static int[] mergeSort(int[] arr, int low, int high) {
        int middle = (low + high) / 2;
        if (low < high) {
            mergeSort(arr, low, middle);
            mergeSort(arr, middle + 1, high);
            merge(arr, low, middle, high);
        }
        return arr;
    }

    static void merge(int[] arr, int low, int middle, int high) {
        //用于存储归并后的临时数组
        int[] temp = new int[high - low + 1];
        //记录第一个数组中需要记录的下标
        int i = low;
        //记录第二个数组中需要记录的下标
        int j = middle + 1;
        //记录临时数组下标
        int index = 0;
        while (i <= middle && j <= high) {
            //第一个数组中数据更小
            if (arr[i] <= arr[j]) {
                temp[index] = arr[i];
                i++;
            } else {
                temp[index] = arr[j];
                j++;
            }
            index++;
        }
        //处理多与数据
        while (i <= middle) {
            temp[index] = arr[i];
            i++;
            index++;
        }

        while (j <= high) {
           temp[index] = arr[j];
            j++;
            index++;
        }
        //将临时数组复制到新数组
        for (int k=0;k<temp.length;k++){
            arr[low+k]=temp[k];
        }
    }
}

基数排序

package Sort.RadixSort;

import java.util.*;

/**
 * Author: PXY
 * Email: 1817865166@qq.com
 * Date: 2020/10/26
 */
public class Radix {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//要排序的个数
        int[] arr = new int[n];//待排序的数组
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
//        System.out.println(Arrays.toString(arr) + "基数排序的结果是:" + Arrays.toString(radixSort(arr)));
        System.out.println(Arrays.toString(arr) + "用队列实现的基数排序的结果是:" + Arrays.toString(RadixQueue(arr)));
    }

    static int[] radixSort(int[] arr) {
        int max = Integer.MIN_VALUE;
        //创建二维数组存放相应位上的数
        int[][] temp = new int[10][arr.length];
        //创建记录存放数字数量的数组
        int[] counts = new int[10];
        //循环找出最大的数
        for (int value : arr) {
            if (value > max) {
                max = value;
            }
        }
        int maxLength = String.valueOf(max).length();//最大数的长度
        //开始基数排序
        for (int i = 0, n = 1; i < maxLength; i++, n = n * 10) {
            //计算余数
            for (int value : arr) {
                int ys = value / n % 10;
                temp[ys][counts[ys]] = value;
                counts[ys]++;
            }
            //记录取出数字要存放的位置
            int index = 0;
            for (int k = 0; k < counts.length; k++) {
                //如果存放的有数
                if (counts[k] != 0) {
                    //循环取出元素
                    for (int l = 0; l < counts[k]; l++) {
                        arr[index] = temp[k][l];
                        index++;
                    }
                    counts[k] = 0;
                }
            }
        }
        return arr;
    }


    /**
     * @param arr
     * @return
     * @desc 用队列实现
     */
    static int[] RadixQueue(int[] arr) {
        int max = Integer.MIN_VALUE;
        //创建十个队列
        Queue[] temp = new LinkedList[10];
        //初始化队列
        for (int i = 0; i < 10; i++) {
            temp[i] = new LinkedList<Integer>();
        }
        for (int value : arr) {
            if (value > max) {
                max = value;
            }
        }
        int maxLength = String.valueOf(max).length();//最大数的长度
        //开始基数排序
        for (int i = 0, n = 1; i < maxLength; i++, n = n * 10) {
            //计算余数
            for (int value : arr) {
                int ys = value / n % 10;
                temp[ys].offer(value);
            }
            //记录取出数字要存放的位置
            int index = 0;
            for (Queue queue : temp) {
                //如果存放的有数
                while (!queue.isEmpty()) {
                    arr[index] = (int) queue.poll();
                    index++;
                }
            }
        }
        return arr;
    }
}