排序算法
- 术语说明
1.1稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面
1.2不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
1.3内排序：所有排序操作都在内存中完成；
1.4外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
1.5时间复杂度： 一个算法执行所耗费的时间。
1.6空间复杂度：运行完一个程序所需内存的大小。 - 总结
图片解释：
n: 数据规模
k: “桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存 - 算法分类
- 比较和非比较的区别
常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。
在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。
比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。
计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。
非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。
非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。
冒泡排序
-
演示
-
代码实现
/**
* 冒泡排序
* 最佳情况 T(n)=O(n)
* 最差情况 T(n)=O(n^2)
* 平均情况 T(n)= O(n^2)
* 空间复杂度 O(1)
* 稳定
* @param arr
* @return
*/
public static char[] bubbling(char[] arr){
if (arr.length ==0){
return arr;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(Arrays.toString(arr));
for (int j= 0;j < arr.length-1-i;j++){
if (arr[j+1]<arr[j]){
char temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
选择排序
- 演示
- 代码实现
/**
* 选择排序
* 稳定O(n^2)
* 空间复杂度O(1)
* 不稳定（云线相等的两个数排完序可能调换位置）
* @param arr
* @return
*/
public static int[] selecting(int[] arr){
if (arr.length == 0){
return arr;
}
for (int i = 0; i < arr.length; i++) {
int minindex=i;
for (int j=i;j<arr.length;j++){
if (arr[j]<arr[minindex]){
minindex=j;
}
}
int temp=arr[minindex];
arr[minindex]=arr[i];
arr[i]=arr[minindex];
}
return arr;
}
插入排序
- 演示
- 代码实现
/**
* 插入排序
* 最佳情况：T(n) = O(n)
* 最坏情况：T(n) = O(n^2)
* 平均情况：T(n) = O(n^2)
* 空间复杂度O(1)
* 稳定
* @param arr
* @return
*/
public static int[] inserting(int[] arr){
if(arr.length == 0){
return arr;
}
int current;
for (int i = 0; i < arr.length-1; i++) {
current=arr[i+1];
int preindex=i;
while (preindex >=0 && current<arr[preindex]){
arr[preindex + 1]=arr[preindex];
preindex--;
}
arr[preindex+1]=current;
}
return arr;
}
希尔排序
- 演示
- 代码实现
/**
* 希尔排序 又称缩小增进量排序
* 最好 O(n log 2 n)
* 最坏O(n log 2 n)
* 平均O(n log n)
* 空间复杂度 O(1)
* 不稳定（排序前相等的两个数，排序后可能改变顺序）
* @param arr
* @return
*/
public static int[] shelling(int[] arr){
int len=arr.length;
int temp,gap=len/2;
while (gap>0){
for (int i=gap;i<len;i++){
temp=arr[i];
int preindex=i-gap;
while (preindex>=0 && arr[preindex]>temp){
arr[preindex+gap]=arr[preindex];
preindex-=gap;
}
arr[preindex + gap]=temp;
}
gap/=2;
System.out.println(Arrays.toString(arr));
}
return arr;
}
归并排序
- 演示
- 代码实现
/**
* 归并排序 采用分治法
* 平均时间复杂度 O(n log n)
* 空间复杂度O(n) 需要额外空间
* 稳定
* @param arr
* @return
*/
// 归并排序（Java-迭代版）
public static void merge_sort_iteration(int[] arr) {
int len = arr.length;
int[] result = new int[len];
int block, start;
for(block = 1; block < len*2; block *= 2) {
for(start = 0; start <len; start += 2 * block) {
int low = start;
int mid = Math.min((start + block), len);
int high = Math.min((start + 2 * block), len);
//两个块的起始下标及结束下标
int start1 = low;
int start2 = mid;
//开始对两个block进行归并排序
while (start1 < mid && start2 < high) {
result[low++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
}
while(start1 < mid) {
result[low++] = arr[start1++];
}
while(start2 < high) {
result[low++] = arr[start2++];
}
}
int[] temp = arr;
arr = result;
result = temp;
}
result = arr;
}
// 归并排序（Java-递归版）
static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {
if (start >= end)
return;
int len = end - start, mid = (len >> 1) + start;
int start1 = start;
int start2 = mid + 1;
merge_sort_recursive(arr, result, start1, mid);
merge_sort_recursive(arr, result, start2, end);
int k = start;
while (start1 <= mid && start2 <= end)
result[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
while (start1 <= mid)
result[k++] = arr[start1++];
while (start2 <= end)
result[k++] = arr[start2++];
for (k = start; k <= end; k++)
arr[k] = result[k];
}
public static void merge_sort(int[] arr) {
int len = arr.length;
int[] result = new int[len];
merge_sort_recursive(arr, result, 0, len - 1);
}
快速排序
- 演示
- 代码实现
/**
* 快速排序方法
* 最佳情况：T(n) = O(nlogn)
* 最差情况：T(n) = O(n2)
* 平均情况：T(n) = O(nlogn)
* 空间复杂度 O(log n)
* 不稳定
* @param array
* @param start
* @param end
*/
public static void QuickSorts(int[] array, int start, int end) {
if (start < 0 || end >= array.length || start > end) return;
int smallIndex = partition(array, start, end);
if (smallIndex > start)
QuickSorts(array, start, smallIndex - 1);
if (smallIndex < end)
QuickSorts(array, smallIndex + 1, end);
}
/**
* 快速排序算法——partition
* @param array
* @param start
* @param end
* @return
*/
public static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1));
int smallIndex = start - 1;
swap(array, pivot, end);
for (int i = start; i <= end; i++)
if (array[i] <= array[end]) {
smallIndex++;
if (i > smallIndex)
swap(array, i, smallIndex);
}
return smallIndex;
}
/**
* 交换数组内两个元素
* @param array
* @param i
* @param j
*/
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
堆排序
- 演示
- 代码实现
//声明全局变量，用于记录数组array的长度；
static int len;
/**
* 堆排序算法
*
* @param array
* @return
*/
public static int[] HeapSort(int[] array) {
len = array.length;
if (len < 1) return array;
//1.构建一个最大堆
buildMaxHeap(array);
//2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
while (len > 0) {
swap(array, 0, len - 1);
len--;
adjustHeap(array, 0);
}
return array;
}
/**
* 建立最大堆
*
* @param array
*/
public static void buildMaxHeap(int[] array) {
//从最后一个非叶子节点开始向上构造最大堆
for (int i = (len/2 - 1); i >= 0; i--) {
adjustHeap(array, i);
}
}
/**
* 调整使之成为最大堆
*
* @param array
* @param i
*/
public static void adjustHeap(int[] array, int i) {
int maxIndex = i;
//如果有左子树，且左子树大于父节点，则将最大指针指向左子树
if (i * 2 < len && array[i * 2] > array[maxIndex])
maxIndex = i * 2;
//如果有右子树，且右子树大于父节点，则将最大指针指向右子树
if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])
maxIndex = i * 2 + 1;
//如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
if (maxIndex != i) {
swap(array, maxIndex, i);
adjustHeap(array, maxIndex);
}
}
计数排序
- 演示
- 代码实现
/**
* 计数排序
*最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n+k)
* @param array
* @return
*/
public static int[] Counting(int[] array) {
if (array.length == 0) return array;
int bias, min = array[0], max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max)
max = array[i];
if (array[i] < min)
min = array[i];
}
bias = -min;
int[] bucket = new int[max - min + 1];
Arrays.fill(bucket, 0);
for (int j : array) {
bucket[j + bias]++;
}
int index = 0, i = 0;
while (index < array.length) {
if (bucket[i] != 0) {
array[index] = i - bias;
bucket[i]--;
index++;
} else
i++;
}
return array;
}
桶排序
- 演示
- 代码实现
/**
* 桶排序
*
* @param array
* @param bucketSize
* @return
*/
public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) {
if (array == null || array.size() < 2)
return array;
int max = array.get(0), min = array.get(0);
// 找到最大值最小值
for (int i = 0; i < array.size(); i++) {
if (array.get(i) > max)
max = array.get(i);
if (array.get(i) < min)
min = array.get(i);
}
int bucketCount = (max - min) / bucketSize + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
ArrayList<Integer> resultArr = new ArrayList<>();
for (int i = 0; i < bucketCount; i++) {
bucketArr.add(new ArrayList<Integer>());
}
for (int i = 0; i < array.size(); i++) {
bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
}
for (int i = 0; i < bucketCount; i++) {
if (bucketSize == 1) {
for (int j = 0; j < bucketArr.get(i).size(); j++)
resultArr.add(bucketArr.get(i).get(j));
} else {
if (bucketCount == 1)
bucketSize--;
ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
for (int j = 0; j < temp.size(); j++)
resultArr.add(temp.get(j));
}
}
return resultArr;
}
基数排序
- 演示
- 代码实现
/**
* 基数排序
* @param array
* @return
*/
public static int[] RadixSorts(int[] array) {
if (array == null || array.length < 2)
return array;
// 1.先算出最大数的位数；
int max = array[0];
for (int i = 1; i < array.length; i++) {
max = Math.max(max, array[i]);
}
int maxDigit = 0;
while (max != 0) {
max /= 10;
maxDigit++;
}
int mod = 10, div = 1;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < 10; i++)
bucketList.add(new ArrayList
最低0.47元/天 解锁文章
266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
