最近从头开始学习Java,记录一下最基础的java练习题

阶乘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 /**
 * 阶乘
 * 1! 1*1
 * 2! 2*1
 * 3! 3*2*1
 * 4! 4*3*2*!
 */
public static int Count1(int x) {
    if (x==1){
        return 1;
    } else {
        return x*Count1(x-1);
    }
}

99乘法表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 /**
 * 99乘法表
 */
public static void Count99() {
    int sum = 0;
    for (int i = 1; i <=9 ; i++) {
        for (int j = 1; j < i +1; j++) {
            sum = j *i;
            System.out.print(j +"x" +i +"="+sum);
            System.out.print("|");
        }
        System.out.println();
    }
}

求100以内能被2整除的余数，并且让每三个显示一行

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * 求100以内能被2整除的余数，并且让每三个显示一行
 */
public static void Count3() {
    for (int i = 0; i <100 ; i++) {
        if (i%2==0){
            System.out.print(i+"\t");
        }
        if (i%(2*3)==0){
            System.out.println();
        }
    }
}

显示100以内的数,求100的和

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 显示100以内的数
 * 求100的和
 */
public static void Count4() {
    int sum = 0;
    for (int i = 0; i <=100 ; i++) {
        System.out.println(i);
        sum = sum +i;
    }
    System.out.println(sum);
}

打印三角形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
  * 打印三角形
  */
  public static void triangle() {
     for (int i = 1; i <=5 ; i++) {
         for (int j = 5;j>=i;j--)
             System.out.print(" ");
         for (int j = 1;j<=i;j++)
             System.out.print("*");
         for (int j = 1;j<i;j++)
             System.out.print("*");
         System.out.println();
     }
 }

计算器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * 计算器
 * 此方法体中有一处单scanner.nextLine() 是为了解决nextLine被跳过的问题
 * 由于scanner类中只有nextLine方法是以回车结尾，而nextInt，nextDouble…都不是以回车为结尾
 */
public static void countMachine() {
    Scanner scanner = new Scanner(System.in);
    while (scanner.hasNextLine()) {
        float one = scanner.nextFloat();
        scanner.nextLine();
        String two = scanner.nextLine();
        float thr = scanner.nextFloat();
        switch (two){
            case "+":
                System.out.println(one+thr);
                break;
            case "-":
                System.out.println(one-thr);
                break;
            case "x":
                System.out.println(one*thr);
                break;
            case "/":
                System.out.println(one/thr);
                break;
            default:
                System.out.println("输入有误");
        }

    }
}

循环输出数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 循环输出数组
 * @param array
 */
public static void printArray(int[] array){
    for (int i = 0; i < array.length ; i++) {
        System.out.println(array[i]);
    }
    // 增强for循环
    for (int j:
         array) {
        System.out.println(j);
    }
}

反转数组

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * 反转数组
 * @param array
 * @return
 */
public static int[] reverseArray(int[] array){
    int[] result = new int[array.length]; // new一个result的数组 长度等于 传入array的长度
    // 反转
    for (int i = 0,j=array.length-1; i <array.length ; i++,j--) {
        result[j] = array[i];
    }
    return result;
}

冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
  冒泡排序
 */
public static void BubbleSort(int[] array){
    for (int i = 1; i <array.length ; i++) {     // i代表第二个数
        for (int j = 0; j <array.length-1 ; j++) {  // j代表第二个数
            if (array[j]>array[j+1]){  // 如果第一个数比第一个数大 就准备交换两个数的位置 依次比较
                int temp = array[j];   // java替换位置 需要有一个临时变量来保存其中一个数的值  把第一个数赋值给临时变量
                array[j] = array[j+1]; // 第二个数的值赋值给第一个数
                array[j+1] = temp;     // 把存储第一个数的值的临时变量赋值给第二个数 完成交换
            }
        }
    }
    System.out.println(Arrays.toString(array));
}

插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
插入排序
每次从原数组中取一个值到新数组中去作比较
 */
public static void insertSort(int[] array){
    // 创建一个和原数组相同的空数组 用来存放排序后的数值
    int sortArray[] = new int[array.length];
    // 数组中第一个元素定为排序好的元素
    sortArray[0] = array[0];
    // 依次遍历未排序的元素
    for (int i = 1; i < array.length; i++) {
        // 找一个临时值来存未排序元素
        int temp = array[i];
        // 记录待排序数组下标需要插入已排序数组的位置
        int index = i;
        // 从已排序好的数组右边依次遍历数组，直到找到待排序元素需要插入的位置
        while (index > 0 && temp < sortArray[index-1]){
            sortArray[index] = sortArray[index-1];
            index--;
        }
        // 插入待排序元素
        sortArray[index] = temp;
    }
    System.out.println(Arrays.toString(sortArray));
}

选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
选择排序
每次取最小的依次交换位置
 */
public static void selectSort(int[] array){
    // 一次进行选择排序，每次找出最小的元素，放入待排序的序列中
    for (int i = 0; i < array.length; i++) {
        //记录最小元素min和最小元素的数组下标索引minIndex
        int min = array[i];
        int minIndex = i;
        // 在未排序的序列中找出最小的元素和对应数组中的位置
        for (int j = i+1; j <array.length ; j++) {
            if (array[j] < min){ // 如果第二位的数小余第一位
                min = array[j]; // 就交换位置
                minIndex = j;  // 并记录下标
            }
        }
        // 交换位置
        int temp = array[i];
        array[i] = array[minIndex];
        array[minIndex] = temp;
    }
    System.out.println(Arrays.toString(array));
}

希尔排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
    /*
    希尔排序
     */
    public static void shellSort(int[] array){
        // 初始化希尔排序的增量为插入的数组长度
        int gap = array.length;
        // 不断地进行插入排序，直至增量为1
        while (true) {
            // 增量每次减半
            gap = gap/2;
            for (int i = 0; i < gap ; i++) {
                // 内部循环是一个插入排序
                for (int j = i+gap; j <array.length ; j+=gap) {
                    int temp = array[j];
                    int k = j - gap;
                    while (k >= 0 && array[k] > temp){
                        array[k+gap] = array[k];
                        k -= gap;
                    }
                    array[k+gap] = temp;
                }
            }
            // 增量为1之后，希尔排序结束，退出循环
            if (gap == 1)
                break;
        }
        System.out.println(Arrays.toString(array));
    }
}