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步)
- 从左到右打印一行.
- 从上到下打印一列.(只有一行,则不需要第二步,即终止条件为终止行号>起始行号)
- 从右到左打印一行.(圈内至少有两行两列,即除了要求终止行号>起始行号,同时终止列号>起始列号)
- 从下到上打印一行.(至少有三行两列,即要求终止行号比起始行号至少大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();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
