java排序算法总结

原创 于 2021-07-31 22:32:21 发布 · 115 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

这篇博客详细总结了Java中常见的排序算法，包括选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序、计数排序、基数排序以及独特的TimSort，其中提到了TimSort是归并排序和二分法快速排序思想的结合，还讨论了荷兰国旗问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

庆太爱月和 月和爱不爱庆太呢

1.选择排序

public class SelectSort {
    public static void main(String[] args) {
        int[] a = {3, 5, 7, 9, 4, 8, 6, 2, 1, 0};
        show(a);
        sort(a);
        print(a);
    }

    public static void show(int[] array){
        print(array);
        System.out.println(" ");

    }

    public static void sort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            int minPos = i;
            findMin(array, i);
        }
    }

    public static void findMin(int[] array, int i) {
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[i]) {
                swap(array, j, i);
            }
        }
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

2.冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {3, 5, 7, 9, 4, 8, 6, 2, 1, 0};
//        int[] order = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        show(a);
        sort(a);
        print(a);
    }

    public static int[] sort(int[] array) {
        boolean isSort = false;
        for (int i = array.length - 1; i > 0; i--) {
            isSort = false;
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) swap(array, j, j + 1);
                isSort = true;
            }
            if (!isSort) break;
        }
        return array;

    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

3.插入排序

public class InsertSort {//斗地主 抓牌
    public static void main(String[] args) {
        int[] a = {3, 5, 7, 9, 4, 8, 6, 2, 1, 0};
        //        int[] order = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        show(a);
//        sort(a);
        sortImprove(a);
        print(a);

        long starttime = System.currentTimeMillis();
        long endtime = System.currentTimeMillis();
        System.out.println("运行时间为" + (endtime - starttime) + "ms");
    }


    public static void sort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            for (int j = i; j > 0; j--) {
                if (array[j] < array[j - 1]) swap(array, j, j - 1);
            }
        }
    }

    public static void sortImprove(int[] array) {
        boolean isSort = false;
        for (int i = 1; i < array.length; i++) {
            for (int j = i; j > 0; j--) {
                isSort = false;
                if (array[j] < array[j - 1]) {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                    isSort = true;
                }
                if (!isSort) break;
            }
        }
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

4.希尔排序

public class ShellSort {
    public static void main(String[] args) {//上来可以用希尔排序先排一遍，如果能接受的话，就可以了。
        int[] a = {9, 6, 11, 3, 5, 12, 8, 7, 10, 15, 14, 4, 1, 13, 2};
        sortknuth(a);
        print(a);
    }

    public static void sort(int[] array) {


        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                for (int j = i; j > gap - 1; j -= gap) {
                    if (array[j] < array[j - gap]) swap(array, j, j - gap);
                }
            }
        }
//        int gap = 4;
    }

    public static void sortknuth(int[] array) {
        int h = 1;
        while (h <= array.length / 3) {
            h = h * 3 + 1;
        }

        for (int gap = h; gap > 0; gap = (gap - 1) / 3) {
            for (int i = gap; i < array.length; i++) {
                for (int j = i; j > gap - 1; j -= gap) {
                    if (array[j] < array[j - gap]) swap(array, j, j - gap);
                }
            }
        }
//        int gap = 4;
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

5.归并排序

public class MergeSort {
    public static void main(String[] args) {
//        int[] a = {1, 4, 7, 8, 2, 3, 5, 9, 11}; //为什么这个数组无法排序总是排序为
        // 1 3 4 5 7 8 2 9 11
        int[] a = {10, 4, 7, 8, 3, 6, 9, 11, 12, 13};//1 3 4 6 7 8 9
        sort(a, 1, 5);
        print(a);
    }

    public static void sort(int[] array, int left, int right) {
        if (left == right) return;
        int mid = left + (right - left) / 2;
        sort(array, left, mid);
        sort(array, mid + 1, right);

        merge(array, left, mid + 1, right);
//        mergebug(array);
    }

    public static void merge(int[] array, int leftPtr, int rightPtr, int rightBound) {
        int mid = rightPtr - 1;
        int[] temp = new int[(rightBound - leftPtr) + 1];

        int i = leftPtr;
        int j = rightPtr;
        int k = 0;

        while (i <= mid && j <= rightBound) {
            temp[k++] = array[i] <= array[j] ? array[i++] : array[j++];
        }

        while (i <= mid) temp[k++] = array[i++];
        while (j <= rightPtr) temp[k++] = array[j++];

        //print(temp);
        for (int m = 0; m < temp.length; m++) {
            array[leftPtr + m] = temp[m];
        }
    }

    /*public static void mergebug(int[] array) {
        int mid = array.length >> 1;
        System.out.println("mid" + mid);
        int[] temp = new int[array.length];

        int i = 0;
        int j = mid;
        int k = 0;

        while (i < mid && j < array.length) {
            temp[k++] = array[i] <= array[j] ? array[i++] : array[j++];
        }

        while (i < mid) temp[k++] = array[i++];
        while (j < array.length) temp[k++] = array[j++];

        print(temp);
    }*/

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

6.快速排序

public class QuickSort {
    public static void main(String[] args) {
        int[] a = {7, 3, 2, 10, 8, 1, 6, 5, 4, 9};
        sort(a, 0, a.length - 1);
        print(a);
    }

    public static void sort(int[] array, int leftBound, int rightBound) {
        if (leftBound >= rightBound) return;
        int mid = partition(array, leftBound, rightBound);
        sort(array, leftBound, mid - 1);
        sort(array, mid + 1, rightBound);
    }

    public static int partition(int[] array, int leftBound, int rightBound) {
        int pivot = array[rightBound];
        int left = leftBound;
        int right = rightBound - 1;

        while (left <= right) {
            while (left <= right && array[left] <= pivot) left++;
            while (left <= right && array[right] > pivot) right--;
            if (left < right) swap(array, left, right);
        }
        swap(array, left, rightBound);
        return left;
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

7.计数排序

public class CountSort {
    public static void main(String[] args) {
        int[] a = {2, 4, 2, 3, 7, 1, 1, 0, 0, 5, 6, 9, 8, 5, 7, 4, 0, 9};

        //int[] result = sort(a);
        int[] resultrange = sortrange(a, 5, 9);
        System.out.println(Arrays.toString(resultrange));
    }

    public static int[] sortrange(int[] array, int leftbound, int rightbound) {
        int[] result = new int[rightbound - leftbound+1];
        int[] count = new int[10 - leftbound];
        System.out.println(array.length);

        for (int i = 0; i < array.length; i++) {
            while (array[i] >= leftbound && array[i] <= rightbound) {
                if( i<array.length-1){
                    count[array[i]-leftbound]++;
                    i++;
                }else{
                    count[array[i]-leftbound]++;
                    break;
                }

            }

        }

        System.out.println(Arrays.toString(count));

        /*for (int i = 0, j = 0; i < count.length; i++) {
            while (count[i]-- > 0) result[j++] = i;
        }
        return result;*/

        for (int i = 1; i < count.length; i++) {
            count[i] = count[i] + count[i - 1];
        }

        System.out.println(Arrays.toString(count));

        for (int i = count.length-1; i > 0; i--) {
            result[--count[i]] = count[i];
        }
        return result;
    }

    public static int[] sort(int[] array) {
        int[] result = new int[array.length];
        int[] count = new int[10];

        for (int i = 0; i < array.length; i++) {
            count[array[i]]++;
        }

        System.out.println(Arrays.toString(count));

        /*for (int i = 0, j = 0; i < count.length; i++) {
            while (count[i]-- > 0) result[j++] = i;
        }
        return result;*/

        for (int i = 1; i < count.length; i++) {
            count[i] = count[i] + count[i - 1];
        }

        System.out.println(Arrays.toString(count));

        for (int i = array.length - 1; i >= 0; i--) {
            result[--count[array[i]]] = array[i];
        }
        return result;
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

8.基数排序

public class RadixSort {
    public static void main(String[] args) {
        int[] a = {421, 240, 115, 532, 305, 430, 124};
        int[] countarray = new int[a.length];
        for (int i = 0; i < a.length; i++) {
            countarray[i] = lengthNum(a[i]);
        }
        int n = findMax(countarray);
        int[] result = sort(a, n);
        System.out.println(Arrays.toString(result));
    }

    public static int[] sort(int[] array, int n) {
        int[] result = new int[array.length];
        int[] count = new int[10];

        for (int i = 0; i < n; i++) {
            int division = (int) Math.pow(10, i);
            System.out.println(division);
            for (int j = 0; j < array.length; j++) {
                int num = array[j] / division % 10;
                System.out.print(num + " ");
                count[num]++;
            }
            /*System.out.println();
            System.out.println(Arrays.toString(count));*/

            for (int k = 1; k < count.length; k++) {
                count[k] = count[k] + count[k - 1];
            }
            //System.out.println(Arrays.toString(count));

            for (int m = array.length-1; m >=0; m--) {
                int num = array[m] / division % 10;
                result[--count[num]] = array[m];
            }

            System.arraycopy(result,0,array,0,array.length);
            Arrays.fill(count,0);
        }

        return result;
    }

    public static int findMax(int[] array) {
        int len = array.length - 1;
        for (int i = 0; i < len; i++) {
            if (array[i] > array[i + 1]) swap(array, i, i + 1);
        }
        int max = array[len];
        return max;
    }

    public static int lengthNum(int num) {
        int count = 0;
        while (num >= 1) {
            num /= 10;
            count++;
        }
        return count;
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void print(int[] array) {
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

对数器

import java.util.Arrays;
import java.util.Random;

import static day01_sort.SelectSort.print;

public class DataChecker {
    static int[] getRandomArray() {
        Random r = new Random();
        int[] arr = new int[10000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(10000);
        }
        return arr;
    }

    static void checker() {
        boolean same = true;
        for (int times = 0; times <1000 ; times++) {
            int[] arr = getRandomArray();
            int[] arr2 = new int[arr.length];
            System.arraycopy(arr, 0, arr2, 0, arr.length);
            /*print(arr);
            System.out.println(" ");*/

            Arrays.sort(arr);
//        SelectSort.sort(arr2);
//        BubbleSort.sort(arr2);
//        InsertSort.sortImprove(arr2);
//        ShellSort.sort(arr);
//        ShellSort.sortknuth(arr);
//        MergeSort.sort(arr2,0,arr2.length-1);
            QuickSort.sort(arr2,0,arr2.length-1);


            for (int i = 0; i < arr2.length; i++) {
                if (arr[i] == arr2[i]) same = true;
            }
        }

        /*print(arr);
        System.out.println(" ");
        print(arr2);
        System.out.println(" ");*/
        System.out.println(same == true ? "right":"wrong");
    }

    public static void main(String[] args) {
        checker();
    }
}

TimSort

归并排序和二分法快速排序的结合

对数插入排序

荷兰国旗问题

考拉ta哥
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值