剑指Offer--排序算法小结_剑指offer排序

关注

原创最新推荐文章于 2026-08-23 11:54:52 发布 89 阅读 AI 写同款· GEO 优化 ›

LeetCode和剑指offer题目大合集 AlgorithmCode 本仓库收集一些算法的答案，目标是整理一套系统的算法参考答案以供其他学习者参考,我也在慢慢的学算法并且在坚持刷题，我会不定期的上传新的题目，希望大家共同努力！ https://github.com/zfman/AlgorithmCode 在线编程网站： LeetCode 牛客网-剑指offer 目录 排序算法 LeetCode 剑指offer ... 阅读详情

构建最大堆

介绍

利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。

操作过程如下：

1)初始化堆：将R[0…n-1]构造为堆；

2)将当前无序区的堆顶元素R[0]同该区间的最后一个记录交换，然后将新的无序区调整为新的堆。

因此对于堆排序，最重要的两个操作就是构造初始堆和调整堆，其实构造初始堆事实上也是调整堆的过程，只不过构造初始堆是对所有的非叶节点都进行调整。

注意使用最小堆排序后是递减数组，要得到递增数组，可以使用最大堆。

举例

public class HeapSortTest {  
  
    public static void main(String[] args) {  
        int[] data5 = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  
        print(data5);  
        heapSort(data5);  
        System.out.println("排序后的数组：");  
        print(data5);  
    }  
  
    public static void swap(int[] data, int i, int j) {  
        if (i == j) {  
            return;  
        }  
        data[i] = data[i] + data[j];  
        data[j] = data[i] - data[j];  
        data[i] = data[i] - data[j];  
    }  
  
    public static void heapSort(int[] data) {  
        for (int i = 0; i < data.length; i++) {  
            createMaxdHeap(data, data.length - 1 - i);  
            swap(data, 0, data.length - 1 - i);  
            print(data);  
        }  
    }  
  
    public static void createMaxdHeap(int[] data, int lastIndex) {  
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {  
            // 保存当前正在判断的节点  
            int k = i;  
            // 若当前节点的子节点存在  
            while (2 * k + 1 <= lastIndex) {  
                // biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点  
                int biggerIndex = 2 * k + 1;  
                if (biggerIndex < lastIndex) {  
                    // 若右子节点存在，否则此时biggerIndex应该等于 lastIndex  
                    if (data[biggerIndex] < data[biggerIndex + 1]) {  
                        // 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值  
                        biggerIndex++;  
                    }  
                }  
                if (data[k] < data[biggerIndex]) {  
                    // 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k  
                    swap(data, k, biggerIndex);  
                    k = biggerIndex;  
                } else {  
                    break;  
                }  
            }  
        }  
    }  
  
    public static void print(int[] data) {  
        for (int i = 0; i < data.length; i++) {  
            System.out.print(data[i] + "\t");  
        }  
        System.out.println();  
    }  
  
}

时间复杂度

O(nlogn)

空间复杂度

O(1)

稳定性

不稳定

所属类别

简单选择排序的增强版，同属选择排序。

冒泡排序

介绍

临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束。

例子为从小到大排序,原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

举例

package cn.edu.ujn.sort;
public class bubbleSort {
public static void main(String[] args) {
        int[] a = { 6, 2, 4, 1, 5, 9 };
        int n = a.length;
        
    for(int i = 0; i < n; i++)
    	System.out.print(a[i] + "  ");
    
        bubble_sort(a,n);
        
        System.out.println("");
    for(int i = 0; i < n ;i++)
    	System.out.print(a[i] + "  ");
}
static void bubble_sort(int[] unsorted, int n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = i; j < n; j++)
            {
                if (unsorted[i] > unsorted[j])
                {
                    int temp = unsorted[i];
                    unsorted[i] = unsorted[j];
                    unsorted[j] = temp;
                }
            }
        }
    }
}

结果如下:

时间复杂度

最坏情况O(N2),平均O(N2)。

空间复杂度

O(1)

插入排序

介绍

插入排序非常类似于整扑克牌。

在开始摸牌时，左手是空的，牌面朝下放在桌上。接着，一次从桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。为了找到这张牌的正确位置，要将它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。

如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函数。如果输入数组是逆序排列的，将出现最坏情况。平均情况与最坏情况一样，其时间代价是O(n2)。

也许你没有意识到，但其实你的思考过程是这样的：现在抓到一张7，把它和手里的牌从右到左依次比较，7比10小，应该再往左插，7比5大，好，就插这里。为什么比较了10和5就可以确定7的位置？为什么不用再比较左边的4和2呢？因为这里有一个重要的前提：手里的牌已经是排好序的。现在我插了7之后，手里的牌仍然是排好序的，下次再抓到的牌还可以用这个方法插入。编程对一个数组进行插入排序也是同样道理，但和插入扑克牌有一点不同，不可能在两个相邻的存储单元之间再插入一个单元，因此要将插入点之后的数据依次往后移动一个单元。

与选择排序不同的是，插入排序将数据向右滑动，并且不会执行交换。

稳定

最差情况：反序，需要移动n*(n-1)/2个元素

最好情况：正序，不需要移动元素

数组在已排序或者是“近似排序”时，插入排序效率的最好情况运行时间为O(n)；

插入排序最坏情况运行时间和平均情况运行时间都为O(n2)。

通常，插入排序呈现出二次排序算法中的最佳性能。

对于具有较少元素（如n<=15）的列表来说，二次算法十分有效。

在列表已被排序时，插入排序是线性算法O(n)。

在列表“近似排序”时，插入排序仍然是线性算法。

在列表的许多元素已位于正确的位置上时，就会出现“近似排序”的条件。

通过使用O(nlog2n)效率的算法（如快速排序）对数组进行部分排序，

然后再进行选择排序，某些高级的排序算法就是这样实现的。

举例

public static void InsertSort(int[] arr)
{
    int i, j;
    int n = arr.Length;
    int target;
    // 假定第一个元素被放到了正确的位置上
    // 这样，仅需遍历1 - (n-1)
    for (i = 1; i < n; i++)
    {
        j = i;
        target = arr[i];
        while (j > 0 && target < arr[j - 1])
        {
            arr[j] = arr[j - 1];
            j--;
        }
        arr[j] = target;
    }
}

时间复杂度

O(n2)

空间复杂度

O(1)

选择排序

介绍

选择排序的思想非常直接，不是要排序么？那好，我就从所有序列中先找到最小的，然后放到第一个位置。之后再看剩余元素中最小的，放到第二个位置……以此类推，就可以完成整个的排序工作了。可以很清楚的发现，选择排序是固定位置，找元素。相比于插入排序的固定元素找位置，是两种思维方式。不过条条大路通罗马，两者的目的是一样的。

举例

public static void selectSort(int[] arr)
{
int index, tmp, i, j, min;
int len = arr.length;
for(i = 0; i < len; i++){
index = i;
min = arr[i];
for(j = i + 1; j < len; j++){
if(min > arr[j]){
min = arr[j];
index = j;
}
}
tmp = arr[i];
arr[i] = min;
arr[index] = tmp;
}
}

时间复杂度

O(n2)

从选择排序的思想或者是上面的代码中，我们都不难看出，寻找最小的元素需要一个循环的过程，而排序又是需要一个循环的过程。因此显而易见，这个算法的时间复杂度也是O(n*n)的。这就意味值在n比较小的情况下，算法可以保证一定的速度，当n足够大时，算法的效率会降低。并且随着n的增大，算法的时间增长很快。因此使用时需要特别注意。