算法十八招

第一招：动态规划算法

动态规划思想：把问题分解为多个阶段，每个阶段执行决策，记录每一个阶段可达的状态集合（去重后），
基于当前阶段的状态集合，通过决策，推导下一个阶段的状态结婚，动态的往前推进
经典背包问题：有一组不同重量不可分割的物品，需要选择一些装入背包，在满足背包最大重量限制的前提下
，背包中物品的最大重量是多少？
1、把问题分为多个阶段，物品是一个一个装入选择是否装入背包中，每一个物品选择是否装入背包作为一个阶段，共有物品个数个阶段
2、每个阶段做出决策，选择是否装入该物品
3、每个阶段做出决策前有一个当前状态集合，做出决策后也记录可达状态集合（去重）
依次步骤动态的往前推进 阶段就是for循环 决策就是for循环里的逻辑 初始化状态集合，并在执行决策后记录可达的状态集合
循环执行完后，即动态推进结束

public class Packet {
    public int packet(int[] weights, int maximum) {
        int number = weights.length;
        boolean[][] states = new boolean[number][maximum+1];//true表示可达状态
        states[0][0] = true;
        if(weights[0] <= maximum) {
            states[0][weights[0]] = true;
        }
        for(int i=1; i<number; i++) {
            //装进背包
            for(int j=0; j<=maximum; j++) {
                if(states[i-1][j] && j + weights[i] <= maximum) {
                    states[i][j + weights[i]] = true;
                }
            }
            //不装进背包
            for(int j=0; j<=maximum; j++) {
                if(states[i-1][j]) {
                    states[i][j] = true;
                }
            }
        }
        for(int i=maximum; i>=0; i--) {
            if(states[number-1][i]) {
                return i;
            }
        }
        return 0;
    }

    public static void main(String[] args) {
        Packet demo = new Packet();
        int[] weight = {2, 2, 4, 6, 3}; // 物品重量
        int n = 5; // 物品个数
        int w = 9; // 背包承受的最大重量
        System.out.println(demo.packet(weight, w));
    }

}

第二招：贪心算法

贪心算法思想：每次都选择堆期望值贡献最大的数据

经典背包问题：有一组不同重量不可分割的物品，每个物品都有对象的价值，需要选择一些装入背包，在满足背包最大重量限制的前提下，背包中物品的最大价值是多少？

public class Packet {
    public int packet(int[] weights, int[] values, int maximum) {
        //构建性价比数组
        int number = weights.length;
        double[] w_v = new double[number];
        int[] index = new int[number];
        for(int i=0; i<number; i++) {
            w_v[i] = values[i] / weights[i];
            index[i] = i;
        }
        
        double temp = 0;
        int x = -1;
        for(int i=0; i<number-1; i++) {
            for(int j=i+1; j<number; j++) {
                if(w_v[index[j]] > w_v[index[i]]) {
                    temp = w_v[index[j]];
                    w_v[index[j]] = w_v[index[i]];
                    w_v[index[i]] = temp;
                    
                    x = index[i];
                    index[i] = index[j];
                    index[j] = x;
                }
            }
        }
        
        //将排好序的重量和价值分别存到数组中
        int[] w1 = new int[number];
        int[] v1 = new int[number];
        for(int i=0; i<number; i++) {
            w1[i] = weights[index[i]];
            v1[i] = values[index[i]];
        }
        
        int maxValue = 0;
        int sumWeight = 0;
        for(int i=0; i<number; i++) {
            if(sumWeight + w1[i] <= maximum) {//表示当前物品装得下
                sumWeight += w1[i];
                maxValue += v1[i];
            }
        }
        return maxValue;
    }

    public static void main(String[] args) {
        Packet demo = new Packet();
        int[] weights = {35, 30, 60, 50, 40, 10, 25}; // 物品重量
        int[] values = {10, 40, 30, 50, 35, 40, 30};// 物品价值
        int maximum = 150; // 背包承受的最大重量
        System.out.println(demo.packet(weights, values, maximum));
    }
}

 第三招：回溯算法

经典八皇后问题：

//8皇后问题--回溯算法
public class Recall {
    int[] result = new int[8];//全局或成员变量，下标表示行，值表示queue存储在哪一列
    
    public static void main(String[] args) {
        Recall recall = new Recall();
        recall.cal8queues(0);
    }
    
    public void cal8queues(int row) {//调用方式：cal8queues(0)
        if(row == 8) {//8个棋子都放置好了，打印结果
            printQueues(result);
            return;//8行棋子都放好了，已经没法再往下递归了，所以就return
        }
        for(int column=0; column<8; column++) {//每一行都有8种放法
            if(isOk(row, column)) {//有些放法不满足要求
                result[row] = column;//第row行的棋子放到了column列
                cal8queues(row+1);//考察下一行
            }
        }
    }
    
    private boolean isOk(int row, int column) {//判断row行column列放置是否合适
        int leftup = column-1, rightup = column+1;
        for(int i=row-1; i>=0; i--) {//逐行往上考察每一行
            if(result[i] == column) {
                return false;//第i行的column列有棋子吗？
            }
            if(leftup >= 0) {//考察左上对角线：第i行leftup列有棋子吗？
                if(result[i] == leftup) {
                    return false;
                }
            }
            if(rightup < 8) {//考察右上对角线：第i行rightup列有棋子吗？
                if(result[i] == rightup) {
                    return false;
                }
            }
            leftup--;
            rightup++;
        }
        return true;
    }
    private void printQueues(int[] result) {//打印一个二维矩阵
        for(int row=0; row<8; row++) {
            for(int column=0; column<8; column++) {
                if(result[row] == column) {
                    System.out.print("Q");
                }else {
                    System.out.print("*");
                }
            }
            System.out.println();
        }
        System.out.println();
    }
}

第四招：二叉树

【递归 | 非递归】前序、中序、后序遍历

import java.util.Stack;

public class BinaryTree {
    static class Node {
        public String value;//节点存储的内容
        public Node leftNode;//左孩子
        public Node rightNode;//右孩子
        
        public Node(String value) {
            this.value = value;
        }
    }
    public static void main(String[] args) {
/**
                 8
               /   
              6     7
             /    / 
            2   3 4   5
           /
          1
 */
        Node root = new Node("8");
        Node node1 = new Node("1");
        Node node2 = new Node("2");
        Node node3 = new Node("3");
        Node node4 = new Node("4");
        Node node5 = new Node("5");
        Node node6 = new Node("6");
        Node node7 = new Node("7");
        root.leftNode = node6; root.rightNode = node7;
        node6.leftNode = node2; node6.rightNode = node3;
        node7.leftNode = node4; node7.rightNode = node5;
        node2.leftNode = node1;
        BinaryTree demo = new BinaryTree();
        demo.npreOrder(root);
        System.out.println();
        demo.ninOrder(root);
        System.out.println();
        demo.npostOrder(root);
        System.out.println();
        
        demo.preOrder(root);
        System.out.println();
        demo.inOrder(root);
        System.out.println();
        demo.postOrder(root);
        System.out.println();
    }
    
    //非递归前序遍历
    public void npreOrder(Node node){
        Stack<Node> sk=new Stack<Node>();
        Node n=node;
        while(!sk.isEmpty() || n!=null){
            if(n!=null){
                System.out.print("->");
                System.out.print(n.value);
    
                sk.push(n);
                n=n.leftNode;
            }else{
                n=sk.pop();;
                n=n.rightNode;
            }
        }
    }
    //非递归的中序遍历
    public void ninOrder(Node node){
        Stack<Node> s=new Stack<Node>();
        Node n = node;
        while(n != null || !s.isEmpty()){
            if(n != null){
                s.push(n);
                n = n.leftNode;
            }else{
                n = s.pop();
                System.out.print("->");
                System.out.print(n.value);
                n = n.rightNode;
            }
        }
    }
  //非递归后序遍历
    public void npostOrder(Node node){
        Stack<Node> s1=new Stack<Node>();//第一次入栈
        Stack<Node> s2=new Stack<Node>();//第二次入栈
        Node n=node;
        while(!s1.isEmpty() || n!=null){
            if(n != null){
                s1.push(n);
                s2.push(n);
                n=n.rightNode;
            }else{
                n=s1.pop();
                n=n.leftNode;
            }
        }
        while(!s2.isEmpty()){
            System.out.print("->");
            System.out.print(s2.pop().value);
        }
    }
    
    //递归前序遍历
    public void preOrder(Node node){
        if(node != null){
            System.out.print("->" + node.value);
            preOrder(node.leftNode);
            preOrder(node.rightNode);
        }
    }
  //中序遍历
    public void inOrder(Node node){
        if(node!=null){
            inOrder(node.leftNode);
            System.out.print("->" + node.value);
            inOrder(node.rightNode);
        }
    }
  //后序遍历
    public void postOrder(Node node){
        if(node!=null){
            postOrder(node.leftNode);
            postOrder(node.rightNode);
            System.out.print("->" + node.value);
        }
    }
}

 第五招：分治算法

经典归并排序问题：

要求：
对数组进行排序

思路：
把数组对半分，把对半分的数组再次对半分，分到最后子数组长度为1的时候开始按照有序规则，合并两个数组，递归返回，最后合并成一个大的有序数组

//归并排序
    public static int[] mergeSort(int[] arr) {
        if (arr.length < 2) return arr;
        int[] arr1 = Arrays.copyOfRange(arr, 0, arr.length / 2);
        int[] arr2 = Arrays.copyOfRange(arr, arr.length / 2, arr.length);
        arr1 = mergeSort(arr1);
        arr2 = mergeSort(arr2);
        return combine(arr1, arr2);
    }
    //合并函数
    private static int[] combine(int[] arr1, int[] arr2) {
        int[] arr = new int[arr1.length + arr2.length];
        for (int i = 0, j = 0, k = 0; k < arr.length; k++) {
            int temp;
            if (arr1.length <= i) temp = arr2[j++];
            else if (arr2.length <= j) temp = arr1[i++];
            else if (arr1[i] < arr2[j]) temp = arr1[i++];
            else temp = arr2[j++];
            arr[k] = temp;
        }
        return arr;
    }