每日一题之排序算法

矫情吗；* 2021-09-02 03:22 417阅读 0赞

点击上方 [Java后端][Java]，选择 设为星标

优质文章，及时送达

--------------------

###  ###

### 排序算法 ###

1.  冒泡排序
2.  选择排序：选择排序与冒泡排序有点像，只不过选择排序每次都是在确定了最小数的下标之后再进行交换，大大减少了交换的次数
3.  插入排序：将一个记录插入到已排序的有序表中，从而得到一个新的，记录数增1的有序表
4.  快速排序：通过一趟排序将序列分成左右两部分，其中左半部分的的值均比右半部分的值小，然后再分别对左右部分的记录进行排序，直到整个序列有序。

int partition(int a[], int low, int high){
        int key = a[low];
        while( low < high ){
            while(low < high && a[high] >= key) high--;
            a[low] = a[high];
            while(low < high && a[low] <= key) low++;
            a[high] = a[low];
        }
        a[low] = key;
        return low;
    }
    void quick_sort(int a[], int low, int high){
        if(low >= high) return;
        int keypos = partition(a, low, high);
        quick_sort(a, low, keypos-1);
        quick_sort(a, keypos+1, high);
    }

1.  堆排序：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

public class Test {
    
        public void sort(int[] arr) {
            for (int i = arr.length / 2 - 1; i >= 0; i--) {
                adjustHeap(arr, i, arr.length);
            }
            for (int j = arr.length - 1; j > 0; j--) {
                swap(arr, 0, j);
                adjustHeap(arr, 0, j);
            }
    
        }
    
        public void adjustHeap(int[] arr, int i, int length) {
            int temp = arr[i];
            for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
                if (k + 1 < length && arr[k] < arr[k + 1]) {
                    k++;
                }
                if (arr[k] > temp) {
                    arr[i] = arr[k];
                    i = k;
                } else {
                    break;
                }
            }
            arr[i] = temp;
        }
    
        public void swap(int[] arr, int a, int b) {
            int temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }
    
        public static void main(String[] args) {
            int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};
            new Test().sort(arr);
            System.out.println(Arrays.toString(arr));
        }
    }

1.  希尔排序：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时再对全体记录进行一次直接插入排序。
2.  归并排序：把有序表划分成元素个数尽量相等的两半，把两半元素分别排序，两个有序表合并成一个

**- END -**

最近整理一份面试资料《Java技术栈学习手册》，覆盖了Java技术、面试题精选、Spring全家桶、Nginx、SSM、微服务、数据库、数据结构、架构等等。
    获取方式：点“ 在看，关注公众号 Java后端 并回复 777 领取，更多内容陆续奉上。
    推荐阅读 
    1. 每日一题之 ZooKeeper
    2. 每日一题之 Redis
    3. 每日一题之 MySQL
    
    4. 每日一题之 JVM-01
    
    5. 每日一题之 JVM-02
    ‍
    
    
    6‍
    .
     每日一题之 JVM-03
    
    
    7. 
    每日一题之线程
    
    
    8.
     每日一题之 HashMap
    
    9. 每日一题之 HashMap - 02
    
    10. 每日一题之 ThreadLocal
    
    
    11.
     每日一题之 Spring
    12. 每日一题之 计算机网络
    13. 每日一题之 Dubbo
    14. 每日一题之 Kafka
    
    
    15. 每日一题之 高并发系统
    
    
    
    喜欢文章，点个在看

[Java]: http://mp.weixin.qq.com/s?__biz=Mzg2MjEwMjI1Mg%3D%3D&chksm=ce0da17bf97a286df119047a25b7de51621fe542816673bb4aa3ebd8ab97b09a86ed7db2e2ee&idx=3&mid=2247489272&scene=21&sn=ce74938072fc73a808d83ccb474db46d#wechat_redirect