冒泡排序算法-java语言

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ALG {
    //调用函数实现相应需求

    public static void main(String[] args) {

        /* 23，99，56，1，34，55*/

        int[] a = {23, 99, 56, 1, 34, 55};

//        System.out.println("before:"+ Arrays.toString(a));
//        System.out.println("after:"+Arrays.toString(BubbleSort(a)));




//        System.out.println(narcissisticNumber());
//        /**
//         * 打印出100以内的斐波拉契数列*/
//        for(int i=0;;i++){
//            if(Fibonacci(i)<=100){
//                System.out.println(Fibonacci(i));
//            }else {
//                break;
//            }
//
//        }
        //快速排序
//        System.out.println(Arrays.toString(InsertSort(a)));

        QuickSort(a,0,a.length-1);
        System.out.println(Arrays.toString(a));

    }

    /**
     * 冒泡排序
     */
    public static int[] BubbleSort(int[] arrays) {
        for (int i = 0; i < arrays.length - 1; i++) {
            for (int j = 0; j <i; j++) {

                if (arrays[j] > arrays[j + 1]) {

                    int temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
        }
        return arrays;
    }


    /**
     * 打印出所有的 " 仙花数 "，所谓 " 仙花数 “是指 个三位数，其各位数字  和等于该数本身
     */


    public static List narcissisticNumber() {
        List list = new ArrayList();


        for (int i = 100; i < 1000; i++) {
            //个位
            int a = i % 100 % 10;
            //十位
            int b = i % 100 / 10;
            //百位
            int c = i / 100;
            if (a * a * a + b * b * b + c * c * c == i) {
                System.out.println(i);
                list.add(i);
            }
        }
        return list;
    }
    /**
     * 斐波拉契数
     */
    public static int Fibonacci(int i) {


        if (i <= 2) {
            return 1;

        } else {
            return Fibonacci(i - 1) + Fibonacci(i - 2);
        }
    }

    /**
     * 插入排序
     */
    public static int[] InsertSort(int[] arrays) {
        for (int i = 1; i < arrays.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arrays[j] >= arrays[j - 1]) {
                    break;
                } else {
                    int temp = arrays[j];
                    arrays[j] = arrays[j - 1];
                    arrays[j - 1] = temp;
                }
            }
        }
        return arrays;
    }

    /**
     * 快速排序
     */

    public static void QuickSort(int[] array,int start ,int end){
        if(start>=end){
            return ;
        }
        int index=partition(array,start,end);
        QuickSort(array,start,index-1);
        QuickSort(array,index+1,end);
    }


    public static int partition(int []array,int start,int end){
    //固定的切分方式
    int key=array[start];
        while(start<end){
        while(array[end]>=key&&end>start){//从后半部分向前扫描
            end--;
        }
        array[start]=array[end];
        while(array[start]<=key&&end>start){//从前半部分向后扫描
            start++;
        }
        array[end]=array[start];
    }
    array[end]=key;
        return end;
}


}