使二叉树变为其镜像
类似先序遍历的方法
public void mirror(TreeNode node){
if(node==null)
return;
if(node.left==null&&node.right==null)
return;
TreeNode n=node.left;
node.left=node.right;
node.right=n;
mirror(node.left);
mirror(node.right);
}
判断二叉树是否对称
左节点的右子树和右节点的左子树相同 使用递归
boolean isSymmetrical(TreeNode pRoot){
if(pRoot==null)
return true;
return comRoot(pRoot.left,pRoot.right);
}
boolean comRoot(TreeNode left,TreeNode right){
if(left==null)
return right==null;
if(right==null)
return false;
if(left.val!=right.val)
return false;
return comRoot(left.right, right.left)&&comRoot(left.left, right.right);
}
实现有Min函数的栈
Stack stack1=new Stack<>();
Stack stack2=new Stack<>();
public void push(int node) {
stack1.push(node);
if(stack2.isEmpty())
stack2.push(node);
else{
if(node 给出入栈顺序，判断出栈顺序是否正确
public boolean IsPopOrder(int [] pushA,int [] popA) {
if(pushA.length==0||popA.length==0)
return false;
Stack s=new Stack<>();
int popIndex=0;
for(int i=0;i 判断是否是二叉搜索树的后序遍历序列
public boolean judge(int[] a,int start,int end){
if(start>=end)
return true;
int i=start;
while(i寻找二叉树从根到叶子值为x的路径
//方法一 使用栈
public ArrayList> FindPath(TreeNode root,int target) {
ArrayList> all=new ArrayList>();
if(root==null)
return all;
Stack stack=new Stack();
FindPath(root, target,stack,all);
return all;
}
void FindPath(TreeNode root,int target,Stack stack, ArrayList> all){
if(root==null)
return;
if(root.left==null&&root.right==null){
if(root.val==target){
ArrayList list=new ArrayList<>();
for(int i:stack){
list.add(new Integer(i));
}
list.add(new Integer(root.val));
all.add(list);
}
}else{
stack.push(new Integer(root.val));
FindPath(root.left,target-root.val,stack,all);
FindPath(root.right, target-root.val, stack, all);
stack.pop();
}
}
//方法二
public ArrayList> FindPath(TreeNode root,int target) {
if(root==null)
return listAll;
list.add(root.val);
target-=root.val;
if(target==0&&root.left==null&&root.right==null)
listAll.add(new ArrayList(list));
FindPath(root.left,target);
FindPath(root.right, target);
list.remove(list.size()-1);
return listAll;
}
求字符串全排列结果 按字典顺序返回
划分为子问题 第一个数和后面每个数交换 第二个数和后面每个数交换 ...
public ArrayList Permutation(String str) {
char []c=str.toCharArray();
ArrayList list=new ArrayList<>();
if(str!=null&&str.length()>0){
permutation(c,0,list);
Collections.sort(list);
}
for(String i:list)
System.out.println(i);
return list;
}
void permutation(char[] c,int start,ArrayList list){
if(start==c.length-1){
//System.out.println(Arrays.toString(c));
String s=String.valueOf(c);
if(!list.contains(s))
list.add(s);
}
for(int i=start;i 克隆复杂链表 该链表两个指针 一个指向下一个 一个随机指向
思路：
第一步：根据原始链表每个节点N创建对应的N'，把N'链接到N后面
第二步：根据原始链表每个节点N的random指针，设置新节点的random指针，为原指针的下一位
第三步：将第二步得到的链表拆分，奇数位置是原始链表，偶数位置是复制出来的链表 实现过程的一些细节要注意
//根据原始链表每个节点N创建对应的N'，把N'链接到N后面
void clonenodes(RandomListNode phead){
RandomListNode pnode=phead;
while(pnode!=null){
RandomListNode pcloned=new RandomListNode(-1);
pcloned.label=pnode.label;
pcloned.next=pnode.next;
pcloned.random=null;
pnode.next=pcloned;
pnode=pcloned.next;
}
}
//根据原始链表每个节点N的random指针，设置新节点的random指针，为原指针的下一位
void connectrandom(RandomListNode phead){
RandomListNode pnode=phead;
while(pnode!=null){
RandomListNode pcloned=pnode.next;
if(pnode.random!=null){
pcloned.random=pnode.random.next;
}
pnode=pcloned.next;
}
}
RandomListNode reconnect(RandomListNode phead){
RandomListNode pnode=phead;
RandomListNode pclonedHead=null;
RandomListNode pclonedNode=null;
if(pnode!=null){
pclonedHead=pclonedNode=pnode.next;
pnode.next=pclonedNode.next;
pnode=pnode.next;
}
while(pnode!=null){
pclonedNode.next=pnode.next;
pclonedNode=pclonedNode.next;
pnode.next=pclonedNode.next;
pnode=pnode.next;
}
return pclonedHead;
}
RandomListNode clone(RandomListNode node){
clonenodes(node);
connectrandom(node);
return reconnect(node);
}
class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
RandomListNode(int label) {
this.label = label;
}
}
//O（1）时间删除链表非尾节点的节点
将下一个节点的值复制给该节点，删除下一个节点，调整链接。
void delete(ListNode p,ListNode del){
if(p==null||del==null)
return;
if(del.next!=null){
del.val=del.next.val;
del.next=del.next.next;
}else if(p==del){
p=null;
}else{
ListNode pnode=p;
while(pnode.next!=del)
pnode=pnode.next;
pnode.next=null;
}
}
顺时针打印矩阵
俺圈数遍历，注意圈数的结束条件 x>2start&&y>2start
注意每次上下左右遍历执行的前提条件
public class test3 {
/*
* 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，
* 如果输入如下矩阵： 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.
*/
void printMartrixMethod(int [][]matrix){
if(matrix==null||matrix.length==0||matrix[0].length==0)
return;
int start=0;
while((matrix[0].length>start*2)&&(matrix.length>start*2)){
printMatrix(matrix,start);
++start;
}
}
public void printMatrix(int [][] matrix,int start) {
int endx=matrix[0].length-1-start;//中止列号
int endy=matrix.length-1-start;//中止行号
for(int i=start;i<=endx;i++){
int number=matrix[start][i];
System.out.print(number+" ");
}
if(start=start;i--){
int number=matrix[endy][i];
System.out.print(number+" ");
}
}
if(start=start+1;i--){
int number=matrix[i][start];
System.out.print(number+" ");
}
}
}
public static void main(String[] args) {
int a[][]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
new test3().printMartrixMethod(a);
}
}