冒泡排序和选择排序（java）

package com.xxx.scripts;

public class PaiXuMianShi {

	
	  public static void main(String[] args) {
	        System.out.println("开始执行冒泡算法");


	        System.out.println("1、顺序遍历，从小到大，先筛选出大数放后面");
	        System.out.println("-------------");
	        int[] a1 = new int[]{1, 2, 54, 333, 2, 35, 98, 67, -1, -3, 888};
	        int[] d1 = order1(a1);
	        for (int i = 0; i < a1.length; i++) {
	            System.out.println(d1[i]);
	        }

	        System.out.println("2、顺序遍历，从大到小，先筛选出小数放后面");
	        System.out.println("-------------");
	        int[] a2 = new int[]{10,58,6589,-9,1, 2, 54, 333, 2, 35, 98, 67, -1, -3, 888};
	        int[] d2 = order2(a2);
	        for (int i = 0; i < a2.length; i++) {
	            System.out.println(d2[i]);
	        }

	        System.out.println("3、逆序遍历，从大到小，先筛选出大数放前面");
	        System.out.println("-------------");
	        int[] a3 = new int[]{1, 2, 54, 333, 2, 35, 6589,-9,1, 2, 54,98, 67, -1, -3, 888};
	        int[] d3 = order3(a3);
	        for (int i = 0; i < a3.length; i++) {
	            System.out.println(d3[i]);
	        }

	        System.out.println("4、逆序遍历，从小到大，先筛选出小数放前面");
	        System.out.println("-------------");
	        int[] a4 = new int[]{1, 2, 54, 333, 55,62,3,2, 35, 98, 67, -1, -3, 888};
	        int[] d4 = order4(a4);
	        for (int i = 0; i < a4.length; i++) {
	            System.out.println(d4[i]);
	        }

	        System.out.println("冒泡排序执行完毕");
	        System.out.println("===================================");
	        System.out.println("开始执行选择排序算法");


	        System.out.println("5、顺序遍历，从小到大，先筛选出大数放后面");
	        System.out.println("-------------");
	        int[] a5 = new int[]{1, 2, 54, 333, 2, 35, 98, 67, -1, -3, 888,0,15,-3};
	        int[] d5 = order5(a5);
	        for (int i = 0; i < a5.length; i++) {
	            System.out.println(d5[i]);
	        }


	        System.out.println("6、顺序遍历，从大到小，先筛选出小数放后面");
	        System.out.println("-------------");
	        int[] a6 = new int[]{1, 2,3,-999,54,159, 54, 333, 2, 35, 98, 67, -1, -3, 888};
	        int[] d6 = order6(a6);
	        for (int i = 0;i<a6.length;i++){
	            System.out.println(d6[i]);
	        }

	        System.out.println("7、逆序遍历，从小到大，先筛选出小数放前面");
	        System.out.println("-------------");
	        int[] a7 = new int[]{1, 2, 54, 333, 2, 35, 98, 67, -1, -3, 888};
	        int[] d7 = order7(a7);
	        for (int i = 0;i<a7.length;i++){
	            System.out.println(d7[i]);
	        }

	        System.out.println("8、逆序遍历，从大到小，先筛选出大数放前面");
	        System.out.println("-------------");
	        int[] a8 = new int[]{1, 2, 54, 333, 2, 35, 98, 67, -1, -3, 888};
	        int[] d8 = order8(a8);
	        for (int i = 0;i<a8.length;i++){
	            System.out.println(d8[i]);
	        }

	    }
	//   冒泡算法
	    // 顺序遍历，从小到大，先筛选出大数放后面
	    static int[]  order1(int[] b){
	        if(b.length>0){
	            for (int i = 0; i < b.length; i++) {
	                for (int j = 0; j < b.length -i -1; j++) {
	                    if (b[j]>b[j+1]){
	                        int c = b[j+1];
	                        b[j+1] = b[j];
	                        b[j] = c;
	                    }
	                }
	            }
	        }
	        return b;
	    }

	    //    顺序遍历，从大到小，先筛选出小数放后面
	    static int[]  order2(int[] b){
	        if(b.length>0){
	            for (int i = 0; i < b.length; i++) {
	                for (int j = 0; j < b.length -i -1; j++) {
	                    if (b[j]<b[j+1]){
	                        int c = b[j+1];
	                        b[j+1] = b[j];
	                        b[j] = c;
	                    }
	                }
	            }
	        }
	        return b;
	    }
	    //    既然可以从前往后排序，那么是不是也可以从后往前排序呢？
//	    逆序遍历，从大到小，先筛选出大数放前面
	    static int[] order3(int[] b){
	        if (b.length>0){
	            for (int i = b.length -1; i > 0; i--) {
	                for (int j = b.length - 1;j>b.length - i-1;j--){
	                    if(b[j]>b[j-1]){
	                        int d = b[j-1];
	                        b[j-1] = b[j];
	                        b[j] = d;
	                    }
	                }
	            }
	        }
	        return b;
	    }

	    //   逆序遍历，从小到大，先筛选出小数放前面
	    static  int[] order4(int[] b){
	        if (b.length>0){
	            for (int i = b.length-1;i>0;i--){
	                for (int j = b.length -1; j > b.length - i -1 ; j--) {
	                    if (b[j] < b[j-1]){
	                        int d = b[j-1];
	                        b[j-1] = b[j];
	                        b[j] =d;
	                    }
	                }
	            }
	        }
	        return b;
	    }

//	    ========================================================
//	    选择排序
//	    顺序遍历，从小到大，先筛选出大数放后面
	    static int[] order5(int[] b){
	    //        假设b[0]是最大值
	        int max = 0;
	        int c =0;
	        for (int i = 0; i < b.length; i++) {
	            for (int j = 0;j< b.length - i;j++){
	                if (b[max]<b[j]){
	                    max = j;
	                }
	            }
	            c = b[b.length - i-1];
	            b[b.length - i-1] = b[max];
	            b[max] = c;
	            max = 0;
	        }
	        return b;
	    }

//	    顺序遍历，从大到小，先筛选出小数放后面
	static int[] order6(int[] b){
	    int min = 0;
	    int c =0;
	    for (int i = 0; i < b.length; i++) {
	        for (int j = 0;j< b.length - i;j++){
	            if (b[min]>b[j]){
	                min = j;
	            }
	        }
	        c = b[b.length - i-1];
	        b[b.length - i-1] = b[min];
	        b[min] = c;
	        min = 0;
	    }
	    return b;
	}

	    //    逆序遍历，从小到大，先筛选出小数放前面
	    static int[] order7(int[] b){
	        int min = b.length -1;
	        int c =0;
	        for (int i = b.length -1; i >= 0; i--) {
	            for (int j = b.length -1;j>= b.length - i-1;j--){
	                if (b[min]>b[j]){
	                    min = j;
	                }
	            }
	            c = b[b.length - i-1];
	            b[b.length - i-1] = b[min];
	            b[min] = c;
	            min = b.length -1;
	        }
	        return b;
	    }

	    //    逆序遍历，从大到小，先筛选出大数放前面
	    static int[] order8(int[] b){
	        int max = b.length -1;
	        int c =0;
	        for (int i = b.length -1; i >= 0; i--) {
	            for (int j = b.length -1;j>= b.length - i-1;j--){
	                if (b[max]<b[j]){
	                    max = j;
	                }
	            }
	            c = b[b.length - i-1];
	            b[b.length - i-1] = b[max];
	            b[max] = c;
	            max = b.length -1;
	        }
	        return b;
	    }
}