对于冒泡和选择排序算法的一些理解

排序算法的小想法

目前为止关于排序算法中的冒泡和选择，前前后后学了有四五遍了，从最开始的死记硬背到现在 好像渐渐有点理解了
本次，我基于Java,封装一个类，对实体类进行排序，两种排序都用一下

1. 先封装实体类

package sort;

public class Enerty {
    private String name;
    private double height;

    public Enerty() {
    }

    public Enerty(String name, double height) {
        this.name = name;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Enerty{" +
                "name='" + name + '\'' +
                ", height=" + height +
                '}';
    }
}

2. 写操作类**（主要是这里）**
   这里我说一下我对两种算法的理解

• 冒泡：它是对数组中数值的操作，他的目的是依次将第一个数与数组后面的数进行对比调换，所以我们主要的关注点应该放在数组中的数值上来，所以再嵌套第二层for循环的时候，要比和替换的是j与j+1的值
• 选择：它是对数组中索引（也就是位置的操作）的操作，他的目的是将数组的每一个位置的数值依次与其他位置的数进行对比，所以再第二层嵌套的for循环我们用if判断的是数组的位置i和其他位置的j的大小，所以我们主要的关注点应该放在数组中的索引（也就是位置）上来
  以下是代码

package sort;

import java.util.Arrays;

public class EnertyOperator extends Enerty{
    //冒泡：该算法的本质是动数组上的数值，依次将大的值往数组的最后一位排，第二后一位排...
    public static void maoPao(Enerty[] et){
        //要轮的轮数
        for (int i = 0; i < et.length-1; i++) {
            //每轮要比较的次数
            for (int j = 0; j < et.length-i-1; j++) {
                //判断大小,如果大就直接将较大的数字往后排
                if (et[j].getHeight()>et[j+1].getHeight()){
                    Enerty temp = et[j+1];
                    et[j+1] = et[j];
                    et[j] = temp;
                }
            }
        }
    }
    //选择:该算法本质是定位排序，降序排列
    public static void selectSort(Enerty[] et){
        //要伦的轮数,比如i=0为第一个定位的数组位置
        for (int i = 0; i < et.length - 1; i++) {
            //遍历数组的其他位置
            for (int j = i+1; j < et.length; j++) {
                //如果其他位置有比i的位置更大的数，就
                if (et[i].getHeight()<et[j].getHeight()){
                    //给选中的最小值的索引换位置
                    Enerty temp = et[j];
                    et[j] = et[i];
                    et[i] = temp;
                }
            }
        }
    }
}

3. 测试类

package sort;

public class Test {
    public static void main(String[] args) {
        Enerty[] et = {
                new Enerty("黄蓉",155),
                new Enerty("郭靖",188),
                new Enerty("乔峰",185),
                new Enerty("段誉",180),
                new Enerty("阿朱",170),
                new Enerty("钟灵",160)
        };

        System.out.println("按照身高排序前");
        for (Enerty enerty:et){
            System.out.println(enerty);
        }
        System.out.println("==========冒泡从低到高升序排序后==========");
        EnertyOperator.maoPao(et);
        for (Enerty enerty:et){
            System.out.println(enerty);
        }
        System.out.println("==========选择从高到低降序排序后==========");
        EnertyOperator.selectSort(et);
        for (Enerty enerty : et) {
            System.out.println(enerty);
        }

    }
}

4. 结果

按照身高排序前
Enerty{name='黄蓉', height=155.0}
Enerty{name='郭靖', height=188.0}
Enerty{name='乔峰', height=185.0}
Enerty{name='段誉', height=180.0}
Enerty{name='阿朱', height=170.0}
Enerty{name='钟灵', height=160.0}
==========冒泡从低到高升序排序后==========
Enerty{name='黄蓉', height=155.0}
Enerty{name='钟灵', height=160.0}
Enerty{name='阿朱', height=170.0}
Enerty{name='段誉', height=180.0}
Enerty{name='乔峰', height=185.0}
Enerty{name='郭靖', height=188.0}
==========选择从高到低降序排序后==========
Enerty{name='郭靖', height=188.0}
Enerty{name='乔峰', height=185.0}
Enerty{name='段誉', height=180.0}
Enerty{name='阿朱', height=170.0}
Enerty{name='钟灵', height=160.0}
Enerty{name='黄蓉', height=155.0}

5. 总结
   当然，我们可以说，直接用**Arrays.sort();**似乎更快，但是这两种经典的排序算法我仍认为锻炼我们的算法思维还是有帮助的，更何况面试中也会有这类题。