1.几种基本的代码实现
冒泡排序:
/**
* 冒泡排序
* @param arr 待排序数组
* @return
*/
public void BubbleSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - 1; j++) {
if (arr[j] > arr[j + 1]) {
int t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
}
快速排序:
/**
* 快速排序
* @param arr 待排数组
* @param start 下标
* @param end 上标
*/
public void QuickSort(int[] arr, int start, int end) {
if (start > end)
return;
//下标
int low = start;
//上标
int high = end;
//基准数
int temp = arr[start];
while (low < high) {
while (temp <= arr[high] && low < high)
high--;
while (temp >= arr[low] && low < high)
low++;
if (low < high) {
int t = arr[high];
arr[high] = arr[low];
arr[low] = t;
}
}
arr[start] = arr[low];
arr[low] = temp;
QuickSort(arr, start, high - 1);
QuickSort(arr, high + 1, end);
}
插入排序:
/**
* 插入排序
* @param arr 待排数组
*/
public void InsertSort(int[] arr) {
int len = arr.length;
if (arr.length <= 1)
return;
for (int i = 1; i < len; i++) {
int temp = arr[i];
for (int j = 0; j < i; j++) {
if (arr[j] > temp) {
int t = i;
while (t > j) {
arr[t] = arr[t - 1];
t--;
}
arr[j] = temp;
break;
}
}
}
}
选择排序:
/**
* 选择排序
* @param arr 待排数组
*/
public void SelectSort(int[] arr) {
int len = arr.length;
int minindex = 0;
for (int i = 0; i < len; i++) {
int min = 10000000;
for (int j = i; j < len; j++) {
if (arr[j] < min) {
min = arr[j];
minindex = j;
}
}
int temp = arr[i];
arr[i] = arr[minindex];
arr[minindex] = temp;
}
}
2.几种基本的排序算法比较
排序算法 | 时间复杂度 | 稳定性 | 特点 |
---|---|---|---|
冒泡排序 | O(n2) | 稳定 | 一般情况下,特别是在逆序时,它很不理想。它是对数据有序性非常敏感的排序算法。 |
插入排序 | O(n2) | 稳定 | 插入排序将要优于冒泡排序。直接插入法也是一种对数据的有序性非常敏感的一种算法。在有序情况下只需要经过n-1次比较,在最坏情况下,将需要n(n-1)/2次比较 |
选择排序 | O(n2) | 不稳定 | 对数据的有序性不敏感。它虽然比较次数多,但它的数据交换量却很少。所以我们将发现它在一般情况下将快于冒泡排序 |
快速排序 | O(nlogn) 平均时间, O(n2) 最坏情况 | 不稳定 | 在理论上讲,如果每次能均匀划分序列,它将是最快的排序算法, 因此称它作快速排序。虽然很难均匀划分序列,但就平均性能而言,它仍是基于关键字比较的内部排序算法中速度最快者。 |
堆排序 | O(nlogn) | 不稳定 | 一般在小规模的序列中不合适,但对于较大的序列,将表现出优越的性能 |
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。