给定两个数组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轮就可以完成排序。

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

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