From 06116f15553f525862daa5be67294967db346e22 Mon Sep 17 00:00:00 2001
From: zht <zht045692@qq.com>
Date: Fri, 8 Jan 2021 13:14:31 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BD=9C=E4=B8=9A=E6=8F=90=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Main.java              |  73 ++++++++++++++++
 Sort.java              | 191 +++++++++++++++++++++++++++++++++++++++++
 SortingResultInfo.java |  37 ++++++++
 3 files changed, 301 insertions(+)
 create mode 100644 Main.java
 create mode 100644 Sort.java
 create mode 100644 SortingResultInfo.java

diff --git a/Main.java b/Main.java
new file mode 100644
index 0000000..2fd5718
--- /dev/null
+++ b/Main.java
@@ -0,0 +1,73 @@
+import java.util.*;
+
+public class Main {
+    //实际测试可以把数组写得大一些
+    final static int ArrayLength=10000;
+
+
+
+    public static void main(String[] args) {
+        int [] array=new int[ArrayLength];
+        for (int i=0;i<ArrayLength;i++){
+            //生成0到10000的随机数
+            array[i]=new Random().nextInt(10000);
+        }
+
+        System.out.println("原始数据:"+Arrays.toString(array));
+        System.out.println("——————————————————————————————————————————");
+
+        String [] sortTypeArray=new String[]{"选择","插入","冒泡","快速","归并","希尔"};
+        //存储全部排序信息
+        List<SortingResultInfo> list=new ArrayList<>(sortTypeArray.length);
+        for (int i=0;i<sortTypeArray.length;i++){
+            list.add(sort(sortTypeArray[i],array));
+        }
+        Collections.sort(list);
+        System.out.println("运行时间对比：\t\t\t▄为1ms");
+        for (int i=0;i<list.size();i++){
+            try {
+                System.out.println(list.get(i).toString());
+            }catch (DuplicateFormatFlagsException e){
+                System.out.println(list.get(i).getName()+"也太快了吧");
+            }
+        }
+
+    }
+
+    public static SortingResultInfo sort(String nameType, int []array){
+        SortingResultInfo sortingResultInfo = new SortingResultInfo();
+        sortingResultInfo.setName(nameType+"排序");
+        System.out.println(sortingResultInfo.getName());
+        sortingResultInfo.setStartTime(System.currentTimeMillis());
+        int [] newArray = new int[0];
+        switch (nameType){
+            case "选择":
+                newArray= Sort.selectionsort(array.clone());
+                break;
+            case "插入":
+                newArray = Sort.insertionSorting(array.clone());
+                break;
+            case "冒泡":
+                newArray = Sort.bubbleSort(array.clone());
+                break;
+            case "快速":
+                newArray = Sort.quickSort(array.clone());
+                break;
+
+            case "归并":
+                newArray = Sort.mergeSort(array.clone());
+                break;
+            case "希尔":
+                newArray = Sort.shellSort(array.clone());
+                break;
+
+        }
+        sortingResultInfo.setEndTime(System.currentTimeMillis());
+        System.out.println(sortingResultInfo.getName()+"时间："+ sortingResultInfo.getWhen() + "ms");
+        System.out.println(Arrays.toString(newArray));
+        System.out.println("——————————————————————————————————————————");
+        return sortingResultInfo;
+    }
+
+
+}
\ No newline at end of file
diff --git a/Sort.java b/Sort.java
new file mode 100644
index 0000000..5340019
--- /dev/null
+++ b/Sort.java
@@ -0,0 +1,191 @@
+import java.util.Arrays;
+
+public class Sort {
+    /**
+     *  选择排序
+     *  首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
+     *  再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
+     *  重复第二步，直到所有元素均排序完毕。
+     */
+    public static int[] selectionsort(int [] array){
+        for (int i=0;i<array.length;i++){
+            // 最小点位置
+            int minSeat=i;
+            for (int j=i+1;j<array.length;j++){
+                if (array[j]<array[minSeat]){
+                    minSeat=j;
+                }
+            }
+            //交换位置
+            interchange(array,minSeat,i);
+        }
+        return array;
+    }
+
+    /**
+     * 插入排序
+     * 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
+     * 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。
+     * （如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
+     */
+    public static int[] insertionSorting(int [] array){
+        for (int i=0;i<array.length;i++){
+            int item=array[i];
+            int j=i;
+
+            while (j>0&&item<array[j-1]){
+                array[j]=array[j-1];
+                j--;
+            }
+            if (j!=i){
+                array[j]=item;
+            }
+        }
+        return array;
+    }
+
+    /**
+     * 冒泡排序
+     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
+     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
+     * 针对所有的元素重复以上的步骤，除了最后一个。
+     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
+     */
+    public static int[] bubbleSort(int [] array){
+        for (int i=1;i<array.length;i++){
+            boolean isExchange=true;
+            for (int j=0;j<array.length-i;j++){
+                if (array[j]>array[j+1]){
+                    interchange(array,j,j+1);
+                    isExchange=false;
+                }
+            }
+            if (isExchange){
+                //没有交换结束程序
+                break;
+            }
+        }
+        return array;
+
+    }
+
+    /**
+     * 快速排序
+     * 从数列中挑出一个元素，称为 "基准"（pivot）;
+     * 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
+     * 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
+     * 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
+     */
+    public static int[] quickSort(int [] array){
+        return quickSortRecursion(array,0,array.length-1);
+    }
+
+    private static int[] quickSortRecursion(int [] array,int left, int right){
+        if (left<right){
+            int partition = partition(array, left, right);
+            quickSortRecursion(array, left, partition - 1);
+            quickSortRecursion(array, partition + 1, right);
+        }
+        return array;
+    }
+
+    private static int partition(int[] array, int left, int right){
+        int pivot=left;
+        int index=pivot+1;
+        for (int i = index; i <= right; i++) {
+            if (array[i] < array[pivot]) {
+                interchange(array, i, index);
+                index++;
+            }
+        }
+        interchange(array, pivot, index - 1);
+        return index - 1;
+    }
+
+    /**
+     * 归并排序
+     * 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
+     * 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
+     * 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
+     * 重复步骤 3 直到某一指针达到序列尾；
+     * 将另一序列剩下的所有元素直接复制到合并序列尾。
+     */
+    public static int[] mergeSort(int [] array){
+        return mergeSortRecursion(array);
+    }
+
+    private static int[] mergeSortRecursion(int [] array){
+        if (array.length<2){
+            return array;
+        }
+        int middle = (int) Math.floor(array.length / 2);
+        int [] left= Arrays.copyOfRange(array,0,middle);
+        int [] right= Arrays.copyOfRange(array,middle,array.length);
+        return merge(mergeSortRecursion(left),mergeSortRecursion(right));
+    }
+
+    private static int[] merge(int[] left, int[] right) {
+        int[] result = new int[left.length + right.length];
+        int i = 0;
+        while (left.length > 0 && right.length > 0) {
+            if (left[0] <= right[0]) {
+                result[i++] = left[0];
+                left = Arrays.copyOfRange(left, 1, left.length);
+            } else {
+                result[i++] = right[0];
+                right = Arrays.copyOfRange(right, 1, right.length);
+            }
+        }
+
+        while (left.length > 0) {
+            result[i++] = left[0];
+            left = Arrays.copyOfRange(left, 1, left.length);
+        }
+
+        while (right.length > 0) {
+            result[i++] = right[0];
+            right = Arrays.copyOfRange(right, 1, right.length);
+        }
+
+        return result;
+    }
+
+
+    /**
+     * 希尔排序
+     * 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
+     * 按增量序列个数 k，对序列进行 k 趟排序；
+     * 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
+     */
+    public static int[] shellSort(int [] array){
+        int length = array.length;
+        int item;
+        for (int step=length/2;step>=1;step/=2){
+            for (int i=step;i<length;i++){
+                item=array[i];
+                int j=i-step;
+                while (j>=0 &&array[j]>item){
+                    array[j+step]=array[j];
+                    j-=step;
+                }
+                array[j+step]=item;
+            }
+        }
+        return array;
+    }
+
+    /**
+     * 交换位置
+     * @param array
+     * @param place1
+     * @param place2
+     */
+    private static void interchange(int [] array,int place1,int place2){
+        if (place1 !=place2){
+            int item = array[place1];
+            array[place1] = array[place2];
+            array[place2] = item;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/SortingResultInfo.java b/SortingResultInfo.java
new file mode 100644
index 0000000..db60c01
--- /dev/null
+++ b/SortingResultInfo.java
@@ -0,0 +1,37 @@
+public class SortingResultInfo implements Comparable<SortingResultInfo> {
+    private String name;
+    private long startTime ; //获取开始时间
+    private long endTime ; //获取结束时间
+
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setStartTime(long startTime) {
+        this.startTime = startTime;
+    }
+
+    public void setEndTime(long endTime) {
+        this.endTime = endTime;
+    }
+
+    public long getWhen(){
+        return endTime-startTime;
+    }
+
+    @Override
+    public int compareTo(SortingResultInfo o) {
+        return (int) (this.getWhen()-o.getWhen());
+    }
+
+    @Override
+    public String toString() {
+        String replace = String.format("%0" +  getWhen()+ "d", 0).replace("0", "▄");
+        return getName()+"  用时："+getWhen()+"ms\t"+replace;
+    }
+}
\ No newline at end of file
-- 
Gitee