Java日常练习题,每天进步一点点(7)

Java日常练习题系列是一组适合Java初学者的练习题，能够帮助Java新手提高编程水平和理解各种基础算法。对于第七篇“Java日常练习题,每天进步一点点(7)”，我会详细讲解攻略。

题目简介

本篇练习题共有5道题目，包含以下内容：
1. 实现冒泡排序
2. 编写水仙花数判断程序
3. 编写斐波那契数列的程序
4. 编写二分查找算法
5. 编写插入排序

题目解析

1. 实现冒泡排序

冒泡排序是一种简单的排序算法，时间复杂度为O(n^2)。其基本思路是：对于一个长度为n的数列，依次比较相邻的两个元素大小，交换位置，把最大的元素向后移动，直到数列末尾，就完成了一趟排序。接着进行n-1趟排序，即可完成整个排序。以下是冒泡排序的Java代码实现。

public void bubbleSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j] > array[j+1]) {
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}

2. 编写水仙花数判断程序

水仙花数，也叫自恋数，是指一个3位数，其各位数字立方和等于该数本身。例如，153是一个水仙花数，因为1^3 + 5^3 + 3^3 = 153。以下是水仙花数判断程序的Java代码实现。

public boolean isNarcissisticNumber(int num) {
    if (num < 100 || num > 999) {
        return false;
    }
    int sum = 0;
    int temp = num;
    while (temp != 0) {
        int digit = temp % 10;
        sum += Math.pow(digit, 3);
        temp /= 10;
    }
    return sum == num;
}

3. 编写斐波那契数列的程序

斐波那契数列是指从0和1开始，每个数字都是前两个数字之和。例如，斐波那契数列的前10项为：0, 1, 1, 2, 3, 5, 8, 13, 21, 34。以下是斐波那契数列程序的Java代码实现。

public int[] fibonacci(int n) {
    int[] result = new int[n];
    if (n == 1) {
        result[0] = 0;
    } else if (n == 2) {
        result[0] = 0;
        result[1] = 1;
    } else {
        result[0] = 0;
        result[1] = 1;
        for (int i = 2; i < n; i++) {
            result[i] = result[i-1] + result[i-2];
        }
    }
    return result;
}

4. 编写二分查找算法

二分查找算法，也叫折半查找，是一种高效的查找算法，时间复杂度为O(log n)。基本思路是：对于一个有序数列，在每一步把查找区间缩小一半，直到找到目标元素，或者查找区间为空。以下是二分查找算法的Java代码实现。

public int binarySearch(int[] array, int target) {
    int left = 0, right = array.length-1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (array[mid] == target) {
            return mid;
        } else if (array[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

5. 编写插入排序

插入排序是一种简单的排序算法，时间复杂度为O(n^2)。其基本思路是：对于一个长度为n的数列，从左到右进行排序。假设前i-1个元素已经排好序，将第i个元素插入到前面的有序序列中，直到整个序列有序。以下是插入排序的Java代码实现。

public void insertionSort(int[] array) {
    int n = array.length;
    for (int i = 1; i < n; i++) {
        int key = array[i];
        int j = i - 1;
        while (j >= 0 && array[j] > key) {
            array[j+1] = array[j];
            j--;
        }
        array[j+1] = key;
    }
}

示例

以下是两个题目的示例：

示例1：实现冒泡排序

int[] array = {3, 1, 5, 8, 2};
bubbleSort(array);
for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
}
// 输出结果：1 2 3 5 8

示例2：编写斐波那契数列的程序

int[] result = fibonacci(10);
for (int i = 0; i < result.length; i++) {
    System.out.print(result[i] + " ");
}
// 输出结果：0 1 1 2 3 5 8 13 21 34

以上就是本题的详细解析和示例，希望对Java初学者有帮助。