java 冒泡排序

冒泡排序

9  8  7  6 5
第一趟: 找出最大的数  9
    第一次  8  9  7  6  5   9与8交换
    第二次  8  7  9  6  5   9与7交换
    第三次  8  7  6  9  5   9与6交换
    第四次  8  7  6  5  9   9与5交换
第二趟:找出8
    第一次  7  8  6  5  9   8与7交换
    第二次  7  6  8  5  9   8与6交换
    第三次  7  6  5  8  9   8与5交换
    第四次  7  6  5  8  9   8与9交换
第三趟:找出7
    第一次  6  7  5  8  9   7与6交换
    第二次  6  5  7  8  9   7与5交换
    第三次  6  5  7  8  9   7与8交换
    第四次  6  5  7  8  9   8与9交换
第四趟:找出6
    第一次  5  6  7  8  9   6与5交换
    第二次  5  6  7  8  9   6与7交换
    第三次  5  6  7  8  9   7与8交换
    第四次  5  6  7  8  9   8与9交换
第一版本: 发现 有些已经比较过，优化，
第一趟: 找出最大的数  9
    第一次  8  9  7  6  5   9与8交换
    第二次  8  7  9  6  5   9与7交换
    第三次  8  7  6  9  5   9与6交换
    第四次  8  7  6  5  9   9与5交换
第二趟:找出8
    第一次  7  8  6  5  9   8与7交换
    第二次  7  6  8  5  9   8与6交换
    第三次  7  6  5  8  9   8与5交换
第三趟:找出7
    第一次  6  7  5  8  9   7与6交换
    第二次  6  5  7  8  9   7与5交换    
第四趟:找出6
    第一次  5  6  7  8  9   6与5交换
第二版本：减少次数
最终版:假设数据已经有序，后者经过某趟后有序 ，减少趟数
如: 8 1 2 3 4
第一趟: 1 2 3 4 8
第二趟: 1 2 3 4 8  没有交换停止循环

引用数据类型

1、内置类

1、整数、小数 Integer Float Double 直接比较基本数据类型的大小
2、字符 :比较的unicode码之差
3、字符串:
1)、如果其中一个是领外一个起始开始的子串，返回长度之差
2)、否则返回第一个不相等的unicode码之差
4、java.util.Date:根据日期的长整形数比较

2、自定义

1、实体类  java.lang.Comparable +compareTo
2、业务排序类 java.util.Comparator +compare
1)解耦:与实体类分类
2)方便:应对多变的排序规则

新闻信息:时间排序 、点击量  、标题
商品: 价格 、收藏量

3、排序容器

1、TreeSet:数据元素可以排序且不可重复
 对比:Set接口:HashSet,元素必须重写 hashcode和equals方法。
 去重:比较等于0即重复
 1)、元素可以排序  java.lang.Comparable +compareTo
new TreeSet()
 2)、排序业务类 java.util.Comparator +compare
new TreeSet(Comparator<? super E> comparator)
注意:在添加数据时排序，数据更改不会影响原来的顺序，不要修改数据，否则可能重复
2、TreeMap:要求键 可以排序，与上TreeSet同理

工具类

工具类Collections
1、 binarySearch(List<? extends Comparable<? super T>> list, T key)   容器有序
2、sort(List<T> list)
     sort(List<T> list, Comparator<? super T> c)
3、reverse(List<?> list)
4、shuffle(List<?> list) 洗牌
5、swap(List<?> list, int i, int j)

冒泡排序代码

package demo122.sortInner;

import java.util.Comparator;
import java.util.List;

public class Utils {
    
    /**
     * List排序 + Comparator
     * @param arr
     */
    public static <T> void sort(List<T> list, Comparator<T> com){
        //第一步，转成数组
        Object[] arr = list.toArray();
        sort(arr, com);
        //第二步，改变容器中对应额值
        for(int i=0; i<arr.length; i++){
            list.set(i, (T)(arr[i]));
        }
    }
    
    /**
     * 数组排序 + Comparator
     * @param arr
     */
    public static <T> void sort(Object[] arr, Comparator<T> com){
        boolean sorted = true;
        for (int i = 0; i < arr.length - 1; i++) {
            sorted = true;//假定有序
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (com.compare((T)arr[j], (T)arr[j+1])>0) {
                    T temp = (T)arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    sorted = false;//假定失败
                }
            }
            if(sorted){
                break;
            }
        }
    }
    
    /**
     * 容器的排序
     * @param arr
     */
    public static <T extends Comparable<T>> void sort(List<T> list){
        //第一步，转成数组
        Object[] arr = list.toArray();
        sort(arr);
        //第二步，改变容器中对应额值
        for(int i=0; i<arr.length; i++){
            list.set(i, (T)(arr[i]));
        }
    }
    
    /**
     * 使用泛型的数组排序(冒泡排序)
     * @param arr
     */
    public static <T extends Comparable<T>> void sort(T[] arr){
        boolean sorted = true;
        for (int i = 0; i < arr.length - 1; i++) {
            sorted = true;//假定有序
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (((Comparable)arr[j]).compareTo(arr[j + 1])>0) {
                    T temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    sorted = false;//假定失败
                }
            }
            if(sorted){
                break;
            }
        }
    }

    /**
     * 数组排序
     * @param arr
     */
    public static void sort(Object[] arr){
        boolean sorted = true;
        for (int i = 0; i < arr.length - 1; i++) {
            sorted = true;//假定有序
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //if (((Comparable)arr[j]).compareTo(arr[j + 1])>0) {
                if (((Comparable)arr[j]).compareTo(arr[j + 1])>0) {
                    Object temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    sorted = false;//假定失败
                }
            }
            if(sorted){
                break;
            }
        }
    }
}