【Java数据结构实现一】-- 排序 -- 冒泡+选择+插入+希尔+归并+快速

参考视频：【黑马程序员】2020最新数据结构与算法教程（求职面试必备）
参考leetcode学习资料：图解算法数据结构

注意目录结构呦！！！按本文目录在src文件夹下创建项目和文件，直接粘代码即可运行

文章目录

算法和数据结构简述+排序的笔记
Mywrite
- sort
- - - Bubble(冒泡）
    - Selection（选择）
    - Insertion（插入）
    - Shell（希尔）
    - Merge（归并）
    - Quick（快速）

算法和数据结构简述+排序的笔记

【Java数据结构笔记一】-- 数据结构与算法概述–【时间复杂度+空间复杂度】
【Java数据结构笔记二】-- 排序 --冒泡+选择+插入+希尔+归并+快速

Mywrite sort Bubble(冒泡）

这是冒泡排序

package Mywrite.sort;

import java.util.Arrays;

public class Bubble {
    // 测试代码
    public static void main(String[] args) {
        Integer[] arr = {4,5,7,2345,6,83};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }


//    排序
    public static void sort(Comparable[] a){
        for(int i = a.length -1; i>0; i--){
            for(int j = 0; j < i; j++){
                // 比较索引i和索引j+1处的值
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }

//    比大小
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
//    交换
    private static void exch(Comparable[] a, int i ,int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

Selection（选择）

选择排序

package Mywrite.sort;

import java.util.Arrays;

public class Selection {
    // 测试
    public static void main(String[] args) {
        //原始数据
        Integer[] a = {34,5325,567,2546,252465,563};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    
    // 排序
    public static void sort(Comparable[] a){
        for(int i = 0; i < a.length-1 ; i++){
            int minIndex = i;
            for(int j = i+1; j 0;
    }
    //交换
    private static void exch(Comparable[] a, int i, int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

Insertion（插入）

package Mywrite.sort;

import java.util.Arrays;

public class Insertion {
    public static void main(String[] args) {
        Integer[] a = {2,35,63,76,265,7474,24,345,456};
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    
    //    排序
    public static void sort(Comparable[] a){
        for(int i=1;i< a.length; i++){
            for(int j = i; j>=0; j--){
                // 比较索引j处的值和索引j-1处的值；如果索引j-1处的值大于j处的值，需要交换j及j-1
//                处的值
                if(greater(a[j-1], a[j])){
                   exch(a,j,j-1);
                }else{
                    break;
                }
            }
        }
    }

    //    比大小
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    //    交换
    private static void exch(Comparable[] a, int i ,int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

Shell（希尔）

package Mywrite.sort;

import java.util.Arrays;

public class Shell {
    public static void main(String[] args) {
        Integer[] a = {3,4,5,8,9,0,76,6,5,4,2};
        sort(a);
        System.out.println(Arrays.toString(a));

    }
    //    排序
    public  static void sort(Comparable[] a) {
        // 1. 根据数组a的长度，确定增长量h的初始值
        int h = 1;
        while (h < a.length / 2) {
            h = 2 * h + 1;
        }
            // 2.希尔排序
            while (h >= 1) {
                // 排序
                //2. 1 找到待插入的元素
                for (int i = h; i < a.length; i++) {
                    System.out.println(i);
                    //2.2 把待插入的元素插入到有序数列中
                    for (int j = i; j >= h; j -= h) {
                        // 待插入的元素时a[j],比较a[j]和a[j-h]
                        if (greater(a[j - h], a[j])) {
                            // 交换元素
                            exch(a, j - h, j);
                        } else {
                            // 待插入元素已经找到了合适得到位置。结束循环
                            break;
                        }
                    }
                }
                // 减小h的值
                h = h / 2;
            }
        }
    //    比大小
    private static boolean greater(Comparable v, Comparable w){
        return v.compareTo(w) > 0;
    }
    //    交换
    private static void exch(Comparable[] a, int i ,int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

Merge（归并）

package Mywrite.sort;

import java.util.Arrays;

public class Merge {
    public static void main(String[] args) {
        Integer[] a = {8,4,5,7,1,3,6,2};
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    // 定义一个辅助数组
    private static Comparable[] assist;

    //    比大小
    private static boolean less(Comparable v, Comparable w){
        return v.compareTo(w) < 0;
    }
    //    交换
    private static void exch(Comparable[] a, int i ,int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    
    public static void sort(Comparable[] a){
        //1. 初始化数组assist
        assist = new Comparable[a.length];
        //2.定义一个lo变量，和hi变量，分别记录数组中最小的索引和最大的索引
        int lo = 0;
        int hi = a.length - 1;
        //3. 调用sort重载方法完成数组a中 从索引lo到索引hi、的元素的排序
        sort(a,lo,hi);
    }

    
    private  static void sort(Comparable[] a, int lo, int hi){
        // 做安全性校验
        if(hi<=lo){
            return;
        }

        // 对lo到hi之间的数据分为两个组‘
        int mid = lo+(hi - lo)/2;        // 5,9  mid=7

        // 分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);

        // 再把两个组中的数据进行记录
        merge(a,lo,mid,hi);
    }

//    对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
    private static void merge(Comparable[] a, int lo, int mid, int hi){
        // 定义三个指针,分别指向开始数组的索引处和左右子组的开始索引处
        int i = lo;
        int p1 = lo;
        int p2 = mid + 1;

        // 遍历，移动p1指针和p2指针，比较对应索引处的值，找出小的那个，放到辅助数组的对应索引处
        while(p1<=mid && p2<=hi){
            // 比较对应索引出的值
            if(less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else{
                assist[i++] = a[p2++];
            }
        }
        // 遍历，如果p1的指针没有走完，那么程序移动p1指针，把对饮的元素放到辅助数组的对应索引处
        while(p1 <= mid){
            assist[i++] = a[p1++];
        }
        //遍历，如果p2的指针没有走完，那么程序移动p2指针，把对应的元素放到辅助数组的对应索引处
        while(p2<=hi){
            assist[i++] = a[p2++];
        }
        // 把辅助数组中的元素拷贝到原数组中
        for(int index=lo;index <= hi; index++){
            a[index] = assist[index];
        }
    }
}

Quick（快速）

快速排序

package Mywrite.sort;

//#####  快速排序API设计

//        1. | 类名     | Quick                                                        |
//        | 构造方法 | Quick{}：创建Quick对象                                       |
//        | 成员方法 | 1. public static void sort(Comparable[] a) : 对数组内的元素进行排序

//        2. private static void sort(Comparable[] a,int lo,int hi) : 对数组a中从索引lo到索引hi之间的元素进行排序

//        3. public static boolean less(Comparable v,Comparable w): 判断v是否小于w

//        4. private static int partition(Comparable []a,int lo,int hi): 对数组a中，从索引lo到索引hi之间的元素进行分组，并返回分组界限对应的索引

//        5. private static void exch(Comparable[] a,int i,int j): 交换a数组中，索引i和索引j处的值 |


import java.util.Arrays;

public class Quick {
    public static void main(String[] args) {
        Integer[] a = {6,3,5,2,1,5,7,8,3,5};
        sort(a);
        System.out.println(Arrays.toString(a));

    }
    
    private static boolean less(Comparable v, Comparable w){
        return v.compareTo(w) < 0;
    }
    
    private static void exch(Comparable[] a, int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    // 对数组内的元素进行排序
    public static void sort(Comparable[] a) {
        int lo = 0;
        int hi = a.length - 1;
        sort(a,lo,hi);
    }

    // 对数组a中从索引lo到索引hi之间的元素进行排序
    private static void sort(Comparable[] a, int lo, int hi){
        // 安全性校验
        if(hi<=lo){
            return;
        }
        // 需要对数组中lo索引到hi索引处的元素进行分组（左子树和右子树）：
        int partition = partition(a, lo, hi);  // 返回的是分组的分界值所在的索引，分界值位置变换后的索引

        // 让左子组有序
        sort(a, lo, partition-1);
        // 让右子组有序
        sort(a, partition+1, hi);


    }

    // 切分
    //对数组a中，从索引lo到索引hi之间的元素进行分组，并返回分组界限对应的索引
    public static int partition(Comparable[] a, int lo, int hi){
        // 确定分界值
        Comparable key = a[lo];
        // 定义两个指针，分别指向带切分元素的最小索引处和最大索引处的下一个位置
        int left = lo;
        int right = hi+1;

        // 切分
        while(true){
            // 先从右往左扫描，移动right指针，找到一个比分界值大的元素，停止
            while(less(key,a[--right])){
                 if(right==lo){
                     break;
                 }
            }

            // 再从左往右扫描。移动left指针，找到一个比分界值大的元素，停止
            while(less(a[++left],key)){
                if(left == hi){
                    break;
                }
            }
            // 判断left>=right,如果是，则证明元素扫描完毕，结束循环，如果不是,则交换元素
            if(left>=right){
                break;
            }else{
                exch(a,left,right);
            }
        }
        //交换分界值
        exch(a,lo,right);

        return right;
    }

}

记录：刚开始n个月的数据结构与算法学习（java语言）

从不断看视频，不停地跟着视频敲代码，反反复复地理解，到现在:看着之前的练习代码疯狂试探盲敲
思路+不断练习才是学好东西的王道
看视频学习仅是复刻，回归书本是王道!!!刷题更是王道！！！！！

前端就业？话说我为什么不学JS的数据结构呢？

没有好的教学资源（我没有思路的时候，刚开始看不懂书，理解能力太差）
而且开学刷过一段时间JS的数据结构，纯背代码是有的，学不到思路也是真的，关键学JS的算法和数据结构人少啊！
算法和数据结构是一种思路，语言也不只会学一门，对吧，哈哈哈哈。
也欢迎准备前端就业的小哥哥和小姐姐私信交流一起学习，欢迎分享更好的学习方式呀！

要点赞＋关注+收藏呦

笔记在博主本人的博客上也有奥！全套！！！

翼遥bingo【持续完善中，biu~~】

【Java数据结构实现一】-- 排序 -- 冒泡+选择+插入+希尔+归并+快速

Java相关栏目本月热门文章