https://github.com/hustcc/JS-Sorting-Algorithm
1.冒泡
-
比较相邻的元素。如果第一个比第二个大,就交换他们两个。
-
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
-
针对所有的元素重复以上的步骤,除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
public int[] sortArr(int[] arr) {
for (int i = 1; i < arr.length; i++) {
// 设定一个标记,若为true,则表示此次循环没有进行交换,也就是待排序列已经有序,排序已经完成。
boolean flag = true;
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
flag = false;
}
}
if (flag) {
break;
}
}
return arr;
}
之前没加这个标记,后来发现加上一个标记 耗时少.
2.选择排序 不稳定
-
首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置
-
再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
-
重复第二步,直到所有元素均排序完毕。
public int[] sortArr(int[] arr) {
// 总共要经过 N-1 轮比较
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
// 每轮需要比较的次数 N-i
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
// 记录目前能找到的最小值元素的下标
min = j;
}
}
// 将找到的最小值和i位置所在的值进行交换
if (i != min) {
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
return arr;
}
发现比冒泡快一点,
3.插入排序
/**
* 默认 是 坐标0的 数据 是一个 排好的最终形式
* 然后 从坐标1开始 逐个与 坐标0 的排好的集合
* 进行 比较 插入相应的位置
* @param arr
* @return
*/
public int[] sortArr(int[] arr) {
// 从下标为1的元素开始选择合适的位置插入,因为下标为0的只有一个元素,默认是有序的
for (int i = 1; i < arr.length; i++) {
// 记录要插入的数据
int tmp = arr[i];
// 从已经排序的序列最右边的开始比较,找到比其小的数
int j = i;// 当前的 为
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1];
j--;
}
// 存在比其小的数,插入
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}
可能数据比较少 看不出来 感觉和选择排序差不多,但是肯定比上面节省,有几率少走很多判断 对比 如果要比较的数正好正好排在后面那就快了
4.希尔排序 不稳定
/**
* 希尔排序
* 希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
*
* @param arr
* @return
*/
public int[] sortArr(int[] arr) {
int gap = 1;
while (gap < arr.length) {
gap = gap * 3 + 1;
}
while (gap > 0) {
for (int i = gap; i < arr.length; i++) {
int tmp = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > tmp) {
arr[j + gap] = arr[j];
j -= gap;
}
arr[j + gap] = tmp;
}
gap = (int) Math.floor(gap / 3);
}
return arr;
}
试了一下 少了几个数据 ,,快是挺快的.......
5.归并排序
-
申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;
-
设定两个指针,最初位置分别为两个已经排序序列的起始位置;
-
比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;
-
重复步骤 3 直到某一指针达到序列尾;
-
将另一序列剩下的所有元素直接复制到合并序列尾。
/**
* 归并排序
* 希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
*
* @param arr
* @return
*/
public int[] sortArr(int[] arr) {
if (arr.length < 2) {
return arr;
}
//floor 是11.23=11.56=11.78= 11 小数不要
int middle = (int) Math.floor(arr.length / 2);
//把原数组 拆分成俩个数组
int[] left = Arrays.copyOfRange(arr, 0, middle);
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
return merge(sortArr(left), sortArr(right));
}
/**
* 分而治之 就是归并排序
* @param left
* @param right
* @return
*/
protected int[] merge(int[] left, int[] right) {
//这个集合就是新的集合 会把排序号的 放进去
int[] result = new int[left.length + right.length];
int i = 0;
while (left.length > 0 && right.length > 0) {
//如果左边集合的第一个元素小于等于 右边集合的第一个元素
// 那么把它复制给 新集合的第一个元素 然后i++
if (left[0] <= right[0]) {
result[i++] = left[0];
//因为木有Remove 方法 所以只好 Arrays.copyOfRange
left = Arrays.copyOfRange(left, 1, left.length);
} else {
//如果左边集合的第一个元素 大于 右边集合的第一个元素 那么就把右边第一个元素放到新集合中
//总之 谁小 放谁
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
// 这俩个循环都是防止 上面地循环走不动了 还会有残留 嗯 应该是这样
while (left.length > 0) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
while (right.length > 0) {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
6.快速排序 稳定排序
-
从数列中挑出一个元素,称为 “基准”(pivot);
-
重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
-
递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;
/**
* 快速排序 感觉都差不多速度 插入排序比快排要快
* @param arr
* @param left 0开始的坐标
* @param right 最后一个坐标
* @return
*/
private int[] quickSort(int[] arr, int left, int right) {
//如果没到最后一个坐标那就不停
if (left < right) {
int partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex - 1);
quickSort(arr, partitionIndex + 1, right);
}
return arr;
}
private int partition(int[] arr, int left, int right) {
// 设定基准值(pivot)
int pivot = left;
int index = pivot + 1;
for (int i = index; i <= right; i++) {
if (arr[i] < arr[pivot]) {
swap(arr, i, index);
index++;
}
}
swap(arr, pivot, index - 1);
return index - 1;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
7.堆排序 不稳定直接Pass
-
创建一个堆 H[0……n-1];
-
把堆首(最大值)和堆尾互换;
-
把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置;
-
重复步骤 2,直到堆的尺寸为 1。
public class Main5Activity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main5);
//堆排序 不稳定
buildMaxHeap(arr, len);
for (int i = len - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0, len);
}
}
private void buildMaxHeap(int[] arr, int len) {
for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
heapify(arr, i, len);
}
}
private void heapify(int[] arr, int i, int len) {
int left = 2 * i + 1;
int right = 2 * i + 2;
int largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
heapify(arr, largest, len);
}
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
8.计数排序
public class Main5Activity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main5);
int[] arr = {0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5};
long l = System.currentTimeMillis();
int maxValue = getMaxValue(arr);
int[] ints = countingSort(arr, maxValue);
long l1 = System.currentTimeMillis();
System.out.println("耗时:(ms)" + (l1 - l));
for (int i = 0; i < ints.length; i++) {
System.out.println(ints[i]);
}
}
private int[] countingSort(int[] arr, int maxValue) {
int bucketLen = maxValue + 1;
int[] bucket = new int[bucketLen];
for (int value : arr) {
bucket[value]++;
}
int sortedIndex = 0;
for (int j = 0; j < bucketLen; j++) {
while (bucket[j] > 0) {
arr[sortedIndex++] = j;
bucket[j]--;
}
}
return arr;
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
}
耗时0,这方法不错,可惜只能是整数.
9.桶排序
桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:
- 在额外空间充足的情况下,尽量增大桶的数量
- 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
同时,对于桶中元素的排序,选择何种比较排序算法对于性能的影响至关重要。
public class Main5Activity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main5);
int[] arr = {0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5};
long l = System.currentTimeMillis();
int[] ints = new int[0];
try {
ints = bucketSort(arr, 5);
} catch (Exception e) {
e.printStackTrace();
}
long l1 = System.currentTimeMillis();
System.out.println("耗时:(ms)" + (l1 - l));
for (int i = 0; i < ints.length; i++) {
System.out.println(ints[i]);
}
}
private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
if (arr.length == 0) {
return arr;
}
int minValue = arr[0];
int maxValue = arr[0];
for (int value : arr) {
if (value < minValue) {
minValue = value;
} else if (value > maxValue) {
maxValue = value;
}
}
int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
int[][] buckets = new int[bucketCount][0];
// 利用映射函数将数据分配到各个桶中
for (int i = 0; i < arr.length; i++) {
int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
buckets[index] = arrAppend(buckets[index], arr[i]);
}
int arrIndex = 0;
for (int[] bucket : buckets) {
if (bucket.length <= 0) {
continue;
}
// 对每个桶进行排序,这里使用了插入排序
bucket = sortArr(bucket);
for (int value : bucket) {
arr[arrIndex++] = value;
}
}
return arr;
}
/**
* 自动扩容,并保存数据
*
* @param arr
* @param value
*/
private int[] arrAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}
/**
* 默认 是 坐标0的 数据 是一个 排好的最终形式
* 然后 从坐标1开始 逐个与 坐标0 的排好的集合
* 进行 比较 插入相应的位置
* @param arr
* @return
*/
public int[] sortArr(int[] arr) {
// 从下标为1的元素开始选择合适的位置插入,因为下标为0的只有一个元素,默认是有序的
for (int i = 1; i < arr.length; i++) {
// 记录要插入的数据
int tmp = arr[i];
// 从已经排序的序列最右边的开始比较,找到比其小的数
int j = i;// 当前的 为
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1];
j--;
}
// 存在比其小的数,插入
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}
}
耗时:(ms)1,虽然时间长了一点,但是稳
也是,计数排序的升级/,这里需要结合插入排序
10.基数排序
基数排序是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。
public class Main5Activity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main5);
int[] arr = {0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5, 0, 54, 25, 4, 74, 1, 4, 5, 1, 5, 45, 1, 74, 41, 1, 47, 45, 1, 5, 1, 12, 65, 4, 74, 1, 4545, 2, 12, 6, 5, 232, 21, 5, 854, 8, 1, 263, 532, 12, 51, 4, 74, 54, 56, 21, 45, 1, 1212, 2, 12, 02, 2, 2, 20, 32, 35, 5};
long l = System.currentTimeMillis();
int maxDigit = getMaxDigit(arr);
int[] ints = radixSort(arr, maxDigit);
long l1 = System.currentTimeMillis();
System.out.println("耗时:(ms)" + (l1 - l));
for (int i = 0; i < ints.length; i++) {
System.out.println(ints[i]);
}
}
/**
* 获取最高位数
*/
private int getMaxDigit(int[] arr) {
int maxValue = getMaxValue(arr);
return getNumLenght(maxValue);
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
protected int getNumLenght(long num) {
if (num == 0) {
return 1;
}
int lenght = 0;
for (long temp = num; temp != 0; temp /= 10) {
lenght++;
}
return lenght;
}
private int[] radixSort(int[] arr, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
// 考虑负数的情况,这里扩展一倍队列数,其中 [0-9]对应负数,[10-19]对应正数 (bucket + 10)
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < arr.length; j++) {
int bucket = ((arr[j] % mod) / dev) + mod;
counter[bucket] = arrayAppend(counter[bucket], arr[j]);
}
int pos = 0;
for (int[] bucket : counter) {
for (int value : bucket) {
arr[pos++] = value;
}
}
}
return arr;
}
/**
* 自动扩容,并保存数据
*
* @param arr
* @param value
*/
private int[] arrayAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}
/**
* 默认 是 坐标0的 数据 是一个 排好的最终形式
* 然后 从坐标1开始 逐个与 坐标0 的排好的集合
* 进行 比较 插入相应的位置
* @param arr
* @return
*/
public int[] sortArr(int[] arr) {
// 从下标为1的元素开始选择合适的位置插入,因为下标为0的只有一个元素,默认是有序的
for (int i = 1; i < arr.length; i++) {
// 记录要插入的数据
int tmp = arr[i];
// 从已经排序的序列最右边的开始比较,找到比其小的数
int j = i;// 当前的 为
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1];
j--;
}
// 存在比其小的数,插入
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}
}
耗时:(ms)7 很稳