java数据结构与算法（day2）--简单排序

模式：设计api实现api

简单排序

举例（商品排序）

1.1Comparable接口介绍(排序算法更有通用性：对象排序)

创建对象，并且生成豆子。创建Comparable接口

package cn.itcast.algorithm.sort;

public class Student implements Comparable<Student>{
    private String username;
    private int age;

    public Student() {
    }

    public Student(String username, int age) {
        this.username = username;
        this.age = age;
    }

    /**
     * 获取
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * 设置
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{username = " + username + ", age = " + age + "}";
    }

    public int compareTo(Student o){
        return this.getAge()-o.getAge();
    }
}

实例化对象，创建规则

package cn.itcast.algorithm.text;

import cn.itcast.algorithm.sort.Student;

public class TextComparable {
    public static void main(String[] args) {
//        创建对象，调用方法测试
        Student s1=new Student();
        s1.setUsername("李四");
        s1.setAge(18);

        Student s2=new Student();
        s2.setUsername("张三");
        s2.setAge(20);

        Comparable max = getMax(s1, s2);
        System.out.println(max);
    }

    public static Comparable getMax(Comparable c1,Comparable c2){
        int result=c1.compareTo(c2);
        //判断result的情况
        if (result>=0){
            return c1;
        }else {
            return c2;
        }
    }

}

 

1.2 冒泡排序

排序原理：

1）比较相邻的元素，如果前一个元素比后一个大，就交换两个元素的位置。

2）对每一对相邻元素做相同的工作，从第一位元素到结尾最后一位元素。最终最后位置的元素就是最大值。

为什么叫冒泡排序？

冒泡的过程把合适的元素放到合适的位置

 

冒泡排序aip设计：

构造方法：Bubble():创建bubble()对象

成员方法：

1对数组内的元素进行排序

2判断相邻元素大小

3交互元素位置

冒泡排序程序设计：

 

package cn.itcast.algorithm.sort;

public class Bubble {

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

    }

    private static boolean greater(Comparable v, Comparable w){
//        int result=v.compareTo(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;
    }
}

text

package cn.itcast.algorithm.text;

import cn.itcast.algorithm.sort.Bubble;

import java.util.Arrays;

public class BubbleText {
    public static void main(String[] args) {
        Integer[] arr={23,45,67,89,0,54,35};
        Bubble.sort(arr);
        System.out.println(Arrays.toString(arr));

    }
}

 

1.3选择排序

排序原理:(映射索引)

假设第一个元素是最小值，和其他索引出的值进行比较，如果当前索引值大于其他处的索引值，则假定其它索引处为最小值，最后可以找到最小值的所在的索引

交互第一个索引处和最小值所在索引处所在的值

 

 

选择排序api设计

构造方法：

Selection

成员方法：

 

选择排序程序设计：

 

package cn.itcast.algorithm.sort;

public class Selection {
    public static void sort(Comparable[] a){
        for (int i = 0; i <= a.length-2; i++) {
            int minIndex = i;
            for (int j=i+1;j<a.length;j++){
                if(greater(a[minIndex],a[j])){
                    minIndex=j;

                }
            }
            exch(a,i,minIndex);
        }

    }

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

text

 

package cn.itcast.algorithm.text;

import cn.itcast.algorithm.sort.Selection;

import java.util.Arrays;

public class SelectionText {

    public static void main(String[] args) {
        Integer[] a = {123,56,78,990,4569,789};
        Selection.sort(a);
        System.out.println(Arrays.toString(a));

    }


}