剑指offer算法练习（java语言）

女爷i 2022-10-22 12:55 56阅读 0赞

### 1，二维数组中的查找（两种解法） ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70][]

package com.example.alipay.arithmetic;
    
    public class test1 {
        public static void main(String[] args) {
            int [][]array= new int[][] {
       {1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};//4*4的矩阵
            int target=7;
            showMatrix(array);
            System.out.println(Find1(target,array));
            System.out.println(Find2(target,array));
    
        }
    
        /**
         * 显示矩阵
         * @param array
         */
        public static void showMatrix(int [][] array) {
            System.out.println("打印矩阵:");
            int row=array.length;
            int col=array[0].length;
            for (int i=0;i<row;i++){
                for (int j=0;j<col;j++){
                    System.out.print(array[j][i]+"，");
                }
                System.out.println();
    
            }
        }
    
        /**
         * 暴力解法，时间复杂度O(N^2)，空间复杂度O(1)
         * @param target
         * @param array
         * @return
         */
        public static boolean Find1(int target, int [][] array) {
            System.out.println("暴力解法，时间复杂度O(N^2)，空间复杂度O(1)");
            int row=array.length;
            int col=array[0].length;
            for (int i=0;i<row;i++){
                for (int j=0;j<col;j++){
                    if(array[i][j]==target)
                        return true;
                }
            }
            return false;
        }
        /**
         * 观察可知元素从上到下递增，从左到右递增
         * （左下角的元素m是这一行最小的元素，是这一列最大的元素）
         * 当 m < target，由于 m 已经是该行最大的元素，想要更大只有从列考虑，取值右移一位
         * 当 m > target，由于 m 已经是该列最小的元素，想要更小只有从行考虑，取值上移一位
         * 当 m = target，找到该值，返回 true
         * 用某行最小或某列最大与 target 比较，每次可剔除一整行或一整列
         * 左下角开始向右上查找，每次判断都能剔除一整行或一整列
         * 时间复杂度O(行高+列高)，空间复杂度O(1)
         */
        public static boolean Find2(int target, int [][] array) {
            System.out.println("左下角开始向右上查找的解法");
            int rows = array.length;//行的长度
            int cols = array[0].length;//列的长度
            int i=rows-1,j=0;//做下角元素的坐标
            while(i>=0 && j<cols){
                if(target<array[i][j])//target比m小，target元素可能在这一列
                    i--;//向上查询
                else if(target>array[i][j])//target比m小，target元素可能在更大的列
                    j++;//向右查询
                else
                    return true;
            }
            return false;
        }
    
    
    }

## 2，替换空格 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 1][]

public class test2 {
        public static void main(String[] args) {
            String info="We Are Happy";
            String s = replaceSpace(info);
            System.out.println(s);
        }
        public static String replaceSpace (String s) {
            StringBuilder sb = new StringBuilder();
            for (char c : s.toCharArray()) {
                sb.append(c == ' ' ? "%20" : c);
            }
            return sb.toString();
        }
    }

### 3，从尾到头打印链表（三种解法） ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 2][]

package com.example.alipay.arithmetic;
    import java.util.ArrayList;
    import java.util.Collections;
    public class test3 {
      static  ArrayList<Integer>  list = new ArrayList();
    
        public static void main(String[] args) {
            ListNode list=new ListNode(67);
            list.add(0);
            list.add(24);
            list.add(58);
            list.printList();
            ArrayList<Integer> arrayList1 = printListFromTailToHead1(list);
            System.out.println("\n方法1：对list进行逆转后："+arrayList1);
            ArrayList<Integer> arrayList2 = printListFromTailToHead2(list);
            System.out.println("\n方法2：对list进行逆转后："+arrayList1);
            ArrayList<Integer> arrayList3 = printListFromTailToHead3(list);
            System.out.println("\n方法3：对list进行逆转后："+arrayList1);
        }
    
        /**
         * 把元素取出存到ArrayList中
         * 使用Collections的reverse方法，直接将list反转
         * 时间复杂度O(n)，空间复杂度O(n)
         * @param listNode
         * @return
         */
        public static ArrayList<Integer> printListFromTailToHead1(ListNode listNode) {
            ArrayList<Integer> list = new ArrayList<Integer>();
            while(listNode != null){
                list.add(listNode.var);
                listNode = listNode.next;
            }
            Collections.reverse(list);//使用Collections的reverse方法，直接将list反转
            return list;
        }
        /**
         * 把元素取出存到ArrayList中，使用add(index,value)方法，在指定位置插入元素
         * 利用栈先进后出的实现，将元素插入栈底0的位置
         * 取出的时候顺序取反
         * 时间复杂度O(n)，空间复杂度O(n)
         * @param listNode
         * @return
         */
        public static ArrayList<Integer> printListFromTailToHead2(ListNode listNode) {
            ArrayList<Integer> list = new ArrayList<Integer>();
            while(listNode != null){
                list.add(0,listNode.var);
                listNode = listNode.next;
            }
            return list;
        }
        /**
         * 利用方法递归的思想，递归整个方法，当到达最后一个元时向list集合中添加元素
         * 时间复杂度O(n)，空间复杂度O(n)
         * @param listNode
         * @return
         */
        public static ArrayList<Integer> printListFromTailToHead3(ListNode listNode) {
                if(listNode!=null){
                    printListFromTailToHead3(listNode.next);
                    list.add(listNode.var);
                }
                return list;
            }
        }
    
    /**
     * 自定义链表类
     */
    class ListNode{
        int var;//链表节点的值
        ListNode next=null;//链表节点的指针，指向下一个节点
        ListNode(int var){
            this.var=var;
        }
    
        public void add(int var) {
            ListNode newNode = new ListNode(var);//创建一一个新的链表节点
            if(this.next == null)//保证是最后一个节点
                this.next = newNode;//尾插法插入链表中
            else
                this.next.add(var);//如果不是最后一个节点，就递归遍历到最后一个节点
        }
        // 打印链表
        public void printList() {
            System.out.print(this.var);
            if(this.next != null)
            {
                System.out.print("-->");
                this.next.printList();
            }
        }
    
    }

### 4，重建二叉树（已知前序数组，中序数组，构建二叉树） ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 3][]

import com.xml.XmlParser;
    import org.junit.Test;
    import java.util.Arrays;
    
    public class Test1 {
        /**
         * 因为是树的结构，一般都是用递归来实现。
         * 用数学归纳法的思想就是，假设最后一步，就是root的左右子树都已经重建好了，那么我只要考虑将root的左右子树安上去即可。
         * 根据前序遍历的性质，第一个元素必然就是root，那么下面的工作就是如何确定root的左右子树的范围。
         * 根据中序遍历的性质，root元素前面都是root的左子树，后面都是root的右子树。那么我们只要找到中序遍历中root的位置，就可以确定好左右子树的范围。
         * 正如上面所说，只需要将确定的左右子树安到root上即可。递归要注意出口，假设最后只有一个元素了，那么就要返回。
         */
        class TreeNode {
              int val;
              TreeNode left;
              TreeNode right;
              TreeNode(int x) { val = x; }
         }
        public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
            //数组长度为0的时候要处理
            if(pre.length == 0)
                return null;
            int rootVal = pre[0];
            //数组长度仅为1的时候就要处理
            if(pre.length == 1)
                return new TreeNode(rootVal);
    
            //我们先找到root所在的位置，确定好前序和中序中左子树和右子树序列的范围
            TreeNode root = new TreeNode(rootVal);
            int rootIndex = 0;
            for(int i=0;i<in.length;i++){
                if(rootVal == in[i]){
                    rootIndex = i;
                    break;
                }
            }
    
            //递归，假设root的左右子树都已经构建完毕，那么只要将左右子树安到root左右即可
            //这里注意Arrays.copyOfRange(int[],start,end)是[)的区间
            root.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,rootIndex+1),Arrays.copyOfRange(in,0,rootIndex));
            root.right = reConstructBinaryTree(Arrays.copyOfRange(pre,rootIndex+1,pre.length),Arrays.copyOfRange(in,rootIndex+1,in.length));
    
            return root;
        }
    
    }

### 5，用两个栈实现队列 ###

题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

import java.util.Stack;
    
    public class Test1 {
        Stack<Integer> stack1 = new Stack<Integer>();
        Stack<Integer> stack2 = new Stack<Integer>();
    
        public void push(int node) {
            stack1.push(node);//队尾添加元素
        }
    
        public int pop() {
            if(stack1.empty()&&stack2.empty()){
                throw new RuntimeException("Queue is empty!");
            }
            if(stack2.empty()){//stack2为空
                while(!stack1.empty()){//stack1不为空
                    stack2.push(stack1.pop());//把stack1的所有元素放到stack2中
                }
            }
            return stack2.pop();
        }
    }

### 6，旋转数组的最小数字 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 4][]

public class Solution {
        public static void main(String[] args) {
            int []a=new int[]{3,4,5,6,1,2};
            System.out.println("min："+minNumberInRotateArray1(a));
            System.out.println("min："+minNumberInRotateArray2(a));
        }
    
        public static int minNumberInRotateArray1(int[] array) {
            if (array.length == 0)
                return 0;
            for (int i = 0; i < array.length - 1; i++) {
                if (array[i] > array[i + 1])
                    return array[i + 1];
            }
            return array[0];
        }
    
        public static int minNumberInRotateArray2(int [] array) {
            int low = 0 ; int high = array.length - 1;
            while(low < high){
                int mid = low + (high - low) / 2;
                if(array[mid] > array[high]){
                    low = mid + 1;
                }else if(array[mid] == array[high]){
                    high = high - 1;
                }else{
                    high = mid;
                }
            }
            return array[low];
        }
    }

### 7，斐波那契数列（已知前两项，从第三项开始，前两项之和为后一项） ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 5][]

import java.util.Scanner;
    
    public class Solution {
        public static void main(String[] args) {
            System.out.print("输入数字n:");
            Scanner sc=new Scanner(System.in);
            int n = sc.nextInt();
            for (int i=1;i<=n;i++){
                System.out.print(Fibonacci(i)+"   ");
            }
    
        }
        static int Fibonacci(int n) {
            int []F=new int[n+1];
            F[0] = 0;
            F[1] = 1;
            for(int i=2; i< n+1; i++) {//已知前两项，从第三项开始，前两项之和为后一项
                F[i] = F[i-2] + F[i-1];
            }
            return F[n];
        }
    
    
    }

### 8，跳台阶（斐波那契数列） ###

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

1   2   3   5   8   13   21   34   55   89，，，

import java.util.Scanner;
    
    public class Solution {
        public static void main(String[] args) {
            System.out.print("输入数字n:");
            Scanner sc=new Scanner(System.in);
            int n = sc.nextInt();
            for (int i=1;i<=n;i++){
                System.out.print(JumpFloor(i)+"   ");
            }
    
        }
    
            static int JumpFloor(int target) {
                if (target <= 1) {
                    return 1;
                }
                // a 表示第 f[i-2] 项，b 表示第 f[i-1] 项
                int a = 1, b = 1, c = 0;
                for (int i = 2; i <= target; i++) {
                    c = a + b; // f[i] = f[i - 1] + f[i - 2];
                    // 为下一次循环求 f[i + 1] 做准备
                    a = b; // f[i - 2] = f[i - 1]
                    b = c; // f[i - 1] = f[i]
                }
                return c;
            }
    
    }

### 9，跳台阶扩展问题 ###

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

*  因为n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级
 *  跳1级，剩下n-1级，则剩下跳法是f(n-1)
 *  跳2级，剩下n-2级，则剩下跳法是f(n-2)
 *  所以f(n)=f(n-1)+f(n-2)+...+f(1)
 *  因为f(n-1)=f(n-2)+f(n-3)+...+f(1)
 *  所以f(n)=2\*f(n-1)

import java.util.Scanner;
    
    public class Solution {
        public static void main(String[] args) {
            System.out.print("输入数字n:");
            Scanner sc=new Scanner(System.in);
            int n = sc.nextInt();
            for (int i=1;i<=n;i++){
                System.out.print(JumpFloor(i)+"   ");
            }
    
        }
    
            static int JumpFloor(int n) {
                    if (n==0 || n==1) return 1;
                    int a = 1, b=0;
                    for (int i=2; i<=n; ++i) {
                        b = a*2;
                        a = b;
                    }
                    return b;
            }
    
    }

### 10，矩形覆盖 ###

我们可以用2\*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2\*1的小矩形无重叠地覆盖一个2\*n的大矩形，总共有多少种方法？

比如n=3时，2\*3的矩形块有3种覆盖方法：

对于这种题没有思路怎么办？

那就对n 从小到大，一步步分析：

![548be7d2c324533c900508a102a3d662.png][]

n=1时，显然只有一种方法

![cb8a5e6e62f6601db9275f03d8f2387e.png][]

n=2时，如图有2种方法

![1146b3c2ccd42b4c36520c02708db245.png][]

n=3，如图有3中方法

# ![c659a61f9dab81b3c01912746e85a2e5.png][] #

n=4，如图有5中方法

观察：1,1,2,3,5，，，，

所以他是斐波那契数列

import java.util.Scanner;
    
    public class Solution {
        public static void main(String[] args) {
            System.out.print("输入数字n:");
            Scanner sc=new Scanner(System.in);
            int n = sc.nextInt();
            for (int i=1;i<=n;i++){
                System.out.print(rectCover(i)+"   ");
            }
        }
        static int rectCover(int n) {
            int []F=new int[n+1];
            F[0] = 1;
            F[1] = 1;
            for(int i=2; i< n+1; i++) {//已知前两项，从第三项开始，前两项之和为后一项
                F[i] = F[i-2] + F[i-1];
                //f[2]=1+1
                //f[3]=1+2
                //f[4]=2+3
            }
            return F[n];
        }
        
    }

### 11，二进制中1的个数 ###

输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。

*  问题1: 如何从十进制数转化到二进制数？
 *  问题2:转化为二进制数后，如果判断有`1`的个数？

import java.util.Scanner;
    
    public class Solution {
        public static void main(String[] args) {
            System.out.print("输入数字n:");
            Scanner sc=new Scanner(System.in);
            int n = sc.nextInt();
            System.out.println(n+"的二进制个数是："+NumberOf1(n));
    
        }
        static int NumberOf1(int val) {
            int ans = 0;
            while (val != 0) {
                int tmp = val % 2;
                if (tmp == 1) ++ans;
                val /= 2;
            }
            return ans;
        }
    
    }

### 12，数值的整数次方（这里提供暴力解） ###

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为0

import java.util.Scanner;
    
    public class Solution {
        public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            System.out.print("输入基数base:");
            int base = sc.nextInt();
            System.out.print("输入指数exponent:");
            int exponent=sc.nextInt();
            System.out.println(base+"的"+exponent+"次方为："+Power(base,exponent));
    
        }
            static double Power(double base, int exponent) {
                if (base == 0.0){
                    return 0.0;
                }
                // 前置结果设为1.0，即当exponent=0 的时候，就是这个结果
                double result = 1.0d;
                // 获取指数的绝对值
                int e = exponent > 0 ? exponent : -exponent;
                // 根据指数大小，循环累乘
                for(int i = 1 ; i <= e; i ++){
                    result *= base;
                }
                // 根据指数正负，返回结果
                return exponent > 0 ? result : 1 / result;
            }
    
    }

### 13，跳转数组的顺序使得奇数在偶数的前面（使用直接插入排序算法实现） ###

解法：寻找奇数，如果该数字是奇数，将数字后的元素后移一位，插入元素

例如：1,2,3,4——》1,3,2,4

import java.util.Scanner;
    
    public class Solution {
        public static void main(String[] args) {
            int []a=new int[]{1,2,3,4};
            reOrderArray(a);
            for (int number:a){
                System.out.print(number+"  ");
            }
        }
            static int[] reOrderArray (int[] array) {
                if(array==null||array.length==0) return array;
                int j=0;//记录已经是奇数的位置
                int temp = 0;
                for(int i =0;i<array.length;i++){
                    temp = array[i];
                    if(array[i]%2==0){
                        continue;
                    }else{
                        int k =i;
                        while(k>j){
                            array[k] = array[k-1];//这区间整体向后移动一位
                            k--;
                        }
                        array[k] = temp;
                        j++;
                    }
                }
                return array;
            }
    
    
    }

### 13，链表中到倒数第k个节点 ###

输入一个链表，输出该链表中倒数第k个结点。如果该链表长度小于k，请返回空。

import java.util.Scanner;
    
    class ListNode {
        int val;
        ListNode next = null;
        public ListNode(int val) {
            this.val = val;
        }
    
        public ListNode addNode(int val,ListNode list){
            while (list.next!=null){
                list=list.next;//遍历到尾结点
            }
            ListNode node=new ListNode(val);//创建新节点
            list.next=node;//将新节点插入链表
            return list;
        }
    
        public void showList(ListNode list){
    
            while (list.next!=null){
                System.out.print(list.val+"  ");
                list=list.next;
            }
        }
        public ListNode FindKthToTail (ListNode pHead, int k) {
            // write code here
            ListNode first = pHead;
            for(int  i= 0;i<k;i++){
                if(first == null) return first;
                first = first.next;
            }
            ListNode last = pHead;
            while(first!=null){
                first = first.next;
                last = last.next;
            }
            return last;
        }
    
    }
    
    public class Solution {
        public static void main(String[] args) {
            ListNode list=new ListNode(1);
            for (int i=2;i<=10;i++){
                list.addNode(i,list);//添加元素
            }
            list.showList(list);//显示链表
            System.out.print("输入数字k:");
            Scanner scanner=new Scanner(System.in);
            int k = scanner.nextInt();
            System.out.print("list链表中的倒数第"+k+"个元素是："+list.FindKthToTail(list,k).val);
    
    
        }
    }

### 14，反转链表 ###

package com.deme_security;
    
    
    import java.util.List;
    import java.util.Stack;
    
    class ListNode {
        int val;
        ListNode next = null;
    
        ListNode(int val) {
            this.val = val;
        }
        static ListNode add(int val,ListNode head){
            ListNode node=new ListNode(val);
            while (head.next!=null){
                head=head.next;
            }
            head.next=node;
            return head;
        }
    }
    
    public class Solution {
        public static void main(String[] args) {
            ListNode list =new ListNode(1);
            ListNode.add(2,list);
            ListNode.add(3,list);
            list = ReverseList(list);
            int k=0;
            while (list!=null){
                System.out.print(list.val+ "  ");
                list=list.next;
                k++;
                if (k==6){
                    return;
                }
            }
        }
            public static ListNode ReverseList(ListNode head) {
                Stack<ListNode> stack= new Stack<>();
                //把链表节点全部摘掉放到栈中
                while (head != null) {
                    stack.push(head);
                    head = head.next;
                }
                if (stack.isEmpty())
                    return null;
                ListNode node = stack.pop();
                ListNode dummy = node;
                //栈中的结点全部出栈，然后重新连成一个新的链表
                while (!stack.isEmpty()) {
                    ListNode tempNode = stack.pop();
                    node.next = tempNode;
                    node = node.next;
                }
                //最后一个结点就是反转前的头结点，一定要让他的next
                //等于空，否则会构成环
                node.next = null;
                return dummy;
            }
    
    }

### 15，输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 6][]

package com.deme_security;
    
    import java.util.Stack;
    
    class ListNode {
        int val;
        ListNode next = null;
        ListNode(int val) {
            this.val = val;
        }
        static ListNode add(int val,ListNode head){
            ListNode node=new ListNode(val);
            while (head.next!=null){
                head=head.next;
            }
            head.next=node;
            return head;
        }
        static void show(ListNode list){
            while (list!=null){
                System.out.print(list.val+ "  ");
                list=list.next;
            }
            System.out.println();
        }
    }
    
    public class Solution {
        public static void main(String[] args) {
            ListNode list1 =new ListNode(1);
            ListNode.add(3,list1);
            ListNode.add(5,list1);
            ListNode.add(10,list1);
            ListNode.add(11,list1);
    
    
            ListNode list2 =new ListNode(2);
            ListNode.add(4,list2);
            ListNode.add(6,list2);
            ListNode.add(7,list2);
    
            ListNode.show(list1);
            ListNode.show(list2);
            ListNode merge = Merge(list1, list2);
            while (merge!=null){
                if (merge.val!=-1){
                    System.out.print(merge.val+"  ");
                }
                merge=merge.next;
            }
    
        }
    
        public static ListNode Merge(ListNode list1,ListNode list2) {
            ListNode p=new ListNode(-1);//带头结点链表
            ListNode head=p;
            while (list1!=null&&list2!=null){//从两个链表中取出最小的节点插入
                if (list1.val<=list2.val){
                    p.next=list1;
                    p=p.next;
                    list1=list1.next;
                }
                else {
                    p.next=list2;
                    p=p.next;
                    list2=list2.next;
                }
            }
            if (list1==null){//找到没有遍历完的链表接入
                p.next=list2;
            }else {
                p.next=list1;
            }
            return head;
        }
    
    }

### 16，判断树的子结构(不会） ###

用递归来实现，从A树的根节点开始，判断其所有的节点是不是依次和树B相同，如不同，递归调用函数，继续判断树A当前节点的左子树的所有节点或右子树的所有节点是否和树B所有节点相同，直到遍历到父树A的叶子节点，如果不是完全相同，则树B不是树A子树，如果直到遍历到树B的叶子节点，其所有节点在树A中均有，则树B是树A的子树。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 7][]

/**
    public class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;
        public TreeNode(int val) {
            this.val = val;
        }
    }
    */
    public class Solution {
        public boolean HasSubtree(TreeNode root1,TreeNode root2) {
            if(root1==null||root2==null){
                return false;
            }
            return isSubtree(root1,root2)||HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);
        }
        
        public boolean isSubtree(TreeNode root1,TreeNode root2){
            if(root2==null){
                return true;
            }
            if(root1==null){
                return false;
            }
            if(root1.val==root2.val){
                return isSubtree(root1.left,root2.left)&&isSubtree(root1.right,root2.right);
            }
            return false;
        }
    }

### 17，二叉树镜像： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 8][]

public class Solution {
        /**
         * 先遍历二叉树，交换它的左右孩子，分别对孩子节点进行递归遍历
         *
         * 
         * @param pRoot TreeNode类 
         * @return TreeNode类
         */
        public TreeNode Mirror (TreeNode pRoot) {
            // write code here
            if(pRoot == null) return pRoot;
            TreeNode temp= pRoot.left;
            pRoot.left = pRoot.right;
            pRoot.right = temp;
            Mirror(pRoot.left);
            Mirror(pRoot.right);
            return pRoot;
        }
    }

### 17，顺时针打印矩阵 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 9][]

package com.deme_security;
    
    import java.util.ArrayList;
    
    public class Solution {
        public ArrayList<Integer> printMatrix(int [][] matrix) {
    
            ArrayList<Integer> result = new ArrayList<>();
            if(matrix == null)return result;
    
            int low = 0;
            int high = matrix.length-1;
            int left = 0;
            int right = matrix[0].length-1;
            while(low <= high && left <= right){
    
                //向右
                for(int i=left; i <= right; i++)
                    result.add(matrix[low][i]);
    
                //向下
                for(int i = low+1; i <= high; i++)
                    result.add(matrix[i][right]);
    
                //向左 有可能出现特殊的情况只有一行，为了避免重复访问
                if(low < high){
                    for(int i= right-1; i >= left; i--)
                        result.add(matrix[high][i]);
                }
    
                //向上 有可能出现特殊的情况只有一列，为了避免重复访问
                if(left < right){
                    for(int i = high-1; i >= low+1; i--)
                        result.add(matrix[i][left]);
                }
    
                low++;
                high--;
                left++;
                right--;
            }
            return result;
        }
    }

### 18，包含min函数的栈 ###

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

思路：

每入栈一次，就与辅助栈顶比较大小，如果小就入栈，如果大就入栈当前的辅助栈顶，当出栈时，辅助栈也要出栈，这种做法可以保证辅助栈顶一定都当前栈的最小值

import java.util.Stack;
    
    思路：用一个栈data保存数据，用另外一个栈min保存依次入栈最小的数
    比如，data中依次入栈，5,  4,  3, 8, 10, 11, 12, 1
           则min依次入栈，5,  4,  3，no,no, no, no, 1
    
    no代表此次不如栈
    每次入栈的时候，如果入栈的元素比min中的栈顶元素小或等于则入栈，否则不如栈。
    
    public class Solution {
    	Stack<Integer> data = new Stack<Integer>();
        Stack<Integer> min = new Stack<Integer>();
        Integer temp = null;
        public void push(int node) {
            if(temp != null){
                if(node <= temp ){
                    temp = node;
                    min.push(node);
                }
                data.push(node);
            }else{
                temp = node;
                data.push(node);
                min.push(node);
            }
        }
        
        public void pop() {
            int num = data.pop();
            int num2 = min.pop();
            if(num != num2){
               min.push(num2); 
            }
        }
        
        public int top() {
            int num = data.pop();
            data.push(num);
            return num;
        }
        
        public int min() {
            int num = min.pop();
            min.push(num);
            return num;
        }
    }

### 21，栈的压入，弹出序列 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 10][]

思路：借用一个辅助的栈，遍历压栈顺序，先讲第一个放入栈中，这里是1，然后判断栈顶元素是不是出栈顺序的第一个元素，这里是4，很显然1≠4，所以我们继续压栈，直到相等以后开始出栈，出栈一个元素，则将出栈顺序向后移动一位，直到不相等，这样循环等压栈顺序遍历完成，如果辅助栈还不为空，说明弹出序列不是该栈的弹出顺序

package com.deme_security;
    
    import java.util.ArrayList;
    import java.util.Stack;
    public class Solution {
        public static void main(String[] args) {
            int []a={1,2,3,4,5,6};
            int []b={6,5,4,3,2,1};
            Solution s=new Solution();
            System.out.println(s.IsPopOrder(a,b));
        }
        public boolean IsPopOrder(int [] pushA,int [] popA) {
            if(pushA.length == 0 || popA.length == 0)
                return false;
            Stack<Integer> s = new Stack<Integer>();//辅助栈
            //用于标识弹出序列的位置
            int popIndex = 0;
            for(int i = 0; i< pushA.length;i++){
                s.push(pushA[i]);//将元素压入辅助栈
                //如果输入栈不为空，且目标栈顶元素等于要弹出的元素，说明元素对应起来了
                while(!s.empty() &&s.peek() == popA[popIndex]){
                    //输入栈的元素出栈
                    s.pop();
                    //辅助栈序列索引向后移动一位
                    popIndex++;//
                }
            }
            return s.empty();
        }
    }

### 22，二叉树的层次遍历，中序遍历 ###

层次遍历：

1.  思路：借助队列，根节点入队，出队加入list中
2.  并判断它左孩子存在吗，存在就入队，右孩子存在吗，存在入队。
3.  继续出队队头元素，继续步骤2

package com.deme_security;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.Queue;
    
    class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;
    
        public TreeNode(int val) {
            this.val = val;
        }
    
        TreeNode add(TreeNode root, int val) {
            TreeNode p = root;
            TreeNode insertParent=root;//记录插入节点的父节点
            TreeNode node = new TreeNode(val);
            while (p != null) {
                insertParent=p;//记录插入节点的父节点
                if (p.val > node.val) {//如果插入节点的值小
                    p = p.left;//去左孩子节点
                } else if (p.val < node.val) {
                    p = p.right;//去右孩子
                }
            }
            if (insertParent.val > node.val) {
                insertParent.left = node;
            } else {
                insertParent.right = node;
            }
            return root;
        }
    
    
        void show(TreeNode root) {
            if (root==null){
                return;
            }
            Queue<TreeNode> queue = new LinkedList<>();//辅助
            ArrayList<TreeNode> list =new ArrayList<>();//存储遍历出来的节点
            TreeNode node;
            queue.add(root);//根节点入队
            while (!queue.isEmpty()) {
                node=queue.peek();//头结点出队
                queue.poll();
                list.add(node);//加入list中
                if (node.left!=null){
                    queue.add(node.left);//做孩子入队
                }
                if (node.right!=null){
                    queue.add(node.right);//右孩子入队
                }
            }
            for (TreeNode n: list){
                System.out.print(n.val+"  ");
            }
            return;
        }
        /**
         * 中序遍历：
         * @param root
         */
        void PreOrder(TreeNode root) {
            if (root!= null) {
                PreOrder(root.left);
                System.out.print(root.val+"  ");
                PreOrder(root.right);
            }
        }
    }
    /*
    每一次打印一个节点的时候，如果该节点有子节点，则把该节点的子节点放到一个队列的尾部。
    接下来到对队列的头部取出最早进入队列的节点放到ArrayList 中，
    重复前面的操作，直至队列中所有的节点都存到ArrayList中。
            8
         2     10
       1   6
       中序遍历：1,2,6,8,10
       层次遍历：8,2,10,1,6
    
     */
    public class Solution {
        public static void main(String[] args) {
            TreeNode root= new TreeNode(8);
            root.add(root,2);
            root.add(root,10);
            root.add(root,1);
            root.add(root,6);
            root.PreOrder(root);
            System.out.println();
            root.show(root);
        }
    
    }

### 23，二叉树的后序遍历序列 ###

**思路：后序遍历 的序列中，最后一个数字是树的根节点 ，数组中前面的数字可以分为两部分：第一部分是左子树节点 的值，都比根节点的值小；第二部分 是右子树 节点的值，都比 根 节点 的值大，后面用递归分别判断前后两部分 是否 符合以上原则**

package Exam;
    
    //思路：找住二叉查找树的特点：左子树<根<=右子树  使用分治思想
    public class Solution {
        public static void main(String[] args) {
            int a[]={2,4,3,6,8,7,5};
            Solution solution=new Solution();
            System.out.println( solution.VerifySquenceOfBST(a));
        }
        public boolean VerifySquenceOfBST(int [] sequence) {
            if(sequence.length == 0){
                return false;
            }
            if(sequence.length == 1){
                return true;
            }
            return judge(sequence,0,sequence.length-1);
        }
        /*
                  5
               3     7
             2   4  6   8
    
    后序遍历：2,4,3,6,8,7,5
         */
    
        public boolean judge(int[] a,int start,int end){
            if(start >= end){//递归结束
                return true;
            }
            int i = start;
            while(a[i] < a[end]){//后序遍历：2,4,3,7,8,6,5
                ++i;//找到左孩子节点，//先找到3
            }
            for(int j=i;j<end;j++){//7,8,6显然不满足
                if(a[j] < a[end]){//如果右孩子节点中有比父节点小的，说明不是后序遍历
                    return false;
                }
            }
            //判断2,4,3和7,8,6满足条件吗
            return judge(a,start,i-1) && judge(a,i,end-1);//递归遍历左右孩子
        }
    }

### 24，二叉树中和为某一值的路径 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 11][]

public class Solution {
        private ArrayList<ArrayList<Integer>> listAll = new ArrayList<ArrayList<Integer>>();//路径的集合
        private ArrayList<Integer> list = new ArrayList<Integer>();//记录路径
        
        public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {//参数是树的各节点，目标值
    
            if(root == null) return listAll;//根节点为null直接返回
            list.add(root.val);//将节点加入list（路径）
            target -= root.val;//目标值与节点值想减
            if(target == 0 && root.left == null && root.right == null) //如果目标值为0，且该节点是叶节点，满足要求
                listAll.add(new ArrayList<Integer>(list));//将该路径
            FindPath(root.left, target);//递归遍历左子树
            FindPath(root.right, target);//递归遍历右子树
            list.remove(list.size()-1);//如果遍历到左叶节点了，不满足要求，需要将该叶节点去除。遍历右叶节点
            return listAll;
        }
    }

### 25，复杂链表的复制 ###

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

思路：

1.  遍历链表，将每个节点A进行复制得到节点A'，将复制后的节点插到原来节点的后面
2.  遍历链表，完成特殊指针的指向复制，A指向D，A'就要指向D的后一个节点D'
3.  将链表进行拆开。

![20210513165304711.png][]

![2021051316532191.png][]

![20210513165336413.png][]

/*
    *解题思路：
    *1、遍历链表，复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
    *2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
    *3、拆分链表，将链表拆分为原链表和复制后的链表
    */
    public class Solution {
        public RandomListNode Clone(RandomListNode pHead) {
            if(pHead == null) {
                return null;
            }
            
            RandomListNode currentNode = pHead;
            //1、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
            while(currentNode != null){	
                RandomListNode cloneNode = new RandomListNode(currentNode.label);
                RandomListNode nextNode = currentNode.next;
                currentNode.next = cloneNode;
                cloneNode.next = nextNode;
                currentNode = nextNode;
            }
            
            currentNode = pHead;
            //2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
            while(currentNode != null) {
                currentNode.next.random = currentNode.random==null?null:currentNode.random.next;
                currentNode = currentNode.next.next;
            }
            
            //3、拆分链表，将链表拆分为原链表和复制后的链表
            currentNode = pHead;
            RandomListNode pCloneHead = pHead.next;
            while(currentNode != null) {
                RandomListNode cloneNode = currentNode.next;
                currentNode.next = cloneNode.next;
                cloneNode.next = cloneNode.next==null?null:cloneNode.next.next;
                currentNode = currentNode.next;
            }
            
            return pCloneHead;
        }
    }

### 26，二叉搜索树与双向链表 ###

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

思路：使用递归方法实现对树的中序遍历，按照中序遍历，将整个树分解成了无数的小树，然后将他们分别转化成了一小段一小段的双向链表。再利用pLast记录总的链表的末尾，然后将这些小段链表一个接一个地加到末尾。

private TreeNode pLast = null;
    public TreeNode Convert(TreeNode root) {
     if (root == null)
         return null;
    
     // 如果左子树为空，那么根节点root为双向链表的头节点
     TreeNode head = Convert(root.left);
     if (head == null)
         head = root;
    
     // 连接当前节点root和当前链表的尾节点pLast
     root.left = pLast;
     if (pLast != null)
         pLast.right = root;
     pLast = root;
    
     Convert(root.right);
    
     return head;
    }

### 27，字符串排列（回溯法解，不会） ###

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

（输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。）

思路：

![63076701d65ddb3315d11a30204fc350.png][]

import java.util.ArrayList;
    public class Solution {
    
        public ArrayList<String> PermutationHelp(StringBuilder str){
             ArrayList<String> result = new  ArrayList<String>();
            if(str.length() == 1)result.add(str.toString());
            else{
                for(int i = 0; i < str.length(); i++){
                    if(i== 0  || str.charAt(i) != str.charAt(0)){
                        char temp = str.charAt(i);
                        str.setCharAt(i, str.charAt(0));
                        str.setCharAt(0, temp);
                        ArrayList<String> newResult = PermutationHelp(new StringBuilder(str.substring(1)));
                        for(int j =0; j < newResult.size(); j++)
                            result.add(str.substring(0,1)+newResult.get(j));
                        //用完还是要放回去的
                        temp = str.charAt(0);
                        str.setCharAt(0, str.charAt(i));
                        str.setCharAt(i, temp);
                    }
                }
                //需要在做一个排序操作
    
            }
            return result;
        }
    
        public ArrayList<String> Permutation(String str) {
            StringBuilder strBuilder = new StringBuilder(str);
            ArrayList<String> result = PermutationHelp(strBuilder);
            return result;
        }
    }

### 27，数组中出现次数超过一半的数字 ###

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组\[1,2,3,2,2,2,5,4,2\]。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。你可以假设数组是非空的，并且给定的数组总是存在多数元素。1<=数组长度<=50000

思路：用hashMap来解

import java.util.*;
    
    public class Solution {
        public int MoreThanHalfNum_Solution(int [] array) {
            if(array.length == 0){
                return 0;
            }
    
            int len = array.length;
            int threshold = len/2;
            Map<Integer,Integer> map = new HashMap<>();
            for(int i = 0; i < len; i++){
                if(!map.keySet().contains(array[i])){
                    map.put(array[i],1);
                }else{
                    map.put(array[i],map.get(array[i])+1);
                }
            }
    
            for(Integer key: map.keySet()){
                if(map.get(key) > threshold){
                    return key;
                }
            }
    
            return 0;
        }
    }

### 28，最小的K个数 ###

给定一个数组，找出其中最小的K个数。例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。如果K>数组的长度，那么返回一个空的数组

思路：对于n个整数中最小的K个数的查找，可以使用各种排序算法：冒泡/堆排/快排/希尔排序等等。将此n个整数从小到大排序之后，前k个数就是所求的结果。但是当原数组中的数据顺序不可修改，并且n的值过于大的时候，各种排序算法要将n个数加载到内存中，即：如果是海量数据中查找出最小的k个数，那么这种办法是效率很低的。

**接下来介绍另外一种算法：**  
创建一个大小为k的数组，遍历n个整数，如果遍历到的数小于大小为k的数组的最大值，则将此数与其最大值替换。

由于每次都要拿n个整数和数组中的最大值比较，所以选择大根堆这一数据结构(大家要分清楚大根堆这一数据结构和堆排序之间的区别：堆排序是在大根堆这一数据结构上进行排序的一种排序算法，一个是数据结构，一个是算法)

public class Solution {
        public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
            ArrayList<Integer> list = new ArrayList<>();
            if (input == null || input.length == 0 || k > input.length || k == 0)
                return list;
            int[] arr = new int[k + 1];//数组下标0的位置作为哨兵，不存储数据
            //初始化数组
            for (int i = 1; i < k + 1; i++)
                arr[i] = input[i - 1];
            buildMaxHeap(arr, k + 1);//构造大根堆
            for (int i = k; i < input.length; i++) {
                if (input[i] < arr[1]) {
                    arr[1] = input[i];
                    adjustDown(arr, 1, k + 1);//将改变了根节点的二叉树继续调整为大根堆
                }
            }
            for (int i = 1; i < arr.length; i++) {
                list.add(arr[i]);
            }
            return list;
        }
         /**
         * @Author: ZwZ
         * @Description: 构造大根堆 
         * @Param: [arr, length]  length:数组长度 作为是否跳出循环的条件
         * @return: void 
         * @Date: 2020/1/30-22:06
         */
        public void buildMaxHeap(int[] arr, int length) {
            if (arr == null || arr.length == 0 || arr.length == 1)
                return;
            for (int i = (length - 1) / 2; i > 0; i--) {
                adjustDown(arr, i, arr.length);
            }
        }
        /**
         * @Description: 堆排序中对一个子二叉树进行堆排序 
         * @Param: [arr, k, length] 
         * @return:  
         * @Date: 2020/1/30-21:55
         */
        public void adjustDown(int[] arr, int k, int length) {
            arr[0] = arr[k];//哨兵
            for (int i = 2 * k; i <= length; i *= 2) {
                if (i < length - 1 && arr[i] < arr[i + 1])
                    i++;//取k较大的子结点的下标
                if (i > length - 1 || arr[0] >= arr[i])
                    break;
                else {
                    arr[k] = arr[i];
                    k = i; //向下筛选
                }
            }
            arr[k] = arr[0];
        }
    }

### 29，连续子数组的最大和 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 12][]

思路：典型的动态规划。dp\[n\]代表以当前元素为截止点的连续子序列的最大和，如果dp\[n-1\]>0，dp\[n\]=dp\[n\]+dp\[n-1\]，因为当前数字加上一个正数一定会变大；如果dp\[n-1\]<0，dp\[n\]不变，因为当前数字加上一个负数一定会变小。使用一个变量max记录最大的dp值返回即可。

public int FindGreatestSumOfSubArray(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            array[i] += array[i - 1] > 0 ? array[i - 1] : 0;
            max = Math.max(max, array[i]);
        }
        return max;
    }

### 30，整数中1出现的次数（从1到n整数中1出现的次数） ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 13][]

思路：每次对10取模，然后判断个位数是否为1，当n位数大时，时间复杂度也比较高.也可以把数字转成字符串，判断1的个数

public class Solution {
        public int NumberOf1Between1AndN_Solution(int n) {
            int count = 0;
            for(int i = 0; i <= n; i++) {
                String str = String.valueOf(i);
                for(int j = 0; j < str.length(); j++) {
                    if(str.charAt(j) == '1')
                        count++;
                }
            }
            return count;
        }
    }
    public class Solution {
        public int NumberOf1Between1AndN_Solution(int n) {
            //count表示1出现的总次数
            int count = 0;
            //从1到n循环n次，对每一个数求它包含多少个1
            for (int i = 1; i <= n; i++) {
                int temp = i;
                //求这个数包含多少个1
                while (temp != 0) {   
                    if (temp % 10 == 1) {
                        count++;
                    }
                    temp = temp / 10;
                }
            }
            return count;
        }
    }

### 31，把数组排成最小的数 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 14][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70]: /images/20221022/ff5d3aa5a1e743d68cb85dd2f58c4daf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 1]: /images/20221022/8f8da7e89fc5433b8af0154c36379122.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 2]: /images/20221022/a16b3e226faf4d2a9d22499dc10741f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 3]: /images/20221022/79d992edb0334182b352a9042a2b9660.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 4]: /images/20221022/4f6551ba494944d0a14c253183cc674c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 5]: /images/20221022/878c5532892e43b6b3b824dcfc595b23.png
[548be7d2c324533c900508a102a3d662.png]: /images/20221022/06793d8aff8741da976e7b9957e881fb.png
[cb8a5e6e62f6601db9275f03d8f2387e.png]: /images/20221022/f8a6067828ce48ef96a12bf9cacbda2a.png
[1146b3c2ccd42b4c36520c02708db245.png]: /images/20221022/742e5e4a69d943a1b734fdc646eef08d.png
[c659a61f9dab81b3c01912746e85a2e5.png]: /images/20221022/28baf7772be743d9a4047bd16c599813.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 6]: /images/20221022/2707392826914139bc2034c1ddcc6b64.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 7]: /images/20221022/235683fe742d484ebe48028427e19812.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 8]: /images/20221022/9577dfa0222e48488aac58f5f88ae423.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 9]: /images/20221022/9d81c749045348b0810bb6a20ece619f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 10]: /images/20221022/19762880d198480bb9dd101509582807.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 11]: /images/20221022/0b28e8c0e8a446e3a2aabb920092bc75.png
[20210513165304711.png]: /images/20221022/24942dee0a9045e0801282d8bd5a3032.png
[2021051316532191.png]: /images/20221022/d3f94ebdbfd34731b0d67429b6d6cc82.png
[20210513165336413.png]: /images/20221022/36216c5010d8458cbfb89f114edf20fd.png
[63076701d65ddb3315d11a30204fc350.png]: /images/20221022/57d06195bc9740b49f878d9ca74029aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 12]: /images/20221022/b1dcae361a8149209bfa1841a8458af6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 13]: /images/20221022/a8bc41b8ded44d7d9b0fed17cdfe12f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg0MTMxMg_size_16_color_FFFFFF_t_70 14]: /images/20221022/c171f60a5ce24fd690462391edfd6fec.png