第十六题：
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
思路：各自遍历，谁小先连接谁，最后把剩下的一起连接上去
代码：
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
ListNode resultList=new ListNode(0);//新建一个头结点
ListNode tempHead=resultList;
while(list1!=null&&list2!=null)//直到有一个链表先为空
{
if(list1.val<list2.val)//谁小，那么tempHead的下一个结点就是它
{
tempHead.next=list1;
list1=list1.next;//list1向后移
}
else{
tempHead.next=list2;
list2=list2.next;//list2向后移
}
tempHead=tempHead.next;//遍历的tempHead指向下一个
}
if(list1==null)//如果链表1为空，那么链表2可能不为空
{
tempHead.next=list2;//所以把链表2接到后面
}else{//否则说明链表2为空，就把链表1接到后面
tempHead.next=list1;
}
return resultList.next;//返回头结点的下一个，即相应的链表
}
}
---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------
第十七题：
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思维：两个递归，先判断根是否相同（一个递归），如果相同，再判断左右儿子是否相同（一个递归），用标记帮忙实现。
代码：
/**
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(root2 == null)//当Tree1和Tree2都不为零的时候，才进行比较。否则直接返回false
return false;
if(root1 == null)
return false;
boolean flag = false;
if(root1.val == root2.val)//以这个根节点为为起点判断是否包含Tree2
{
flag = doHasSubtree(root1,root2);//如果根结点包含，则进入判断函数
}
if(flag)
return flag;//flag为true直接返回
if(!flag)
{//如果找不到，那么就再去root的左儿子当作起点，去判断时候包含Tree2
flag = HasSubtree(root1.left,root2);//递归判断根是否包含
if(flag)
return true;
else{//如果还找不到，那么就再去root的右儿子当作起点，去判断时候包含Tree2
flag = HasSubtree(root1.right,root2);//递归判断根是否包含
if(flag)
return true;
}
}
return false;
}
private boolean doHasSubtree(TreeNode root1,TreeNode root2)
{
if(root2 == null)//如果Tree2已经遍历完了都能对应的上，返回true
return true;
if(root1 == null)//如果Tree2还没有遍历完，Tree1却遍历完了。返回false
return false;
if(root1.val != root2.val)//如果其中有一个点没有对应上，返回false
return false;
//如果根节点对应的上，那么就分别去子节点里面匹配（递归）
return doHasSubtree(root1.left,root2.left) && doHasSubtree(root1.right,root2.right);
}
}
---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------
第十八题：
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5思路：对左右儿子进行交换，之后左右儿子进入递归。
代码：
/**
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;
if(root.left == null && root.right == null)
return;
TreeNode tempNode = root.right;
root.right = root.left;
root.left = tempNode; //这里三行代码进行 交换左右子树
Mirror(root.left);//对于左子树 递归调用 就是说对于左子树也进行交换
Mirror(root.right);//右子树同理
}
}---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------
第十九题：
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.
思路：
-
按照顺时针打印矩阵，这里的话我用了一个变量count,来记录遍历的数目，当count如果小于等于二维矩阵的数目的话，说明没有遍历完成，直到count达到二维数组的数目。
-
代码中的left,right,bottom,top解读。left代表最左的一层，top代表最顶的一层，bottom代表最低的一层，right代表最右的一层，举个例子，比如最顶的层top，每当遍历完最上面的一层，那么就top++，比如最底层bottom每当遍历完最低一层就bottom--，这样下去肯定会出现top和bottom相遇的情况，也就是全部都遍历完了
代码：
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printMatrix(int [][] matrix) {
ArrayList<Integer> resultList = new ArrayList<>();
int cols = matrix[0].length;//列
int rows = matrix.length;//行
int left=0,top=0,bottom=rows-1,right=cols-1;
//left代表最左的一层，top代表最上的一层，bottom代表最低的一层，right代表最右的一层
int count = 0;//计数，count如果达到数组的全部个数，那么结束。
while(count < cols*rows)
{
for(int i=left;i<=right;i++)//从左往右进行遍历，第一层
{//left是目前最左边的那个边界，right是目前最右边的边界
resultList.add(matrix[top][i]);
count++;//每加入一个元素，计数+1
if(count >= cols*rows)
return resultList;//一旦count=cols*rows应该立即返回，不再执行之后的语言
}
top++;//遍历完目前的最顶层，那么top就到下一层
for(int i=top;i<=bottom;i++)
{//从上往下进行遍历，top是目前最上的边界，bottom是目前最下的边界
resultList.add(matrix[i][right]);
count++;//每加入一个元素，计数+1
if(count >= cols*rows)
return resultList;
}
right--;//遍历完最右边的边界，那么right就减一，到下一个最右边边界
for(int i=right;i>=left;i--)
{//从右到左，和上面同理
resultList.add(matrix[bottom][i]);
count++;//每加入一个元素，计数+1
if(count >= cols*rows)
return resultList;
}
bottom--;
for(int i=bottom;i>=top;i--)
{//从下到上，和上面同理。
resultList.add(matrix[i][left]);
count++;//每加入一个元素，计数+1
if(count >= cols*rows)
return resultList;
}
left++;
}
return resultList;
}
}---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------
第二十题：
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
思路：利用辅助栈实现，且每次入栈都要与辅助栈的栈顶进行比较，保证辅助栈从上到下为升序，且每次出栈一个元素，辅助栈也要出栈栈顶。
代码：
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<>();
Stack<Integer> stack2 = new Stack<>();
public void push(int node) {
stack1.push(node);
if (stack2.empty()) {
stack2.push(node);
} else {
if (node <= (int) stack2.peek())//比较栈顶与入栈的值，哪个小入哪个
{
stack2.push(node);
} else {
stack2.push(stack2.peek());
}
}
}
public void pop() {
stack2.pop();
stack1.pop();
}
public int top() {
return (int) stack1.peek();
}
public int min() {
return (int) stack2.peek();
}
}
---------------------------------------------------------------可爱的分界线----------------------------------------------------------------------------------------
扫一扫
1511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
