给定两个数组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轮就可以完成排序。
快速排序的思想是:
每趟排序时选出一个基准值,然后将所有元素与该基准值比较,并按大小分成左右两堆,然后递归执行该过程,直到所有元素都完成排序。
快速排序的步骤如下:
①先从数列中取出一个数作为基准数。
②分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。
③再对左右区间重复第二步,直到各区间只有一个数