[Java实现]剑指offer16-20_day4

16.合并两个排序链表

题目描述

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

思路一:非递归

package com.matajie;

/**
 * 16.合并两个排序链表
 * 题目描述
 * 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
 *
 * 我的程序才不会有bug！
 * author:年仅18岁的天才少年程序员丶mata杰
 **/
public class Merge {
    public class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode Merge(ListNode list1,ListNode list2) {
     ListNode result = null;
     ListNode cur1 = list1;
     ListNode cur2 = list2;
     ListNode last = null;
     //如果有一个为空,返回另一个即可
     if(list1 == null)return list2;
     if(list2 == null)return list1;
     while (cur1 != null && cur2 != null){
         if(cur1.val <= cur2.val){
             //将1尾插到result上.
             ListNode next = cur1.next;
             if(result == null){
            result = cur1;
             }else {
                last.next = cur1;
             }
             last = cur1;
             cur1 = next;
         }else {
             //将2尾插到result上.过程同1.
             ListNode next = cur2.next;
             if(result == null){
                 result = cur2;
             }else {
                 last.next = cur2;
             }
             last = cur2;
             cur2 = next;
         }
     }
     //循环结束,其中一个不为空,直接尾插到result上.
     if (cur1 == null) last.next = cur2;
     if (cur2 == null) last.next = cur1;
     return result;
    }
}

思路2:递归

package com.matajie;

/**
 * 16.合并两个排序链表
 * 题目描述
 * 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
 *
 * 我的程序才不会有bug！
 * author:年仅18岁的天才少年程序员丶mata杰
 **/
public class Merge {
    public class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode Merge(ListNode list1,ListNode list2) {
    if(list1 == null)return list2;
    if(list2 == null)return list1;
    if (list1.val < list2.val){
        list1.next = Merge(list1.next,list2);
        return list1;
    }else {
        list2.next = Merge(list1,list2.next);
        return list2;
    }
    }
}

17.树的子结构

题目描述

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

思路一:

package com.matajie;

/**
 * 17.树的子结构
 * 题目描述
 * 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
 *
 * 我的程序才不会有bug！
 * author:年仅18岁的天才少年程序员丶mata杰
 **/
public class HasSubtree {
    public class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

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

        }

    }
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        boolean result = false;
        //当Tree1和Tree2都不为零时,才进行比较,否则直接返回false.
        if (root1 != null && root2 != null){
            //如果找到了对应Tree2的根节点的点
            if(root2.val == root1.val){//以这个根节点为起点判断是否包含Tree2
                result = deseTree1HaveTree2(root1,root2);
            }
            if(!result){//如果找不到那么就再去root的左孩子当做起点,去判断是否包含Tree2.
                result = HasSubtree(root1.left,root2);
            }
            if(!result){//如果还找不到那么就再去root的右孩子当做起点,去判断是否包含Tree2.
                result = HasSubtree(root1.right,root2);
        }
    }
    return result;
}
public boolean deseTree1HaveTree2(TreeNode node1,TreeNode node2){
        if(node2 == null){//Tree2遍历完了都能对应的上,返回true;
            return true;
        }
        if(node1 == null){//Tree2还没有变荔湾,Tree1却遍历完了,返回fasle
            return false;
        }
        if(node1.val != node2.val){//不匹配,返回false
            return false;
        }
        //如果根节点对应的上,那么就分别去子节点匹配
        return deseTree1HaveTree2(node1.left,node2.left)
        && deseTree1HaveTree2(node1.right,node2.right);
}
}

思路二:利用好短路特性

package com.matajie;

/**
 * 17.树的子结构
 * 题目描述
 * 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
 *
 * 我的程序才不会有bug！
 * author:年仅18岁的天才少年程序员丶mata杰
 **/
public class HasSubtree {
    public class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

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

        }

    }
    boolean isSubtree(TreeNode node1,TreeNode node2){
        if(node2 == null)return true;
        if(node1 == null)return false;
        if(node2.val == node1.val){
            return isSubtree(node1.left,node2.left) && isSubtree(node1.right,node2.right);
        }else {
            return false;
        }
    }
    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);

}
}

18.二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

package com.matajie;

/**
 * 18.二叉树的镜像
 * 题目描述
 * 操作给定的二叉树，将其变换为源二叉树的镜像。
 *
 * 我的程序才不会有bug！
 * author:年仅18岁的天才少年程序员丶mata杰
 **/

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

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

        }

    }
    public void Mirror(TreeNode root) {
      if(root == null) {
          return;
      }
      TreeNode temp = root.left;
      root.left = root.right;
      root.right = temp;
      Mirror(root.left);
      Mirror(root.right);
    }
}

19.顺时针打印矩阵

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.

思路:

从外圈到内圈顺序依次打印,可以用一个循环来打印矩阵,每次打印矩阵的一个圈.
循环结束条件:设行数rows,列数cols,打印第一圈左上角坐标为(0,0),第二圈的左上角坐标为(1,1),依次类推,左上角行标和列表总是相同的,我们可以取(start,start)为左上角作为分析目标.
对于一个55的矩阵,最后一圈只有一个数字,对应坐标(2,2) , 5 > 22;
对于一个66的矩阵,最后一圈有四个数字,左上角下标(2,2), 6 > 22;
可得循环继续的条件为cols>start * 2 && rows > start * 2.

(别问为啥画的这么丑,问就是我上铺画的QAQ)

打印一圈的实现 : (注意:最后一圈可能只有一行,一列甚至一个数字,所以可能不需要4步)

1. 从左到右打印一行.
2. 从上到下打印一列.(只有一行,则不需要第二步,即终止条件为终止行号>起始行号)
3. 从右到左打印一行.(圈内至少有两行两列,即除了要求终止行号>起始行号,同时终止列号>起始列号)
4. 从下到上打印一行.(至少有三行两列,即要求终止行号比起始行号至少大2,同时终止列号>起始列号)

package com.matajie;

import java.util.ArrayList;

/**
 * 19.顺时针打印矩阵
 * 题目描述
 * 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，
 * 例如，如果输入如下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.
 *
 * 我的程序才不会有bug！
 * author:年仅18岁的天才少年程序员丶mata杰
 **/
public class PrintMatrix {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        int rows = matrix.length;
        int cols = matrix[0].length;
        if (matrix == null || cols <= 0 || rows <= 0) {
            return null;
        }
        int start = 0;
        while (cols > start*2 && rows > start*2){
            print(list,matrix,cols,rows,start);
            start++;
        }
            return list;
    }
   static void print(ArrayList<Integer> list,int[][] matrix,int cols, int rows,int start){
        int endX = cols - 1 - start;
        int endY = rows - 1 - start;
        //从左到右打印一行
        for(int i = start;i<=endX;i++){
            int number = matrix[start][i];
            list.add(number);
        }
        //从上到下打印一行
       if(start < endY){
            for(int i = start + 1;i <= endY;i++){
                int number = matrix[i][endX];
                list.add(number);
            }
       }
       //从右到左打印一行
       if(start<endX && start < endY){
            for(int i = endX - 1;i >= start;i--){
                int number = matrix[endY][i];
                list.add(number);
            }
       }
       //从下到上打印一行
       if(start<endX && start < endY - 1){
            for(int i = endY - 1;i >= start + 1;i--){
                int number = matrix[i][start];
                list.add(number);
            }
       }
    }
}

20.包含min函数的栈

题目描述

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

package com.matajie;

import java.util.Stack;

/**
 * 20.包含min函数的栈
 * 题目描述
 * 定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
 *
 * 我的程序才不会有bug！
 * author:年仅18岁的天才少年程序员丶mata杰
 **/
public class StackContainingMin {
    Stack<Integer> dataStack = new Stack<>();
    Stack<Integer> minStack = new Stack<>();//定义一个存放最小数的最小栈
    private int minNode;
    public void push(int node) {
      if(minStack.size() == 0){
          minNode = node;
          minStack.push(node);
      }else {
          if(minNode<node){
              minStack.push(minNode);
          }else {
              minStack.push(node);
              minNode = node;
          }
      }
      dataStack.push(node);
    }

    public void pop() {
        if (dataStack.size() > 0 && minStack.size() > 0) {
            dataStack.pop();
            minStack.pop();
        }
    }
    public int top() {
      return dataStack.peek();
    }

    public int min() {
return minStack.peek();
    }
}