常用排序算法-Java实现

常用排序算法

基本术语：

1.时间复杂度：指对排序数据的总的操作次数；反映当n变化时，操作次数呈现什么规律
2.空间复杂度：指算法在计算机内执行时所需存储空间的度量，是数据规模n的函数
3.稳定：如果a原本在b前面且a=b，排序之后a仍然在b的前面 即为稳定
4.不稳定：如果a原本在b的前面且a=b，排序之后 a 可能会出现在 b 的后面
5.内部排序：所有排序操作都在内存中完成
6.外部排序：待排序记录的数量很大，在排序过程中需要对外存进行访问的排序过程

---

1. 冒泡排序
   冒泡排序就是重复“从序列左边开始比较相邻两个数字的大小，再根据结果交换两个数字的位置”这一操作的算法。在这个过程中，数字会像泡泡一样，慢慢从左往右“浮”到序列的顶端，所以这个算法才被称为“冒泡排序”
   1.冒泡排序的时间复杂度为O(n^2)
2.最好的时间复杂度为O(n) (序列本身即为从小到大)
3.最坏的时间复杂度为O(n^2)
4.空间复杂度: 空间复杂度为O(1)，常数级
5.稳定性: 当 a[j] == a[j+1] 的时候，不交换 a[j] 和 a[j+1]，所以冒泡排序是稳定的
   
   算法实现

/**
         * 常规冒泡排序
         * @param a 待排序数组
         * @return 排序后的数组
         */
        public static int[] bubbleSortNormal(int[] a) {
            if (null == a || a.length < 2) {
                return a;
            }

            //外循环一次为一趟排序 在一趟排序中让一个待排序元素和其他元素一一比较
            for (int i = 0; i < a.length; i++) {

                //内循环一次 即为一次相邻比较
                for (int j = 0; j < a.length - 1 - i; j++) {
                    if (a[j + 1] < a[j]) {
                        int temp = a[j + 1];
                        a[j + 1] = a[j];
                        a[j] = temp;
                    }
                }
            }
            return a;
        }

        /**
         * 冒泡排序--优化
         * @param a 待排序数组
         * @return 排序后的数组
         */
        public static int[] bubbleSortOptimize(int[] a) {
            if (null == a || a.length < 2) {
                return a;
            }

            //外循环一次为一趟排序 在一趟排序中让一个待排序元素和其他元素一一比较
            for (int i = 0; i < a.length; i++) {

                //设置标识，判断一趟排序是否发生了交换 如果未发生交换，则说明数组已经有序，不必再排序了
                boolean isSwap = false;
                //内循环一次 即为一次相邻比较
                for (int j = 0; j < a.length - 1 - i; j++) {
                    if (a[j + 1] < a[j]) {
                        int temp = a[j + 1];
                        a[j + 1] = a[j];
                        a[j] = temp;
                        isSwap = true;
                    }
                }
                if(!isSwap) {
                    break;
                }
            }
            return a;
        }

2. 选择排序
   选择排序就是重复“从待排序的数据中寻找最小值，将其与序列最左边的数字进行交换”这一操作的算法。在序列中寻找最小值时使用的是线性查找
   1.选择排序平均时间复杂度为O(n^2)，最好时间复杂度为O(n^2)，最坏时间复杂度为O(n^2)
2.最好情况: 如果待排序数据本来就是正序的，则移动数据次数为 0，但需要进行(n-1)+(n-2)+...+(2)+(1)= n * (n - 1) / 2 次比较
3.空间复杂度: 空间复杂度为O(1)，常数级
4.稳定性：选择排序不稳定，比如序列 3、5、3、1，我们知道第一趟排序第 1 个元素 3 会和 1 交换，那么原序列中 2 个 3 的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法
   
   
   
   算法实现

public static int[] selectionSort(int[] a) {
            if (null == a || a.length < 2) {
                return a;
            }

            for (int i = 0; i < a.length; i++) {//排序的趟数
                int minIndex = i;
                for (int j = i; j < a.length; j++) {
                    if (a[j] < a[minIndex]) {//通过内循环 找到最小的数
                        minIndex = j; //更新最小数的索引
                    }
                }

                //将最小数和无序区的第一个数交换
                int temp = a[minIndex]; //通过内循环找到的最小数
                a[minIndex] = a[i]; //交换待排序数和最小数
                a[i] = temp;
            }

            return a;
        }

3. 插入排序
   插入排序是一种从序列左端开始依次对数据进行排序的算法。在排序过程中，左侧的数据陆续归位，而右侧留下的就是还未被排序的数据。插入排序的思路就是从右侧的未排序区域内取出一个数据，然后将它插入到已排序区域内合适的位置上
   1.插入排序的时间复杂度为O(n^2)
2.最好的时间复杂度为O(n) (序列本身即为从小到大)
3.最坏的时间复杂度为O(n^2)
4.空间复杂度: 空间复杂度为O(1)，常数级
5.稳定性: 插入排序不会交换相等的元素 是稳定
   
   
   算法实现

public static void insertionSort(int[] data) {
            if (null == data || data.length == 0) {
                return;
            }

            int j;// 排序指针
            for (int p = 1; p < data.length; p++) {
                int temp = data[p];// 从第二个数据开始(第一个数据假定是排好序的)
                // 和自己前面的数据依次比较（内循环）
                for (j = p; j >0 && temp < data[j-1]; j--) {// 找出p位置对应数据排序后应在的位置
                    data[j] = data[j-1];// 将大于自己的数据后移一位
                }
                data[j] = temp;//移动位置p的元素到排序后的位置
            }

            System.out.println("排序后: ");
            System.out.println(Arrays.toString(data));
        }

4. 堆排序

在这里插入代码片

5. 快速排序

在这里插入代码片