数据结构排序方法总结

给定两个数组A,B，将A,B排序合并成一个数组，输出升序排列后的新数组。数组A,B中为整数，字母。

下面是代码：

import java.util.Arrays;
    public class Solution15 {
        //冒泡排序
        public static void bubbleSort(String[] array) {
            int n = array.length;
            for (int i = 0; i < n - 1; i++) {
                for (int j = 0; j < n - i - 1; j++) {
                    if (array[j].compareTo(array[j + 1]) > 0) {
                        // 交换元素
                        String temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }

        public static void main(String[] args) {
            String[] A = {"d", "3", "a", "5"};
            String[] B = {"b", "4", "1", "c"};
            String[] mergedArray = mergeArrays(A, B);
            bubbleSort(mergedArray);
            System.out.println(Arrays.toString(mergedArray));
        }

        private static String[] mergeArrays(String[] A, String[] B) {
            String[] result = new String[A.length + B.length];
            // arraycopy主要定义是源数组 起始点，复制长度，目标起点，复制长度
            System.arraycopy(A, 0, result, 0, A.length);
            System.arraycopy(B, 0, result, A.length, B.length);
            return result;
        }


        //快排
        public static void quickSort(String[] array, int low, int high) {
            if (low < high) {
                int pi = partition(array, low, high);
                quickSort(array, low, pi - 1);
                quickSort(array, pi + 1, high);
            }
        }

        private static int partition(String[] array, int low, int high) {
            String pivot = array[high];
            int i = (low - 1);
            for (int j = low; j < high; j++) {
                if (array[j].compareTo(pivot) < 0) {
                    i++;
                    // 交换元素
                    String temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
            // 交换元素
            String temp = array[i + 1];
            array[i + 1] = array[high];
            array[high] = temp;
            return i + 1;
        }

        //堆排
        public static void heapSort(String[] array) {
            int n = array.length;

            // 构建堆
            for (int i = n / 2 - 1; i >= 0; i--) {
                heapify(array, n, i);
            }

            // 提取元素
            for (int i = n - 1; i > 0; i--) {
                // 交换元素
                String temp = array[0];
                array[0] = array[i];
                array[i] = temp;

                heapify(array, i, 0);
            }
        }

        private static void heapify(String[] array, int n, int i) {
            int largest = i;
            int left = 2 * i + 1;
            int right = 2 * i + 2;

            if (left < n && array[left].compareTo(array[largest]) > 0) {
                largest = left;
            }

            if (right < n && array[right].compareTo(array[largest]) > 0) {
                largest = right;
            }

            if (largest != i) {
                // 交换元素
                String swap = array[i];
                array[i] = array[largest];
                array[largest] = swap;

                heapify(array, n, largest);
            }

        }
        // 希尔排序
        public static void shellSort(String[] array) {
            int n = array.length;
            for (int gap = n / 2; gap > 0; gap /= 2) {
                for (int i = gap; i < n; i++) {
                    String temp = array[i];
                    int j;
                    for (j = i; j >= gap && array[j - gap].compareTo(temp) > 0; j -= gap) {
                        array[j] = array[j - gap];
                    }
                    array[j] = temp;
                }
            }
        }
        //插入排序
        public static void insertionSort(String[] array) {
            int n = array.length;
            for (int i = 1; i < n; i++) {
                String key = array[i];
                int j = i - 1;
                while (j >= 0 && array[j].compareTo(key) > 0) {
                    array[j + 1] = array[j];
                    j = j - 1;
                }
                array[j + 1] = key;
            }
        }
        // 选择排序
        public static void selectionSort(String[] array) {
            int n = array.length;
            for (int i = 0; i < n - 1; i++) {
                int minIndex = i;
                for (int j = i + 1; j < n; j++) {
                    if (array[j].compareTo(array[minIndex]) < 0) {
                        minIndex = j;
                    }
                }
                // 交换元素
                String temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
        }

    }

这里我们说下因为基数排序大多用在整数排序，所以这里不列出来。

1.直接插入排序的思想是指：每次将一个待排序的元素按大小插入到前面己排好序的有序表中，直到全部元素排序完成。最开始默认当前有序表的第0个元素成为一个已经排序好的有序的子数组 直接插入排序的时间复杂度为O( n2 ) 

2.希尔排序( Shell’s Sort)又称“缩小增量排序”( Diminishing Increment Sort)，是插入排序的一种， 因D.L.Shell 于1959 年提出而得名。直接插人排序，当待排序的记录个数较少且待排序序列的关键字基本有序时，效率较高。希尔排序基于以上两点，从“减少记录个数”和“序列基本有序”两个方面对直接插入排序进行了改进。

基本思想：
先将整个待排记录序列分割成若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

希尔排序特点:
（1)缩小增量
（2)多遍插入排序

3.直接选择排序
概念：直接选择排序又称简单选择排序，是一种不稳定的排序方法，其是选择排序中最简单一种，其基本思想是：第 i 趟排序再待排序序列 a[i]~a[n] 中选取关键码最小的记录，并和第 i 个记录交换作为有序序列的第 i 个记录。
其实现利用双重循环，外层 i 控制当前序列最小值存放的数组元素位置，内层循环 j 控制从 i+1 到 n 序列中选择最小的元素所在位置 k

具体的排序过程为：

1.将整个记录序列划分为有序区和无序区，初始时有序区为空，无序区含有待排序的所有记录
2.在无序区选择关键码最小的记录，将其与无序区中的第一个元素，使得有序区扩展一个记录，同时无序区减少了一个记录
3.不断重复步骤 2，直到无序区只剩下一个记录为止

4.堆排序
基本思想：

1.首先将待排序的数组构造成一个大堆，此时，整个数组的最大值就是堆结构的顶端

2.将顶端的数与末尾的数交换，此时，末尾的数为最大值，剩余待排序数组个数为n-1

3.将剩余的n-1个数再构造成大堆，再将顶端数与n-1位置的数交换，如此反复执行，便能得到有序数组

构造堆
将无序数组构造成一个大根堆（升序用大根堆，降序就用小根堆）

每次新插入的数据都与其父结点进行比较，如果插入的数比父结点大，则与父结点交换，否则一直向上交换，直到小于等于父结点，或者来到了顶端

固定最大值再构造堆。

5.冒泡排序
冒泡排序是比较基础的排序算法之一，其思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端。整个过程如同气泡冒起，因此被称作冒泡排序。
冒泡排序的步骤是比较固定的：
①比较相邻的元素。如果第一个比第二个大，就交换他们两个。
②每趟从第一对相邻元素开始，对每一对相邻元素作同样的工作，直到最后一对。
③针对所有的元素重复以上的步骤，除了已排序过的元素(每趟排序后的最后一个元素)，直到没有任何一对数字需要比较

6.快速排序

也是一种较为基础的排序算法，其效率比冒泡排序算法有大幅提升。因为使用冒泡排序时，一趟只能选出一个最值，有n个元素最多就要执行n - 1趟比较。而使用快速排序时，一次可以将所有元素按大小分成两堆，也就是平均情况下需要logn轮就可以完成排序。

快速排序的思想是：
每趟排序时选出一个基准值，然后将所有元素与该基准值比较，并按大小分成左右两堆，然后递归执行该过程，直到所有元素都完成排序。

快速排序的步骤如下：
①先从数列中取出一个数作为基准数。
②分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
③再对左右区间重复第二步，直到各区间只有一个数