- 常见排序算法分类
- 常见排序算法性能比较：
排序 方法 | 平均情况 | 最好 情况 | 最坏 情况 | 空间复杂度 | 稳定性 |
冒泡 排序 | O(n²) | O(n) | O(n²) | O(1) | 稳定 |
选择 排序 | O(n²) | O(n²) | O(n²) | O(1) | 不稳定 |
插入 排序 | O(n²) | O(n) | O(n²) | O(1) | 稳定 |
希尔 排序 | O(nlogn) ~ O(n²) | O(n^1.3) | O(n²) | O(1) | 不稳定 |
堆排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(1) | 不稳定 |
归并 排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(n) | 稳定 |
快速 排序 | O(nlogn) | O(nlogn) | O(n²) | O(logn)~O(n) | 不稳定 |
- 排序算法的稳定性问题：
若arr[i] = arr[j]，排序前arr[i]在arr[j]之前，排序后arr[i]还在arr[j]之前，则称这种排序算法是稳定的。通俗地讲就是保证排序前后两个相等的数的相对顺序不变。
举例：冒泡排序是一个稳定的排序算法，但若将arr[j]>arr[j+1]换为arr[j]>=arr[j+1]，则两个相等的数就需要交换位置，从而变成不稳定的算法
1.冒泡排序
基本思想：
不断地进行两两比较相邻数据，如果前面的数据大于后面的就将它们交换，使得大的数往后面走，每次冒泡就会将一个大的数往后面冒，直到没有需要交换的数据为止。
- 代码如下：
public static void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){ //趟数
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}通过上述冒泡我们可以发现，当数组进行到第7趟时已经有序，但仍然进行了第8趟操作，尽管没有交换数据，但之后的大量比较有些多余。此时考虑 冒泡算法的优化：加入flag标记，确定是否已有序
- 优化版本：
public static void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
boolean flag=false;//优化标记
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
flag=true; //若发生数据交换，则flag置为true
}
}
if(flag==false){
//System.out.print("已有序");
return;
}
}
}分析知，当待排序数组本身有序，根据优化后的代码，可推断出进行n-1次比较，时间复杂度为O(n)，当待排序全部无序时，此时需要比较n(n-1)/2次，因此冒泡排序的时间复杂度为O(n²)
2.选择排序
基本思想：
待排序序列通过n-i次数据间的比较，从n-i+1个记录中选出最小值，和第i个数据交换。
- 代码如下：
public static void sort(int[] arr){
for(int i = 0; i<arr.length ; i++) {
int minIndex=i;
for(int j=i+1;j<arr.length;j++) { //j只是为找最小值下标
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}分析知：无论最好最差的情况，选择排序的比较次数是一样多的，其时间复杂度仍然为O(n²)，尽管选择排序与冒泡排序时间复杂度相同，但性能上还是略优于冒泡排序
3.插入排序
基本思想：
①从0号下标开始(默认此时已有序)
②取1号下标数据，从后往前进行比较 ，如果该数据大于下一个数据，将该元素后移；
③重复操作，直到找到已排序的元素小于或者等于该元素的位置，将新元素插入到该位置后
- 代码如下：
public static void char1(int[] arr) {
for(int i=0;i<arr.length-1;i++){
if(arr[i]>arr[i+1]){
int j=i+1;
int temp=arr[j];
while(i>=0&&temp<arr[i]){
arr[i+1]=arr[i];
i--;
}
arr[i+1]=temp;
}
}
}4.希尔排序
基本思想：
将相隔某个增量的数据组成一个子序列，实现跳跃式移动，从而提高排序效率
- 代码如下：
public static void shell(int[]arr){ //充当接口作用
int[] gaps = {5,3,1};
for(int i=0;i<gaps.length;i++){
shellSort(arr,gaps[i]);
}
}
public static void shellSort(int[] arr, int gap) {
for (int i = gap; i < arr.length; i++) {
int temp = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > temp) {
arr[j + gap] = arr[j];
j -= gap;
}
arr[j + gap] = temp;
}
}5.快速排序
基本思想：
对一个数组，标记初始值arr[0]为temp（基准）。
①用right下标从后向前找到比temp小的数据，将其放在left下标位置，此时right下标位置为空；
②用left从前向后找到比temp大的数据，将其放在right下标位置，此时left所指位置为空
③用temp填补left的空白位置 -> 此时right==left
当right或者left位左右数据个数<=2时，表示数组已正序
若left或right下标左右数据个数>=2，划分左右，重复操作：
- 代码如下：
public static void quickSort(int[] arr) { //充当接口作用
quickProcess(arr, 0, arr.length - 1);
}
private static void quickProcess(int[] arr, int left, int right) {
int index = partition(arr, left, right);
//划分左边
if (index - left >= 2) {
quickProcess(arr, left, index - 1);
}
//划分右边
if (right - index >= 2) {
quickProcess(arr, index + 1, right);
}
}
private static int partition(int[] arr, int left, int right) {
int temp = arr[left];
while (left < right) {
//从后往前找比基准小的数丢到left的位置
while (left < right && arr[right] >= temp) {
right--;
}
arr[left] = arr[right];
//从前向后找比基准大的数字丢到right的位置
while (left < right && arr[left] <= temp) {
left++;
}
arr[right] = arr[left];
}
arr[left] = temp;
return right;
}
