Java基础知识（入门级四）

10、冒泡排序

请将下列几个数按照冒泡排序的方法排列

import java.util.Arrays;
/**本类用来完成冒泡排序*/
public class BubbleSort {
    public static void main(String[] args) {
        //创建一个无序的数组
        int[] a = {27,96,73,25,21};
        //调用method()完成排序
        int[] newA = method(a);
        System.out.println("排序完毕:"+Arrays.toString(newA));
    }
    public static int[] method(int[] a) {
        //外层循环,控制比较的轮数,假设有n个数,最多比较n-1次
        for(int i = 1 ; i <= a.length-1 ; i++) {
            System.out.println("第"+i+"轮:");
            //内层循环:相邻比较+互换位置
            for(int j=0; j < a.length-1 ; j++) {
                //相邻比较,a[j]代表的就是前一个元素,a[j+1]代表的就是后一个元素
                if(a[j] > a[j+1]) { //交换数据
                   int t = a[j];
                   a[j] = a[j+1];
                   a[j+1] = t;
                }
            }
            System.out.println("第"+i+"轮的结果:"+Arrays.toString(a));
        }
        return a;//把排序好的数组a返回
    }
}

分析冒泡排序的算法思路可以知道，如果有n个数参加排序，则最多需要进行n-1轮的比较，每轮的比较均能实现将参与比较的数中的最大值排列到其最终的位置，则可以由上述的代码实现。但是，当参与的n个数基本有序的时候，使用上述算法，时间复杂度就会较大，因此有下列优化后的冒泡排序算法。
优化后的冒泡排序算法

import java.util.Arrays;
import java.util.Random;
/**本类用来完成冒泡排序，经过优化*/
public class BubbleSort {
    public static void main(String[] args) {
        //创建一个无序的数组
        int[] a = createArray();
        //调用method()完成排序
        int[] newA = bubbleSort(a);
        System.out.println("排序完毕:"+Arrays.toString(newA));
    }
    public static int[] createArray() {
        //创建数组--动态
        int length = new Random().nextInt(8);
        int[] a = new int[length];
        //遍历数组,给数组中的每个元素赋值
        for(int i = 0 ; i <a.length ; i++) {
            //100是自定义的数据,表示生成的随机整数的范围是[0,100)
            a[i] = new Random().nextInt(100);     
        }
        //使用数组的工具类查看数组中的元素
        System.out.println(Arrays.toString(a));
        return a;
    }
    public static int[] bubbleSort(int[] a) {
        //外层循环,控制比较的轮数,假设有n个数,最多比较n-1次
        for(int i = 1 ; i <= a.length-1 ; i++) {
            boolean flag = false;//优化2
            System.out.println("第"+i+"轮:");
            //内层循环:相邻比较+互换位置
            //结束值:a.length-1-i -i是因为之前轮中找到的最大值无序参与比较,i轮会产生i个最大值,所以需要
            for(int j=0; j < a.length-1-i ; j++) {//优化1
                //相邻比较,a[j]代表的就是前一个元素,a[j+1]代表的就是后一个元素
                if(a[j] > a[j+1]) {
                   int t = a[j];
                   a[j] = a[j+1];
                   a[j+1] = t;
                   flag = true;       
                }
            }
            if(flag == false) {
                return a;
            }
           System.out.println("第"+i+"轮的结果:"+Arrays.toString(a));
        }
        return a;//把排序好的数组a返回
    }
}

这个程序是优化以后的冒泡排序，数组中的数可以随机生成，并且设置了一个标志位，控制循环的轮数，对于基本有序的数，进行排序的时候能够有效的提高其时间复杂度。

11、判断某一个正整数的位数中含某个元素的个数

两个三整数 m和 k，num，其中 1 < m < 1000001<m<100000，1 < k < 5，判断 m 能否被 19整除，且各位数字中恰好含有 k个num 。如果满足条件，则输出"YES"，否则，输出"NO"。

import java.util.Scanner;
/**判断正整数中某个数字的个数*/
public class Main{
	public static void main(String[] args) {
		 int count = 1,t = 0,n=0;
	     Scanner sc = new Scanner(System.in);
	     int m = sc.nextInt();   //获取整数m
	     int k = sc.nextInt();   //判断整数中是否存在k个num
	     int num = sc.nextInt();  //判断整数中的num
	     int m1 = m;    //将整数m的值赋值给m1
	     if(m%19==0){  //判断m是否能够被19整数
	       //判断整数m的位数
	        while(m>=10){
	           m = m/10;
	           count++;  //记录整数m的位数
	         }
	        for(int i = 0;i<=count;i++) {  
	           t = m1%10;
	           m1 = m1/10;  //求出整数m中各个位置上的数
	           if(t==num) //记录整数m中num的个数
	               n++;
	        }
	        if(k == n)  //判断整数m中num的个数是否为k
	           System.out.println("YES");
	        }
	        else {
	        	System.out.println("NO");
	     }
	}
}

这段程序主要涉及到求正整数的位数，以及每个位置上的值为什么的问题，本段代码使用除以10的方式判断正整数的位数，通过求余的方式判断各个位置上的值。