冒泡，选择，插入，希尔，归并，快速，堆排，计数，桶，基数排序
冒泡排序主要思想
从第一个元素开始，和第二个元素比较大小，如果比后面的元素小，就置换两个元素，这样依次传递，传递到最后一个元素，就是最大值，然后再从第一个元素开始，传递到倒数第二个元素，就是次最大元素，这样比较到最后就把数组排序完成
private static int[] bubbleSort(int[] arr) {
int len = arr.length;
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
选择排序思想
比较数据里面的所有元素，选择出最小的那个，放到第一个位置，
然后再从剩下所有元素选择出第二小的元素，放到第二个位置，依次类推，完成数组的排序
private static int[] selectSort(int[] arr) {
int len = arr.length;
for (int i = 1; i < len; i++) {
int min = arr[i - 1];
int index = i - 1;
for (int j = i; j < len; j++) {
if (arr[j] < min) {
index = j;
min = arr[j];
}
}
int temp = arr[i - 1];
arr[i - 1] = min;
arr[index] = temp;
}
return arr;
}
插入排序主要思想
固定第一个元素位置，然后从第二个元素开始，依次比较和之前元素的大小，如果比之前元素小，就把前面的元素往后移一位，直到找到当前元素应该插入的位置，将元素插入进去，
private static int[] insertSort(int[] arr) {
int len = arr.length;
for (int i = 1; i < len; i++) {
int num = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > num) {
arr[j + 1] = arr[j--];
}
arr[j + 1] = num;
}
return arr;
}
希尔排序，是一种优化的插入排序，这种算法的主旨是，将数组中的数据调整至大致从小到大的分布，这样再使用插入排序，比较的次数就会大大减少，一般会分成几组，最开始分成arr.length/2一组，再一次/2，保证最后能变成一大组的插入排序
private static int[] shellSort(int[] arr) {
int len = arr.length;
int num = len / 2;
while (num > 0) {
for (int i = 1; i < len; i++) {
for (int j = i + num; j < len; j += num) {
int poi = arr[j];
int pre = j - num;
while (pre >= 0 && arr[pre] > arr[pre + num]) {
int temp = arr[pre];
arr[pre] = arr[pre + num];
arr[pre + num] = temp;
pre -= num;
}
arr[pre + num] = poi;
}
}
num /= 2;
}
return arr;
}
归并排序主要思想
归并排序主要是分和和的概念，将一个数组从中间分为左右两部分，然后每一部分再分为左右两个部分，直到每一个部分只有一个元素，再将这两个元素排序，然后再递归上去和另一半排序，最后完成整个数组的排序。
private static int[] mergeSort(int[] arr) {
mergeSort(arr, 0, arr.length - 1);
return arr;
}
private static void mergeSort(int[] arr, int left, int right) {
if (left == right) {
return;
}
int mid = left + right / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, mid + 1, right);
}
private static void merge(int[] arr, int l1, int r1, int l2, int r2) {
int i = l1;
int[] temp = new int[r2 - l1 + 1];
int point = 0;
while (l1 <= r1 && l2 <= r2) {
if (arr[l1] <= arr[l2]) {
temp[point++] = arr[l1++];
continue;
}
temp[point++] = arr[l2++];
}
while (l1 <= r1) {
temp[point++] = arr[l1++];
}
while (l2 <= r2) {
temp[point++] = arr[l2++];
}
System.arraycopy(temp, 0, arr, i, temp.length);
}
快速排序主要思想
在数组中选一个点，然后置换整个点左右两边元素，将整个点左边的元素都变成不比整个点大的元素，右边都变成不比整个点小的元素，然后再在这个点的左右两边再选取一个点，完成这个操作。
private static int[] quickSort(int[] arr) {
quickSort(0, arr.length - 1, arr);
return arr;
}
private static void quickSort(int left, int right, int[] arr) {
if (left >= right) {
return;
}
int l = left;
int r = right;
int mid = (left + right) / 2;
int num = arr[mid];
while (left < right) {
while (left < mid && arr[left] <= num) {
left++;
}
while (right > mid && arr[right] >= num) {
right--;
}
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
if (mid == left) {
mid = right;
} else if (mid == right) {
mid = left;
}
}
quickSort(1, mid - 1, arr);
quickSort(mid + 1, r, arr);
}
堆排序主要思想
堆排序是将整个数组，想成一个完全二叉树，然后构建成一个大堆顶，这样就保证了最大的元素一定在二叉树的根节点，然后置换根节点和最后一个节点，最后一个位置上就是最大的值，然后用除了最后一个元素的数组确定第二大元素，依次类推完成数组的排序，
private static int[] heapSort(int[] arr) {
int len = arr.length;
for (int i = len / 2 - 1; i >= 0; i--) {
adjustHeap(i, arr, len);
}
for (int i = len - 1; i >= 0; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
adjustHeap(0, arr, i);
}
return arr;
}
private static void adjustHeap(int point, int[] arr, int length) {
int num = arr[point];
for (int i = point * 2 + 1; i < length; i = i * 2 + 1) {
if (i + 1 < length && arr[i + 1] > arr[i]) {
i++;
}
if (arr[i] > num) {
arr[point] = arr[i];
point = i;
} else {
break;
}
}
arr[point] = num;
}
**计数排序主要思想**
计数排序是一种用空间换时间的典型算法，找出数组的最大值和最小值，然后定义一个容量为最大值减去最小值的数组，根据原数组减去最小值的值，就可以定位到原数组的值应该放到空间数组的那个位置，最后遍历这个空间数组，完成排序。
```java
private static int[] countingSort(int[] arr) {
// 找出最大值和最小值
int min = arr[0], max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
} else if (arr[i] < min) {
min = arr[i];
}
}
int[] temp = new int[max - min + 1];
int offset = -min;
for (int j : arr) {
temp[j + offset]++;
}
int index = 0;
for (int i = 0; i < temp.length; i++) {
int j = temp[i];
while (j > 0) {
arr[index++] = i - offset;
j--;
}
}
return arr;
}
桶排序的思想
桶排序的思想是，定义若干个桶，使得，整个待排序的数组的元素可以均匀的放到桶中，因为每个桶中的元素不多，所以排序的时间复杂度可以忽略，然后依次遍历桶，取出桶中的元素，完成排序。
private static int[] bucketSort(int[] arr) {
int len = arr.length;
int min = arr[0];
int max = arr[0];
for (int i = 1; i < len; i++) {
min = Math.min(min, arr[i]);
max = Math.max(max, arr[i]);
}
int bucketSize = (max - min) / len + 1;
List<List<Integer>> bucketPool = new ArrayList<>();
for (int i = 0; i < bucketSize; i++) {
bucketPool.add(new ArrayList<>());
}
for (int j : arr) {
bucketPool.get((j - min)/ len).add(j);
}
for (List<Integer> list : bucketPool) {
Collections.sort(list);
}
int index = 0;
for (List<Integer> list : bucketPool) {
for (Integer num : list) {
arr[index++] = num;
}
}
return arr;
}
**```
**基数排序**
基数排序的思想是，首先确认整个待排序的数组最大的是几位数，然后定义十个桶，从0到9，按照个位数将所有的元素放到桶里面，然后排序，之后取出，然后按照十位依次放到桶里，排序，取出，直到最高位，完成排序，如果有负数的话，可以找出最小值，让所有的值都加上最小值的绝对值，将所有的数变成非负数，排序完再减回来
```java
private static int[] radixSort(int[] arr) {
//存数组中最大的数字,为了知道循环几次
int max = Integer.MIN_VALUE;//(整数中的最小数)
//遍历数组，找出最大值
for (int j : arr) {
if (max < j) {
max = j;
}
}
//计算最大数是几位数,,此方法计较绝妙
int maxLength = (max + "").length();
//用于临时存储数据的数组
int[][] temp = new int[10][arr.length];
//用于存储桶内的元素位置
int[] counts = new int[arr.length];
//第一轮个位数较易得到余数，第二轮就得先除以十再去取余，之后百位除以一百
//可以看出，还有一个变量随循环次数变化，为了取余
//循环的次数
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
//每一轮取余
for (int k : arr) {
//计算余数
int ys = (k / n) % 10;
//把便利店数据放在指定数组中，有两个信息，放在第几个桶+数据应该放在第几位
temp[ys][counts[ys]] = k;
//记录数量
counts[ys]++;
}
if (i == 0) {
//打印二维数组，测试
for (int[] nums : temp) {
System.out.println(Arrays.toString(nums));
}
}
}
return arr;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
