java实现各种排序算法及比较

常见排序算法包括以下七种:选择排序、冒泡排序、插入排序、快速排序、希尔排序、堆排序、归并排序。
在学习具体算法实现并进行比较前,先来学习算法比较的几个维度。
一是稳定性
所谓稳定性,是指值相等的两个元素在排序前后是否会发生位置的交换。如果不会发生交换,则认为是稳定的算法;反之,则认为是不稳定的排序算法。
二是时间复杂度,指执行算法所需的时间长短。简单说就是算法执行的快慢程序。
三是空间复杂度,指执行算法所占用的内存大小。
有了这些基本概念,下面就来看以上七种排序算法的java版实现

/**
 * <一句话功能简述>
 */
public class AllSort {

    /**
     * 快速排序<br/>
     * 不稳定排序,时间复杂度O(nlogn)
     * 
     * @param a
     * @param left
     * @param right
     * @return
     */
    public static void quickSort(int[] a, int left, int right) {
        if (left >= right)
            return;

        int i, j, temp;
        i = left;
        j = right;
        temp = a[left];

        while (i != j) {
            while (a[j] >= temp && i < j)
                j--;

            while (a[i] <= temp && i < j)
                i++;

            if (i < j) {
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
                j--;
            }
        }

        a[left] = a[i];
        a[i] = temp;

        if (left < i - 1)
            quickSort(a, left, i - 1);
        if (i + 1 < right)
            quickSort(a, i + 1, right);
    }

    /**
     * 选择排序<br/>
     * 不稳定排序,时间复杂度为O(n2)
     * 
     * @param a
     * @return
     */
    public static void choseSort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            int min_index = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[min_index] > a[j]) {
                    min_index = j;
                }
            }
            if (i != min_index) {
                int temp = a[i];
                a[i] = a[min_index];
                a[min_index] = temp;
            }
        }
    }

    /**
     * 冒泡排序<br/>
     * 稳定排序,时间复杂度为O(n2)
     * 
     * @param a
     * @return
     */
    public static void bubbleSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            for (int j = 0; j < a.length - i; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

    /**
     * 直接插入排序<br/>
     * 稳定排序,时间复杂度O(n2)
     * 
     * @param a
     * @return
     */
    public static void insertSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            int temp = a[i];
            int pos = i - 1;
            while (pos >= 0 && a[pos] > temp) {
                a[pos + 1] = a[pos];
                pos--;
            }
            a[pos + 1] = temp;
        }
    }

    /**
     * 希尔排序<br/>
     * 不稳定排序,时间复杂度O(nlogn)
     * 
     * @param a
     * @return
     */
    public static void shellSort(int[] a) {
        int d = a.length / 2;
        while (d >= 1) {
            for (int i = 0; i < d; i++) {
                for (int j = i + d; j < a.length; j = j + d) {
                    int temp = a[j];
                    int pos = j - d;
                    while (pos >= 0 && a[pos] > temp) {
                        a[pos + d] = a[pos];
                        pos -= d;
                    }
                    a[pos + d] = temp;
                }
            }
            d = d / 2;
        }

    }

    /**
     * 归并排序<br/>
     * 稳定排序,时间复杂度O(nlogn),速度仅次于快速排序
     * 
     * @param a
     * @param left
     * @param right
     * @return
     */
    public static void mergeSort(int[] a, int left, int right) {
        if (left < right) {
            int middle = (left + right) / 2;
            // 对左边进行递归
            mergeSort(a, left, middle);
            // 对右边进行递归
            mergeSort(a, middle + 1, right);
            // 合并
            merge(a, left, middle, right);
        }
    }

    private static void merge(int[] a, int left, int middle, int right) {
        int[] tmpArr = new int[right - left + 1];
        int pos = 0;

        int i = left;// 左边起始位置
        int j = middle + 1; // 右边起始位置
        while (i <= middle && j <= right) {
            // 从两个数组中选取较小的数放入中间数组
            if (a[i] <= a[j]) {
                tmpArr[pos++] = a[i++];
            } else {
                tmpArr[pos++] = a[j++];
            }
        }
        // 将剩余的部分放入中间数组
        while (i <= middle) {
            tmpArr[pos++] = a[i++];
        }
        while (j <= right) {
            tmpArr[pos++] = a[j++];
        }
        // 将中间数组复制回原数组
        int start = 0;
        while (left <= right) {
            a[left++] = tmpArr[start++];
        }
    }

    /**
     * 堆排序<br/>
     * 不稳定排序,时间复杂度O(nlogn)
     * @param a 
     * @return
     */
    public static void heapSort(int[] a) {
        int lastIndex = a.length - 1;
        for (int i = 0; i < lastIndex; i++) {
            // 建堆
            buildMaxHeap(a, lastIndex - i);
            // 交换堆顶和最后一个元素
            swap(a, 0, lastIndex - i);
            // System.out.println(Arrays.toString(a));
        }
    }

    private static void buildMaxHeap(int[] data, int lastIndex) {
        // 从lastIndex处节点(最后一个节点)的父节点开始
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
            // k保存正在判断的节点
            int k = i;
            // 如果当前k节点的子节点存在
            while (k * 2 + 1 <= lastIndex) {
                // k节点的左子节点的索引
                int biggerIndex = 2 * k + 1;
                // 如果biggerIndex小于lastIndex,即biggerIndex+1代表的k节点的右子节点存在
                if (biggerIndex < lastIndex) {
                    // 若果右子节点的值较大
                    if (data[biggerIndex] < data[biggerIndex + 1]) {
                        // biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                // 如果k节点的值小于其较大的子节点的值
                if (data[k] < data[biggerIndex]) {
                    // 交换他们
                    swap(data, k, biggerIndex);
                    // 将biggerIndex赋予k,开始while循环的下一次循环,重新保证k节点的值大于其左右子节点的值
                    k = biggerIndex;
                } else {
                    break;
                }
            }
        }
    }

    private static void swap(int[] data, int i, int j) {
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

    public static void main(String[] args) {
        Random random = new Random();
        int[] a = new int[20];
        for (int i = 0; i < a.length; i++) {
            a[i] = random.nextInt(20);
        }

        //quickSort(a, 0, a.length - 1);
        //mergeSort(a, 0, a.length - 1);
        //shellSort(a);
        //heapSort(a);
        //choseSort(a);
        //bubbleSort(a);
        //insertSort(a);
        System.out.println(Arrays.toString(a));

    }

}

各排序算法比较如下图
这里写图片描述
这个是摘自网上的比较,仅供参考。
我对有些项持怀疑态度,例如归并排序,个人认为空间复杂度不应该是O(1),而应该是O(nlog2n)。而快速排序的空间复杂度是O(1)。

图解Java数据结构和算法

06-21
1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题:1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级 3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容:本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

java数据结构算法

11-22
做一门精致,全面详细的 java数据结构与算法!!! 让天下没有难学的数据结构, 让天下没有难学的算法, 不吹不黑,我们的讲师及其敬业,可以看到课程视频,课件,代码的录制撰写,都是在深夜,如此用心,其心可鉴,他不掉头发,谁掉头发??? 总之你知道的,不知道的,我们都讲,并且持续更新,走过路过,不要错过,不敢说是史上最全的课程,怕违反广告法,总而言之,言而总之,这门课你值得拥有,好吃不贵,对于你知识的渴求,我们管够管饱 话不多说,牛不多吹,我们要讲的本门课程内容: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值