java编程基础（四）选择排序

选择排序运算逻辑分析

选择排序的运算逻辑是，挑选比i位置小的值交换到i位置

代码

package demo1;

import java.util.Arrays;
import java.util.Random;

public class SelectionSort {
    public static void main(String[] args) {
        int[] a = rnd();
        System.out.println(Arrays.toString(a));
        System.out.println("----------------------------");
        sort(a);
        System.out.println("----------------------------");
        System.out.println(Arrays.toString(a));
    }

    static void sort(int[] a) {
        for (int i=0;i<a.length;i++) {
            for (int j=i+1;j<a.length;j++) {
                if (a[i]>a[j]) {
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
            System.out.println(Arrays.toString(a));
        }
    }

    static int[] rnd() {
        int[] a = new int[5 + new Random().nextInt(6)];

        for (int i = 0; i < a.length; i++) {
            a[i] = new Random().nextInt(100);
        }

        return a;
    }
}
 

java编程基础（五）二分法查找

二分法查找逻辑分析

二分法查找是在一组有序数据中寻找目标值，并获得目标值所在的下标位置。

二分法查找也叫折半查找，基本逻辑是每次都向中间位置找，然后缩小一半范围再向中间位置找，请看下面的示例：

查找结束时，低位下标和高位下标可以重叠，请看下面的演示：

如果低位下标和高位下标交叉，则说明查找的目标值不存在。最终 lo 下标值则是目标值应插入的位置：

代码

package demo1;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class BinarySearch {
    public static void main(String[] args) {
        int[] a = rnd();
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.print("请输入查找的目标值：");
        int t = new Scanner(System.in).nextInt();

        int index = binarySearch(a, t);
        if (index < 0) {
            System.out.println("找不到目标值");
        } else {
            System.out.println(t+"所在的下标位置："+index);
        }
    }

    private static int binarySearch(int[] a, int t) {
        int lo = 0;
        int hi = a.length-1;
        int mid;
        while (lo <= hi) {
            mid = (lo+hi) / 2;
            if (a[mid] < t) {
                lo = mid+1;
            } else if (a[mid] > t) {
                hi = mid-1;
            } else {
                return mid;
            }
        }

        return -(lo+1);
    }

    static int[] rnd() {
        int[] a = new int[5 + new Random().nextInt(6)];

        for (int i = 0; i < a.length; i++) {
            a[i] = new Random().nextInt(100);
        }

        return a;
    }
}
 

java编程基础（六）递归

递归

递归是指在方法中调用自身

    void f() {
        f();
    }
 

递归算法的运算逻辑，是将复杂问题一步步简化，简化成最简问题，然后再倒推求出结果，请看下面的例子：

 

递归求阶乘

 

逻辑分析

求5的阶乘可以简化成求4的阶乘再乘5，依次类推，简化阶乘的最简问题：求0的阶乘，0的阶乘规定是1。再从0的阶乘倒推求出结果。

代码

package demo1;

import java.math.BigInteger;
import java.util.Scanner;

/*
递归求阶乘
 */
public class Test1 {
    public static void main(String[] args) {
        while (true) {
            System.out.print("求几的阶乘：");
            int n = new Scanner(System.in).nextInt();
            BigInteger r = f(BigInteger.valueOf(n));
            System.out.println("结果：\n"+r.toString());
        }
    }

    private static BigInteger f(BigInteger n) {
        if (n.equals(BigInteger.ZERO)) {
            return BigInteger.ONE;
        }

        return n.multiply(f(n.subtract(BigInteger.ONE)));
    }
}
 

递归解汉诺塔

三根柱子，在一根柱子上从下往上按照大小顺序摞着圆盘。按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

 

逻辑分析

将3层圆盘从A，用B辅助，移动到C，逻辑如下：

移动3层圆盘可以简化为以下步骤：

1. 先移动两层圆盘，从A，用C辅助，移动到B：

2. 将一个圆盘从A移动到C：

3. 再次移动两层圆盘，从B，用A辅助，移动到C：

以上，将三层汉诺塔，简化为移动两层汉诺塔，以此类推，可以简化成最简问题，移动一层汉诺塔。

代码

package demo1;

import java.math.BigInteger;
import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        System.out.print("求几层汉诺塔：");
        int n = new Scanner(System.in).nextInt();
        f(n);
    }

    private static void f(int n) {
        String z1="A",z2="B",z3="C";
        f(n,z1,z2,z3);
    }

    private static void f(int n, String z1, String z2, String z3) {
        if (n == 1) {
            System.out.println(z1+" -> "+z3);
            return;
        }

        f(n-1, z1,z3,z2);

        System.out.println(z1+" -> "+z3);

        f(n-1, z2,z1,z3);
    }
}