此内容受密码保护。如需查阅，请在下方输入密码。

密码：

此内容受密码保护。如需查阅，请在下方输入密码。

密码：

import java.util.*;
​
public class Main {
    public static void main(String[] args) {
​
        Node nodeA = new Node("A");
        Node nodeB = new Node("B");
        Node nodeC = new Node("C");
        Node nodeD = new Node("D");
        Node nodeE = new Node("E");
        Node nodeF = new Node("F");
        Node nodeG = new Node("G");
​
        nodeA.left = nodeB;
        nodeA.right = nodeC;
        nodeB.left = nodeD;
        nodeB.right = nodeE;
        nodeC.right = nodeF;
        nodeE.left = nodeG;
​
        //递归方式
        preOrder(nodeA);
        System.out.println();
        midOrder(nodeA);
        System.out.println();
        postOrder(nodeA);
        System.out.println();
        //非递归方式
        preOrder2(nodeA);
        System.out.println();
        midOrder2(nodeA);
        System.out.println();
        postOrder2(nodeA);
        System.out.println();
        //层序遍历
        bfs(nodeA);
        System.out.println();
        List<List<String>> lists = bfs2(nodeA);
        for (List<String> list : lists) {
            for (String str : list) {
                System.out.print(str);
            }
            System.out.println();
        }
    }
​
    public static class Node {
        private String value;
        private Node left;
        private Node right;
​
        public Node(String value) {
            this.value = value;
        }
    }
​
    //递归方式
    //先序遍历
    private static void preOrder(Node root) {
        if (root == null) return;
        System.out.print(root.value);
        preOrder(root.left);
        preOrder(root.right);
    }
​
    //中序遍历
    private static void midOrder(Node root) {
        if (root == null) return;
        midOrder(root.left);
        System.out.print(root.value);
        midOrder(root.right);
    }
    //后序遍历
    private static void postOrder(Node root) {
        if (root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.value);
    }
​
    //非递归方式
    //先序遍历
    private static void preOrder2(Node root) {
        if (root == null) return;
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            System.out.print(node.value);
            if (node.right != null) stack.push(node.right);
            if (node.left != null) stack.push(node.left);
        }
    }
​
    //中序遍历
    private static void midOrder2(Node root) {
        if (root == null) return;
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            Node node = stack.pop();
            System.out.print(node.value);
            if (node.right != null) cur = node.right;
        }
    }
    //后序遍历
    private static void postOrder2(Node root) {
        if (root == null) return;
        Stack<Node> stack = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            stack2.push(node);
            if (node.left != null) stack.push(node.left);
            if (node.right != null) stack.push(node.right);
        }
        while (!stack2.isEmpty()) {
            System.out.print(stack2.pop().value);
        }
    }
​
    //层序遍历
    private static void bfs(Node root) {
        if (root == null) return;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            System.out.print(node.value);
            if (node.left != null) queue.add(node.left);
            if (node.right != null) queue.add(node.right);
        }
    }
​
    //层序遍历按层输出
    private static List<List<String>> bfs2(Node root) {
        List<List<String>> res = new ArrayList<>();
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
​
        List<String> temp;
        while (!queue.isEmpty()) {
            int size = queue.size();
            temp = new ArrayList<>();
            while (size-- > 0) {
                Node node = queue.poll();
                temp.add(node.value);
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(temp);
        }
​
        return res;
    }
​
​
}

import java.util.LinkedList;
import java.util.Scanner;
​
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] arr = sc.nextLine().split(" ");
        LinkedList<String> list = new LinkedList<>();
        dfs(arr,list);
    }
    
    public static void dfs(String[] arr,LinkedList<String> list) {
        if(list.size()>=arr.length){
            System.out.println(list);
            return;
        }
        for(int i=0;i<arr.length;i++){
            if(!list.contains(arr[i])){
                list.add(arr[i]);
                dfs(arr,list);
                list.removeLast();
            }
        }
    }    
}

斐波那契数列：

import java.util.Scanner;
​
//斐波那契数列
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
​
        System.out.println(fb(n));
    }
​
    static int fb(int n) {
        if(n == 1||n == 2){
            return 1;
        }
        return fb(n-1) + fb(n-2);
    }
}

汉诺塔：

import java.util.Scanner;
​
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
​
        int n = sc.nextInt();
        printHanoiTower(n,"A","B","C");
​
    }
​
    static void printHanoiTower(int n,String from,String to,String help) {
        if(n==1) {
            System.out.println(n+":"+from+"->"+to);
        }else{
            printHanoiTower(n-1,from,help,to);  //将前N-1个盘子移至辅助空间
            System.out.println(n+":"+from+"->"+to);
            printHanoiTower(n-1,help,to,from);  //将N-1个盘子从辅助空间移回源空间
        }
    }
}

最长单调子序列：

以最最长递增子序列为例：

说明：输出最长递增子序列的长度，递增子序列为数组中单调递增的元素的最大个数，元素不必相邻，但相对位置必须一致

import java.util.Scanner;
​
public class Main {
    public static void main(String[] args) {
        //输入
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] arr = new int[n][2];
        for (int i = 0; i < n; i++) {
            arr[i][0] = sc.nextInt();
        }
​
        //计算
        for (int i = 0; i < n; i++) {
            arr[i][1] = 1;
            for (int j = 0; j < i; j++) {
                if(arr[i][0] > arr[j][0]){
                    arr[i][1] = Math.max(arr[i][1], arr[j][1]+1); //赋值比当前元素小的前一个元素的长度+1与1之间的最大值
                }
            }
        }
​
        //获取最大递增子序列长度
        int max = 0;
        for (int i = 0; i < n; i++) {
            max = Math.max(max, arr[i][1]);
        }
        //输出
        System.out.println(max);
        
    }
}

最大连续子序列和：

import java.util.Scanner;
​
//最大连续子序列和
//测试用例 -2,11,-4,13,-5,-2
public class study05 {
    public static void main(String[] args) {
        //输入
        Scanner sc = new Scanner(System.in);
        String[] s = sc.nextLine().split(",");
        int[] a = new int[s.length+1];
        a[0] = 0;
        for(int i=1;i<=s.length;i++){
            a[i] = Integer.parseInt(s[i-1]);
        }
​
        //计算
        int[] dp = new int[a.length];
        for(int i=1;i<s.length;i++){
            dp[i] = 0;
            //转移方程
            dp[i] = Math.max(dp[i]+a[i],a[i]);
        }
​
        //输出
        int max = 0;
        for(int i=1;i<a.length;i++){
            if(dp[i]>max){
                max = dp[i];
            }
        }
        System.out.println(max);
    }
}

最长公共子序列：(双序列)（二维dp）

import java.util.Scanner;
​
//最长公共子序列
//测试用例 BDCABC ABCBDAB 
public class Main {
    public static void main(String[] args) {
        //输入
        Scanner sc = new Scanner(System.in);
        String[] s1 = sc.nextLine().split("");
        String[] s2 = sc.nextLine().split("");
        int[][] arr = new int[s1.length+1][s2.length+1];
        //计算
        for(int i=1;i<arr.length;i++){
            for(int j=1;j<arr[i].length;j++){
                //转移方程
                if(s1[i-1].equals(s2[j-1])){
                    arr[i][j] = arr[i-1][j-1]+1;
                }else {
                    arr[i][j] = Math.max(arr[i-1][j], arr[i][j-1]);
                }
            }
        }
        //输出
        System.out.println(arr[arr.length-1][arr[0].length-1]);
    }
}

背包DP：

01背包：

//01背包
public class Main {
    public static void main(String[] args) {
        //输入
        int[] w = {2,3,4}; //物品重量
        int[] v = {3,5,6}; //物品价值
        int n = 6; //背包容量
​
        int[][] arr = new int[w.length+1][n+1];
​
        //计算
        for (int i = 1; i < w.length+1; i++) {
            for (int j = 1; j < n+1; j++) {
                //转移方程
                if (j<w[i-1]) {
                    arr[i][j]=arr[i-1][j];
                }else{
                    arr[i][j]=Math.max(arr[i-1][j],arr[i-1][j-w[i-1]]+v[i-1]);
                }
            }
        }
​
        //输出
        System.out.println(arr[w.length][n]);
    }
}

完全背包：

//完全背包
public class Main {
    public static void main(String[] args) {
        //输入
        int[] w = {2,3,4}; //物品重量
        int[] v = {3,5,6}; //物品价值
        int n = 6; //背包容量
​
        int[][] arr = new int[w.length+1][n+1];
​
        //计算
        for (int i = 1; i < w.length+1; i++) {
            for (int j = 1; j < n+1; j++) {
                //转移方程
                if (j<w[i-1]) {
                    arr[i][j]=arr[i-1][j];
                }else{
                    arr[i][j]=Math.max(arr[i-1][j],arr[i][j-w[i-1]]+v[i-1]);
                }
            }
        }
​
        //输出
        System.out.println(arr[w.length][n]);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int flag = 1;
        if (n < 2) {
            flag = 0;
        }else{
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) {
                    flag = 0;
                }
            }
        }
        if (flag == 1) {
            System.out.println("这是素数");
        }else{
            System.out.println("这不是素数");
        }
    }
}

最大公约数+最小公倍数：

import java.util.Scanner;
​
//辗转相除法
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //除数/被除数=商+余数
        int A = sc.nextInt();
        int B = sc.nextInt();
        int a = A;
        int b = B;
        while (b != 0) {
            int temp = a;
            a = b;
            b = temp%a;
        }
        
        //最大公约数=A
        System.out.println("最大公约数是："+ a);
        int c = (A*B)/a;
        //最小公倍数=A*B/最大公约数
        System.out.println("最小公倍数是："+ c);
    }
}

说明：以此比较相邻元素，并将较大元素移至后方

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {5, 4, 3, 2, 1};
        bubbleSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

选择排序：

说明：每次选择一个最小元素与未排序元素首部进行替换

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {3, 2, 5, 4, 1};
        selectionSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

插入排序：

说明：每次将未排序的首元素插入已排序的队列中

public class InsertionSort {
  
    public static int[] insertionSort(int[] a){
        if(a.length<=1) return a;
        for(int i = 1; i<a.length; ++i){
            int value = a[i];
            int j = i-1;
            //查找插入的位置
            while(j>=0&&value<a[j]){
                a[j+1] = a[j];
                j--;
            }
            a[j+1] = value;
        }
        return a;
    }
​
    public static void main(String[] args) {
        int[] a = {10, 9, 7, 4, 3, 2, 1, 8};
        System.out.println("之前的排序：");
        System.out.println(Arrays.toString(a));
​
        insertionSort(a);
        System.out.println("之后的排序：");
        System.out.println(Arrays.toString(a));
    }
}

希尔排序：

import java.util.Arrays;
​
public class Main {
​
    public static int[] shellSort(int[] a){
        //不断缩小增量
        for(int x=a.length/2;x>0;x=x/2){
            //增量为1的插入排序
            for(int i=x; i<a.length; i++){
                int value = a[i];
                int j = i-x;
                //查找插入的位置
                while(j>=0&&value<a[j]){
                    a[j+x] = a[j];
                    j-=x;
                }
                a[j+x] = value;
            }
        }
​
        return a;
    }
​
    public static void main(String[] args) {
        int[] a = {10, 9, 7, 4, 3, 2, 1, 8};
        System.out.println("之前的排序：");
        System.out.println(Arrays.toString(a));
​
        shellSort(a);
        System.out.println("之后的排序：");
        System.out.println(Arrays.toString(a));
    }
}

计数排序：

说明：使用位置+偏移量的方式，用数组确定位置用出现次数表示偏移量，逆序确定每个数字的位置

//计数排序
public class Main {
    public static void main(String[] args) {
        int[] a = {8, 10, 12, 9, 8, 12, 8}; //输入的数组
        int[] r = new int[a.length];        //输出的数组
        int min = Integer.MAX_VALUE;        //数组中的最小值
        int max = Integer.MIN_VALUE;        //数组中的最大值
        for (int i = 0; i < a.length; i++) {
            min = Math.min(min, a[i]);
            max = Math.max(max, a[i]);
        }
        int[] s = new int[max - min + 1];   //计数数组 统计每个数字出现的次数
        for (int i = 0; i < a.length; i++) {
            s[a[i]-min]++;
        }
​
        int[] s1 = new int[max - min + 1];  //排序数组 表示数字应在排序后数组的位置 当前值=前一位的值+计数数组的值
        s1[0]=s[0];
        for (int i = 1; i < s.length; i++) {
            s1[i]=s1[i-1]+s[i];
        }
        
        //逆序填写数字到相应位置
        for (int i = a.length-1; i >=0; i--) {
            r[s1[a[i]-min]-1]=a[i];
            s1[a[i]-min]--;
        }
​
        //输出数组
        for(int j=0;j<r.length;j++){
            System.out.print(r[j]+" ");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        System.out.println(SequentialSearch(arr,6));
    }
    
    //顺序查找
    static int SequentialSearch(int[] arr,int target){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==target){
                return i;
            }
        }
        return -1;
    }
}

二分查找：

public class Main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        System.out.println(binarySearchBasic(arr,7));
        System.out.println(binarySearch(arr,10));
    }
    /**
     * 二分查找基础版
     * Params:arr-待查找的升序数组  target-待查找的目标值
     * Return:找到则返回索引       找不到返回-1
     */
    public static int binarySearchBasic(int[] arr,int target){
        int i=0,j=arr.length-1;//设置指针和初值 1.i=0，j=arr.length;
        while(i<=j){//范围内有东西2.(i<j)
            int m = (i+j)>>>1;
            if(target<arr[m]){//目标在左边
                j=m-1;//3.j=m
            }else if(arr[m]<target){//目标在右边
                i=m+1;
            }else{
                return m;
            }
        }
        return -1;
    }
​
    //大量数据改进版
    public static int binarySearch(int[] arr, int target) {
        int i=0,j=arr.length;
        while(j-i>1){
            int m=(i+j)>>>1;
            if(target<arr[m]){
                j=m;
            }else{
                i=m+1;
            }
        }
        if(target==arr[i]){
            return i;
        }else{
            return -1;
        }
    }
}