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

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

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

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

【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 <a.length ;j++){
                if(greater(a[minIndex],a[j])){
                    minIndex = j;
                }
            }
            // 交换最小元素所在索引minIndex处的值和索引i处的值
            exch(a,minIndex, i);
        }
    }
    //比较
    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;
    }
}

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;
    }

    /*对数组a中的元素进行排序*/
    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);
    }

    /*对数组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) : 对数组内的元素进行排序<br />
//        2. private static void sort(Comparable[] a,int lo,int hi) : 对数组a中从索引lo到索引hi之间的元素进行排序<br />
//        3. public static boolean less(Comparable v,Comparable w): 判断v是否小于w<br />
//        4. private static int partition(Comparable []a,int lo,int hi): 对数组a中,从索引lo到索引hi之间的元素进行分组,并返回分组界限对应的索引<br />
//        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));

    }
    /*
    * 比较v元素是否小于w元素
    * */
    private static boolean less(Comparable v, Comparable w){
        return v.compareTo(w) < 0;
    }
    /*
    数组元素i和j交换位置
    */
    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的算法和数据结构人少啊!
  • 算法和数据结构是一种思路,语言也不只会学一门,对吧,哈哈哈哈。
  • 也欢迎准备前端就业的小哥哥和小姐姐私信交流一起学习,欢迎分享更好的学习方式呀!

请添加图片描述

要点赞+关注+收藏呦👉




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

  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值