大家好！我是未来村村长，就是那个“请你跟我这样做，我就跟你这样做！”的村长????????！
||To bottom||
【To Up】系列文章重在java入门，但是【To Bottom】系列文章则重在面向基础，面向底层。只有深入底层才能得到技术和框架理解的进阶，才能深化自己的技术能力。该系列主要是“基础更基础，入门更上层”，即更基础的知识，更全面的框架运用。
所谓“心中有丘壑，眉间显山河”，大致就是这个道理。
文章目录
- 2、插入排序
- 3、希尔排序
- 4、归并排序
- 5、基数排序
- 6、堆排序
- 7、冒泡排序
- 8、选择排序
1、快速排序
一句话描述：快速排序采用的是分治的思想，不断递归【设定一个基准位，将该数组分成两份】，实现数组的排序。
（1）属性定义
public static void sort(int[] arr,int low,int high){
//一、属性定义
int i,j;//1、左右扫描指针
if(low>high) return;//2、当low与high大小相等时结束递归
i = low;//3、i从左开始扫描
j = high;//4、j从右开始扫描
int temp = arr[low];//5、基准位
- i，j：从右或右开始扫描的指针
- low，high：分别代表数组首尾元素
- temp：基准位，以该位数据为标准切分子数组，一般为low位
（2）排序实现
//二、排序实现【升序】
while (i<j){
//1、i，j分别从两边开始扫描
while (arr[j]>=temp && j>i) j--;
while (arr[i]<=temp && j>i) i++;
//2、j停下来的数小于基准位，i则大于基准位
//3、将i和j的数字进行交换
if(j>i){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
//4、归位：ij相遇的位置就是基准位的位置
arr[low] = arr[i];
arr[i] = temp;
① i，j从左右开始扫描，当j遇到比基准位小的数，停止扫描，j位置的数据是需要放到基准位左边的数据。
② 当i遇到比基准位小的数，停止扫描。这个时候，i和j正好冲突，将i和j的元素互换
③ 继续扫描，重复以上步骤
④ 最后ij相遇，所有while循环不满足条件而停止，此时i和j的位置就是基准位，我们将该位置的数据与基准位置数据互换即可【为什么ij所在位置的元素小于基准位置？因为j先到达该位置，则一定会停下来与i互换，所以i会先到达该位置，等待j的到来】
（3）递归执行
//三、递归执行
sort(arr,low,j-1);
sort(arr,j+1,high);
第一次已经将该数组分成两份了，然后在从基准位左右两边分别进行此排序操作，最终会使每一个子数组实现排序。
（4）算法效率分析
public class QuickSort {
public static void sort(int[] arr,int low,int high){
//一、属性定义
int i,j;//1、左右扫描指针
if(low>high) return;//2、当low与high大小相等时结束递归
i = low;//3、i从左开始扫描
j = high;//4、j从右开始扫描
int temp = arr[low];//5、基准位
//二、排序实现【升序】
while (i<j){
//1、i，j分别从两边开始扫描
while (arr[j]>=temp && j>i) j--;
while (arr[i]<=temp && j>i) i++;
//2、j停下来的数小于基准位，i则大于基准位
//3、将i和j的数字进行交换
if(j>i){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
//4、归位：ij相遇的位置就是基准位的位置
arr[low] = arr[i];
arr[i] = temp;
//三、递归执行
sort(arr,low,j-1);
sort(arr,j+1,high);
}
}
时间复杂度：
- 平均情况：O(nlog2n)
- 最好：O(nlog2n)
- 最坏：O(n2)
- 稳定情况：不稳定
空间复杂度：
- O(nlog2n)
2、插入排序
一句话描述：从头开始逐步遍历，默认i前面的数据已经有序，将i的元素插入到前面的有序数组中。
（1）属性定义
public static void sort(int arr[]){
//一、属性
int iv;//定义待插入的数
int ivPreIndex;//定义待插入数的前一个下标
- iv：待插入数据，默认i前面的数据已经有序，iv是待插入的数据
- ivPreIndex：用ivPreIndex作为遍历i前面数据的指针
（2）排序实现
//二、排序
for(int i = 0;i<arr.length;i++){
iv = arr[i];//1、从头开始，默认i之前的数已经排好序
ivPreIndex = i-1;//2、取到i前一位下标,从这里开始与待插入数比较
//3、将iv与i前面的数逐一比较，找到待插入位置
while (ivPreIndex>=0 && arr[ivPreIndex]>iv){
//3.1、每找到一次对应位置，该位置的数后移，直到i前数组有序
arr[ivPreIndex+1] = arr[ivPreIndex];
//3.2、下标更新
ivPreIndex--;
}
//4、最终ivPreIndex+1的位置就是待插入的位置
arr[ivPreIndex+1] = iv;
}
① 从头开始，默认第一个数有序，从第二个数开始插入
② 每次插入i位置的元素，是将i逐步与i前面的元素进行比较
③ 如果遇到比i大的数，该数就向后移动一位，直到遇到比i小的数，或者ivPreIndex指向头元素
④ 最后将空出来的值，赋值待插入元素
（3）算法效率分析
public class InsertionSort {
public static void sort(int arr[]){
//一、属性
int iv;//定义待插入的数
int ivPreIndex;//定义待插入数的前一个下标
//二、排序
for(int i = 0;i<arr.length;i++){
iv = arr[i];//1、从头开始，默认i之前的数已经排好序
ivPreIndex = i-1;//2、取到i前一位下标,从这里开始与带插入数比较
//3、将iv与i前面的数逐一比较，找到待插入位置
while (ivPreIndex>=0 && arr[ivPreIndex]>iv){
//3.1、每找到一次对应位置，该位置的数后移，直到i前数组有序
arr[ivPreIndex+1] = arr[ivPreIndex];
//3.2、下标更新
ivPreIndex--;
}
//4、最终ivPreIndex+1的位置就是待插入的位置
arr[ivPreIndex+1] = iv;
}
}
}
时间复杂度：
- 平均情况：O(n2）
- 最好：O(n)
- 最坏：O(n2)
- 稳定情况：稳定
空间复杂度：
- O(1)
3、希尔排序
一句话描述：规定一个间距，让间距相同的元素为一个子数组，在组内进行排序操作，不断缩小间距，重复组内排序。
（1）属性定义
public static void sort(int arr[]){
//一、属性
int gap;//规定间距以切分子表
- gap：gap就是我们的分组依据，每次比较结束后缩小其值，进行重新分组和排序
（2）排序实现
//二、排序
//1、gap初始值为二分之一数组长度，逐步缩小分组间距
for(gap = arr.length/2;gap>0;gap = gap/2){
//2、将整个数组切分为若干个子数组【以gap为间距】
for(int i = gap;i<arr.length;i++){
//3、遍历各组元素，进行组内排序
for (int j = i-gap; j>=0 ; j=j-gap) {
if(arr[j]>arr[i]){
int temp=arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}
① gap取数组长度，每次进行分组操作前都缩小为一半【也可以缩小其它倍数】
② 根据gap大小，将间距为gap的元素划分为一个子数组
③ 在子数组内进行插入排序
（3）算法效率分析
public class ShellSort {
public static void sort(int arr[]){
//一、属性
int gap;//规定间距以切分子表
//二、排序
//1、gap初始值为二分之一数组长度，逐步缩小分组间距
for(gap = arr.length/2;gap>0;gap = gap/2){
//2、将整个数组切分为若干个子数组【以gap为间距】
for(int i = gap;i<arr.length;i++){
//3、遍历各组元素，进行组内排序
for (int j = i-gap; j>=0 ; j=j-gap) {
if(arr[j]>arr[j+gap]){
int temp=arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}
}
}
时间复杂度：
- 平均情况：O(n1.3）
- 最好：O(n)
- 最坏：O(n2)
- 稳定情况：不稳定
空间复杂度：
- O(1)
4、归并排序
一句话描述：利用递归的方式，将数组不断从中间分成子数组，然后进行合并，合并的顺序总是左半部分数据大于右半部分数据。
（1）合并算法
private static void merge(int[] arr,int left,int right,int mid,int[] temp){
//一、属性
int i = left;//左边有序序列的初始索引
int j = mid+1;//右边有序序列的初始索引
int t = 0;//temp数组的当前索引
//二、合并：将左右两边的数据按规则填充到temp数组
//1、扫描数组arr，从开头和中间开始扫描
while (i<=mid && j<=right){
//1.1、将ij扫描到的数进行比较，较小值优先放置，直到有一边扫描完毕
if(arr[i]<=arr[j]){
temp[t] = arr[i];
t++;
i++;
}else {
temp[t] = arr[j];
t++;
j++;
}
}
//1.2、将剩余的数据依次添加到temp数组中
while (i<=mid){
temp[t] = arr[i];
t++;
i++;
}
while (j<=right){
temp[t] = arr[j];
t++;
j++;
}
//1.3、将temp复制到arr中
t=0;
int tempLeft = left;
while (tempLeft<=right){
arr[tempLeft] = temp[t];
t++;
tempLeft++;
}
}
① 每次都从开头和中间开始扫描，对i，j指针路过的元素进行比较，将较小值优先放入temp数组中
② 继续扫描比较，直到temp数组装载了一半
③ 将后续数据放入temp数组中
④ 如此temp数组前一半数据就小于后一半数据
（2）排序算法
public static void sort(int[] arr, int left, int right, int[] temp){
if (left<right) {
int mid = (left + right) / 2;
//向左递归进行分解
sort(arr, left, mid, temp);
//向右递归进行分解
sort(arr, mid + 1, right, temp);
//每分解一次便合并一次
merge(arr, left, right, mid, temp);
}
}
① 向左递归分解
② 向右递归分解
③ 逐步合并
（3）算法效率分析
public class MergeSort {
public static void sort(int[] arr, int left, int right, int[] temp){
if (left<right) {
int mid = (left + right) / 2;
//向左递归进行分解
sort(arr, left, mid, temp);
//向右递归进行分解
sort(arr, mid + 1, right, temp);
//每分解一次便合并一次
merge(arr, left, right, mid, temp);
}
}
private static void merge(int[] arr,int left,int right,int mid,int[] temp){
//一、属性
int i = left;//左边有序序列的初始索引
int j = mid+1;//右边有序序列的初始索引
int t = 0;//temp数组的当前索引
//将左右两边的数据按规则填充到temp数组
while (i<=mid && j<=right){
if(arr[i]<=arr[j]){
temp[t] = arr[i];
t++;
i++;
}else {
temp[t] = arr[j];
t++;
j++;
}
}
while (i<=mid){
temp[t] = arr[i];
t++;
i++;
}
while (j<=right){
temp[t] = arr[j];
t++;
j++;
}
t=0;
int tempLeft = left;
while (tempLeft<=right){
arr[tempLeft] = temp[t];
t++;
tempLeft++;
}
}
}
时间复杂度：
- 平均情况：O(nlog2n）
- 最好：O(nlog2n)
- 最坏：O(nlog2n)
- 稳定情况：稳定
空间复杂度：
- O(n)
5、基数排序
一句话描述：定义一个桶用于装载数据【大小为10*arr.length】，取到数组的最大值的位数，从个位开始，按照各个位上的自然数进行桶的装载，然后依次取出，这样能保证每次取出都是按各个位上的自然数升序排序，取到最高位时，取出即排序完毕。
（1）属性
public static void sort(int[] arr){
//一、属性
//1、桶：用来装载元素
int[][] bucket = new int[10][arr.length];
//2、用来记录每个桶(0-9)装了几个数字
int[] Count = new int[10];
//3、数组的最大位数
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max){
max = arr[i];
}
}
int maxLength = (max + "").length();//获得最大值长度/决定循环次数
//4、取出来的数据
int digit；
- bucket：二维数组，10个桶用来装载数据，[10]代表每个位上可能出现的自然数，[arr.length]是装载容量
- Count：记录每个自然数桶装了几个数据
- maxLength：计算该数组中最大数的位数
- digit：自然数，代表各个位上的自然数
（2）装桶与取出
//二、装桶再取出
for(int k = 0;k<maxLength;k++){
//1、装载
for(int i = 0;i<arr.length;i++){
//1.1、取出各个位上的自然数，用于桶的定位
digit = (int)(arr[i]/Math.pow(10,k)%10);
//1.2、定位到桶之后，通过Count[digit]定位放置的位置
bucket[digit][Count[digit]]= arr[i];
//1.3、该自然数放置个数增加
Count[digit]++;
}
//2、取出
int index = 0;
//2.1、遍历Count，确定每个bucket有几个数
for(int j = 0;j<Count.length;j++){
if(Count[j]!=0){
//2.2、从0开始依次取出
for(int l = 0;l<Count[j];l++){
arr[index] = bucket[j][l];
index++;
}
}
Count[j] = 0;//每取出一个就将计数桶元素清零，以便下一个高位装载使用
}
}
① 从个位数开始装载，每次都要经历装载和取出的过程
② 装载：首先会取出arr数组中每一个数相应位上的自然数值，然后定位到相应的桶中，进行装载
③ 取出：从自然数值较小的数开始取出，这样取出的数一定是在该位上按从小到大开始取出
说明：这样第二次【十位】装载的时候，按十位上的自然数大小排序，当遇到十位相等时，因为我们是按照个位大小顺序进行装载，此时较小位数会先进入桶中，取出时也会先进行取出，这样即时遇到十位相等的情况，也是个位较小的数先取出，后续装载取出也是如此。
（3）算法效率分析
public class RaixSort {
public static void sort(int[] arr){
//一、属性
//1、桶：用来装载元素
int[][] bucket = new int[10][arr.length];
//2、用来记录每个桶(0-9)装了几个数字
int[] bucketElementCount = new int[10];
//3、数组的最大位数
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max){
max = arr[i];
}
}
int maxLength = (max + "").length();//获得最大值长度/决定循环次数
//二、装桶再取出
for(int k = 0;k<maxLength;k++){
//装载
for(int i = 0;i<arr.length;i++){
int digit = (int)(arr[i]/Math.pow(10,k)%10);
bucket[digit][Count[digit]]= arr[i];
Count[digit]++;
}
//取出
int index = 0;
for(int j = 0;j<bucketElementCount.length;j++){
if(bucketElementCount[j]!=0){
for(int l = 0;l<bucketElementCount[j];l++){
arr[index] = bucket[j][l];
index++;
}
}
bucketElementCount[j] = 0;//将计数桶元素清零
}
}
}
}
时间复杂度：O是数组大小，k是位数数量
- 平均情况：O(n*k）
- 最好：O(n*k)
- 最坏：O(n*k)
- 稳定情况：稳定
空间复杂度：
- O(n+k)
6、堆排序
一句话描述：利用堆的数据结构进行排序。
（1）数据结构：堆
堆是一棵顺序存储的完全二叉树，堆可分为大顶堆和小顶堆。
- 大顶堆：每个节点的关键字都大于其孩子节点的关键字，根节点是堆中最大节点【因为双亲节点总是大于孩子节点，所以从根节点出发，无论走那条路，得到的都是一个递减序列，可证明根节点为堆中最大节点】
- 小顶堆：每个节点的关键字都小于其孩子节点的关键字，根节点是堆中最小节点
ps：一棵大小为N的完全二叉树，高度为lgN
（2）下沉算法
private static void sink(int[] arr,int index,int length){
//index：代表进行下沉操纵的节点
//左子节点下标
int leftChild = 2*index + 1;
//右子节点下标
int rightChild = 2*index + 2;
//要调整的节点下标
int present = index;
//向左边下沉
if(leftChild<length && arr[leftChild]>arr[present]){
present = leftChild;
}
//向右边下沉
if(rightChild<length && arr[rightChild]>arr[present]){
present = rightChild;
}
//如果下标不相等，说明下标已经下沉
if(present!=index){
//则交换值达到值的下沉
int temp = arr[index];
arr[index] = arr[present];
arr[present] = temp;
//继续下沉
sink(arr,present,length);
}
}
① 下沉操作是针对某一个节点，找到其左右子节点，如果其左右子节点有比该节点大的，则进行位置互换。
② 这个时候该节点可能有又拥有了新的左右子节点，继续根据大顶堆的定义，检查其左右子节点是否大于该节点，如果是则继续下沉
（3）堆的建造
private static void buildHeap(int[] arr,int length){
//从length/2的位置开始向前遍历，因为length/2后的节点皆为孩子节点
for (int i = length/2; i>=0; i--) {
//对length/2之前的双亲节点逐个进行下沉操作
sink(arr,i,length);
}
}
① 对于一个给定数组，我们进行堆的建造，只需要检查每个一双亲节点是否符合：双亲节点大于孩子节点
② 如果不符合就进行下沉操作
（4）排序算法
public static void sort(int[] arr){
int length = arr.length;
//1、先进行堆的建造
buildHeap(arr,length);
//2、从末尾开始，将末尾元素与堆顶元素交换
for (int i = length-1; i >0 ; i--) {
//2.1、将堆顶元素与末位元素调换
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
//2.2、更新末尾值，隐藏完成交换的末尾元素
length--;
//2.3//、将堆顶元素下沉 目的是将最大的元素浮到堆顶来
sink(arr,0,length);
}
}
① 之前我们已经知道堆顶元素是堆中最大，所以我们只需要将堆顶元素与末尾元素进行调换，更新末尾元素下标，重新调整堆，就取出了最大值并且将其置于末尾
② 重复以上步骤，每次都只需要将堆顶元素与更新的末尾下标元素进行调换，然后对对顶元素进行下沉即可实现排序
（5）算法效率分析
public class HeapSort {
public static void sort(int[] arr){
int length = arr.length;
//1、先进行堆的建造
buildHeap(arr,length);
//2、从末尾开始，将末尾元素与堆顶元素交换
for (int i = length-1; i >0 ; i--) {
//2.1、将堆顶元素与末位元素调换
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
//2.2、更新末尾值，隐藏完成交换的末尾元素
length--;
//2.3//、将堆顶元素下沉 目的是将最大的元素浮到堆顶来
sink(arr,0,length);
}
}
private static void buildHeap(int[] arr,int length){
//从length/2的位置开始向前遍历，因为length/2后的节点皆为孩子节点
for (int i = length/2; i>=0; i--) {
//对length/2之前的双亲节点逐个进行下沉操作
sink(arr,i,length);
}
}
private static void sink(int[] arr,int index,int length){
//index：代表进行下沉操纵的节点
//左子节点下标
int leftChild = 2*index + 1;
//右子节点下标
int rightChild = 2*index + 2;
//要调整的节点下标
int present = index;
//向左边下沉
if(leftChild<length && arr[leftChild]>arr[present]){
present = leftChild;
}
//向右边下沉
if(rightChild<length && arr[rightChild]>arr[present]){
present = rightChild;
}
//如果下标不相等，说明下标已经下沉
if(present!=index){
//则交换值达到值的下沉
int temp = arr[index];
arr[index] = arr[present];
arr[present] = temp;
//继续下沉
sink(arr,present,length);
}
}
}
时间复杂度：O是数组大小，k是位数数量
- 平均情况：O(nlog2n）
- 最好：O(nlog2n)
- 最坏：O(nlog2n)
- 稳定情况：不稳定
空间复杂度：
- O(1)
7、冒泡排序
一句话描述：从头开始遍历，从第一位开始，每一位数与后一位元素两两比较，较大者向后移动，每一轮排序产生一个最大值。
（1）代码
代码自己看
public class BubbleSort {
public static void sort(int[] arr){
//记录比较次数
int count=0;
//i=0,第一轮比较
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;
}
count++;
}
}
}
}
（2）算法效率分析
时间复杂度：
- 平均情况：O(n2）
- 最好：O(n)
- 最坏：O(n2)
- 稳定情况：稳定
空间复杂度：
- O(1)
8、选择排序
一句话描述：每次找到数组中最小值放到第一个位置，然后默认依次找到后续的最小值，从第一位依次向后放置。
（1）代码
代码自己看
public class SelectionSort {
public static void sort(int arr[])
{
for (int i = 0; i < arr.length-1; i++) {
int index=i;//标记第一个为待比较的数
for (int j = i+1; j < arr.length; j++) { //然后从后面遍历与第一个数比较
if (arr[j]<arr[index]) { //如果小,就交换最小值
index=j;//保存最小元素的下标
}
}
//找到最小值后，将最小的值放到第一的位置，进行下一遍循环
int temp=arr[index];
arr[index]=arr[i];
arr[i]=temp;
}
}
}
（2）算法效率分析
时间复杂度：
- 平均情况：O(n2）
- 最好：O(n)
- 最坏：O(n2)
- 稳定情况：不稳定
空间复杂度：
- O(1)
——————————————————
作者：未来村村长
图片来源：简书-小吉头、以及百度图片【侵删】
个人网站：www.76pl.com
????????点个关注，在未来村不会迷路????????
——————————————————
