顺序查找法

    Java
    复制代码

    1
    /*
    2
     顺序查找法
    3
    @param objs 数组
    4
     @param obj 要查找的结果 */
    5
    public static int search(Object[] objs, Object obj){
    6
    for (int i = 0; i < objs.length; i++) {
    7
    if (obj.equals(objs[i]))
    8
    return i;
    9
    }
    10
    return -1;
    11
    }

    二分查找法

    Java
    复制代码

    1
    /*
    2
     二分查找法
    3
    @param numbers 数组
    4
     @param number 要查找的数
    5
    @param startIndex 开始下标
    6
     @param endIndex 结束下标 */
    7
    public static int search(double[] numbers, double number, int startIndex, int endIndex) {
    8
    if (numbers[startIndex] > number || numbers[endIndex] < number) {
    9
    //开始下标的值大于要查找的值 或 结束下标的值小于要查找的值
    10
    System.out.println(“您要查找的内容不在此数组中”);
    11
    return -1;
    12
    }
    13
    if (numbers[(startIndex + endIndex) / 2] == number) {
    14
    //如果中间位置的数值等于要查找的数
    15
    //直接返回下标
    16
    return (startIndex + endIndex) / 2;
    17
    } else if (numbers[(startIndex + endIndex) / 2] > number) {
    18
    //如果中间位置的数值大于要查找的数
    19
    //在前半部分查找
    20
    return search(numbers, number, startIndex, (startIndex + endIndex) / 2);
    21
    } else{
    22
    //如果中间位置的数值小于要查找的数
    23
    //在后半部分查找
    24
    return search(numbers, number, (startIndex + endIndex) / 2, endIndex);
    25
    }
    26
    }

    冒泡排序

    Java
    复制代码

    1
    public static void sort(int[] arr){
    2
    for (int j = 0; j < arr.length - 1; j++) {
    3
    //外层循环控制轮次
    4
    for (int i = 0; i < arr.length - 1 -j; i++) {
    5
    //内层循环 比较相邻数值的大小
    6
    if (arr[i] > arr[i + 1]) {
    7
    int max = arr[i];
    8
    arr[i] = arr[i + 1];
    9
    arr[i + 1] = max;
    10
    }
    11
    }
    12
    }
    13
    }

    斐波那契数列

    Java
    复制代码

    1
    /*
    2
     斐波那契数列 F(n)
    3
    @param n n 的值
    4
     @return F(n) 的值
    5
    */
    6
    public static int fibonacci(int n){
    7
    if (n < 0)
    8
    return -1;
    9
    if (n == 0){
    10
    return 1;
    11
    }else if (n == 1){
    12
    return 1;
    13
    }else {
    14
    return fibonacci(n - 1) + fibonacci(n - 2);
    15
    }
    16
    }

    汉诺塔

    Java
    复制代码

    1
    /*
    2
     @param n 层数
    3
    @param a 所在位置
    4
     @param b 借助位置
    5
    @param c 目标位置 /
    6
    public void move(int n,char a,char b,char c){
    7
    if(n == 1){
    8
    //只有一层 直接移动
    9
    System.out.println(++count + “:” + a + “->” + c);
    10
    }else{
    11
    //除最后一层移动到目标位置
    12
    move(n - 1, a, c, b);
    13
    //最后一层移到目标位置
    14
    System.out.println(++count + “:” + a + “->” + c);
    15
    //除最后一层移动到目标位置
    16
    move(n - 1, b, a, c);
    17
    }
    18
    }

    八皇后

    Java
    复制代码

    1
    //下标表示行数, 数值代表列数(从0开始)
    2
    private int[] queen;
    3

    4
    /*
    5
     八皇后问题
    6
    @param n 行数和列数 /
    7
    public void setQueen(int n) {
    8
    queen = new int[n];
    9
    //将数值初始化为 -1 表示当前位置未放置皇后
    10
    for (int i = 0; i < n; i++) {
    11
    queen[i] = -1;
    12
    }
    13
    //行数
    14
    int row = 0;
    15
    while (true) {
    16
    // 当前行放置皇后位置, 列数+1
    17
    queen[row] ++;
    18
    // 判断当前皇后位置是否越界
    19
    if (queen[row] >= n) {
    20
    // 越界则进行回溯
    21
    if (row > 0) {
    22
    // 设置当前行皇后为初始无放置状态
    23
    queen[row] = -1;
    24
    // 回溯
    25
    row—;
    26
    continue;
    27
    } else {
    28
    // row < 0 结束循环
    29
    break;
    30
    }
    31
    }
    32

    33
    //未越界, 判断是否冲突
    34
    if (!isConflict(row)) {
    35
    // 未冲突则放置
    36
    row++;
    37
    // 判断是否为了最大行
    38
    if (row >= n) {
    39
    // 最大行 输出正确结果
    40
    System.out.println(Arrays.toString(queen));
    41
    //回溯
    42
    row—;
    43
    }
    44
    //不为最大行进入下次循环
    45
    }
    46
    }
    47
    }
    48

    49
    /*
    50
     判断与之前放置的皇后是否冲突 */
    51
    public boolean isConflict(int k) {
    52
    for (int i = k - 1; i > -1; i—) {
    53
    if (queen[k] == queen[i] || Math.abs(queen[k] - queen[i]) == Math.abs(k - i)) {
    54
    return true;
    55
    }
    56
    }
    57
    return false;
    58
    }

    单例模式

    1. IoDH

    Java
    复制代码

    1
    public class SingletonIoDH {
    2

    3
    private SingletonIoDH() {
    4
    }
    5

    6
    private static class SingletonUtil{
    7
    private static final SingletonIoDH instance = new SingletonIoDH();
    8
    }
    9

    10
    public static SingletonIoDH getInstance(){
    11
    return SingletonUtil.instance;
    12
    }
    13
    }

    2. 双重校验锁

    Java
    复制代码

    1
    public class SingletonDouble {
    2
    private volatile static SingletonDouble singleton;
    3

    4
    private SingletonDouble() {
    5
    }
    6

    7
    public static SingletonDouble getInstance() {
    8
    if (singleton == null) {
    9
    synchronized (SingletonDouble.class) {
    10
    if (singleton == null)
    11
    singleton = new SingletonDouble();
    12
    }
    13
    }
    14
    return singleton;
    15
    }
    16
    }