排序法【冒泡排序法】

package com.Lucky.base;

import java.util.Arrays;

/*
      排序法：
        1、直接插入排序；
        2、希尔排序；
        3、简单选择排序；
        4、堆排序；
        5、冒泡排序；【目前需要掌握的】
        6、快速排序；
        7、归并排序；
        8、桶排序/基数排序。
 */
public class sort {

    public static void main(String[] args) {


        //调用自定义的冒泡排序法
        int[] arrays={78,89,45,12,100,65,22,6,7,2};  //此时的排序是烂七八糟的

        System.out.println();
        String str= Arrays.toString(Mysort(arrays));
        System.out.println(str);   //从小到大重新排序了


        String str1= Arrays.toString(MaxSort(arrays));
        System.out.println(str1);   //从大到小重新排序了
    }




    /**
     *  //冒泡排序法思路：
     * 1.获取数组中的第一个数与相邻的另一个数据相比较,第一个数比第二个数大，就交换位置
     * 2.下一轮则可以少循环一次
     * 依次循环，直到结束
     *
     * 【1,9,5,4,2,8,7】
     * @param arrs
     * @return
     */
    public static int[] Mysort(int[] arrs){
        int temp=0;

        for (int i = 0; i < arrs.length-1; i++) {  ///防止数组越界Bug
               //内层循环【比上一层循环少一次】
            for (int j = 0; j < arrs.length-1-i; j++) {
                 //交换相邻的数据【从小到大】
                if(arrs[j+1]<arrs[j]){
                    temp=arrs[j];  ///临时将大的那个值放在这里
                    arrs[j]=arrs[j+1];//将小的值放在前面
                    arrs[j+1]=temp;  //将大的值从临时变量中重新取出来
                }
            }
        }
        return arrs;
    }

    /**
     * 从大到小排序：冒泡排序法
     * @return
     */
    public static int[] MaxSort(int[] e){
        //定义一个临时变量
        int tempy=0;

        for (int i = 0; i < e.length-1; i++) {
            boolean flag=false;
            for (int j = 0; j < e.length-1-i; j++) {
                if(e[j]<e[j+1]){   // 1  3
                    tempy=e[j];   //1
                    e[j]=e[j+1];  //3
                    e[j+1]=tempy;  //1
                    flag=true;
                }
                if(flag==false){   //跳出内层循环就结束【优化】
                    break;
                }
            }
        }
        return e;
    }
}