剑指Offer行榜【牛客网】练习（四）

1、合并两个排序链表

题目描述：
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思路：
两个指针依次比较两个链表中的值，选择小的值链接，将这个指针向后移动一位，继续比较。当一个指针到末尾时就停止，把另外一个链表剩余的链接。

代码：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        ListNode root = new ListNode(0);
        ListNode r = root;
        ListNode pointer1 = list1;
        ListNode pointer2 = list2;
        if(list1.val<=list2.val){
            root.val = list1.val;
            pointer1 = pointer1.next;
        }else{
            root.val = list2.val;
            pointer2 = pointer2.next;
        }
        while(pointer1!=null&&pointer2!=null){
            if(pointer1.val<=pointer2.val){
                r.next = new ListNode(pointer1.val);
                pointer1 = pointer1.next;
            }else{
                r.next = new ListNode(pointer2.val);
                pointer2 = pointer2.next;
            }
            r = r.next;
        }
        while(pointer1!=null){
            r.next = new ListNode(pointer1.val);
            pointer1 = pointer1.next;
            r = r.next;
        }
        while(pointer2!=null){
            r.next = new ListNode(pointer2.val);
            pointer2 = pointer2.next;
            r = r.next;
        }

        return root;
    }
}

2、树的子结构

题目描述：
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

思路：
使用两个递归：
1、B是A的子树，或者B是A的左结点的子树，或者B是A的右结点的子树。
2、是子树，则判断当前结点相同，当前结点的左部分相同，当前结点的右部分相同。

注意点：
判断子树时，B的子节点为null先判断，若为null，则是子树。（A可能还有多余结点）

代码：

/**
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 static 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);
        }else{
            return false;
        }
    }
}

3、二叉树镜像

题目描述：
操作给定的二叉树，将其变换为源二叉树的镜像。

思路：
使用递归，把根的子树镜像。

代码：

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public void Mirror(TreeNode root) {
        if(root==null){
            return;
        }
        TreeNode leftNode = root.left;
        TreeNode rightNode = root.right;
        root.left = rightNode;
        root.right = leftNode;
        Mirror(leftNode);
        Mirror(rightNode);
    }
}

4、顺时针打印矩阵

题目描述：
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路：
把打印一圈写成一个函数，循环调用这个函数即可。

代码：

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> result = new ArrayList<>();
        int i=0;
        int width = matrix[0].length;
        int height = matrix.length;
        while(i<=matrix.length/2&&width!=0&&height!=0){
            result.addAll(printCircle(i,width,height,matrix));
            i++;
            width-=2;
            height-=2;
        }
        return result;
    }
    
    public static ArrayList<Integer> printCircle(int i,int width, int height, int[][] matrix){
        ArrayList<Integer> result = new ArrayList<>();
        int lineStart = (matrix[0].length-width)/2;
        for(int j = lineStart;j<lineStart+width;j++){
            result.add(matrix[i][j]);
        }
        if(height>1){
            if(lineStart+width-1>=0){
                for(int j=i+1;j<i+height;j++){
                    result.add(matrix[j][lineStart+width-1]);
                }
            }
            if(width>1){
                for(int j=lineStart+width-2;j>=lineStart;j--){
                    result.add(matrix[i+height-1][j]);
                }
                for(int j=i+height-2;j>i;j--){
                    result.add(matrix[j][lineStart]);
                }
            }
        }
        
        return result;
    }
}

5、包含min函数的栈

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

思路：
把元素取出来放入ArrayList，再放回，找最小

代码：

import java.util.Stack;
import java.util.Collections;
import java.util.ArrayList;
public class Solution {
    
    private Stack<Integer> stack = new Stack<>();
    
    public void push(int node) {
        stack.push(node);
    }
    
    public void pop() {
        stack.pop();
    }
    
    public int top() {
        int result = stack.pop();
        stack.add(result);
        return result;
    }
    
    public int min() {
        ArrayList<Integer> copy = new ArrayList<>();
        while(!stack.empty()){
            copy.add(stack.pop());
        }
        for(int i=copy.size()-1;i>=0;i--){
            stack.push(copy.get(i));
        }
        Collections.sort(copy);
        return copy.get(0);
    }
}