剑指offer编程题java实现（正在更新）
面试题三：查找二维数组中元素问题
public static void main(String[] args){
int[][] num = {{1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};
search(num,7);
}
public static void search(int[][] arr,int target){
int rows = arr.length;
int columns = arr[0].length;
int row = 0;
int column = columns-1;
while(row<=rows&&column>=0){
if(target==arr[row][column]){
System.out.println(target+"在第"+row+"行，第"+column+"列");
break;
}
if(target>arr[row][column]){
row++;
}
if(target<arr[row][column]){
column--;
}
}
}
面试题四：替换字符串中的空格
延伸：1.合并两个字符串 2.两个有序数组，将一个插入到另一个，并保证有序。 从后面开始会减少元素移动的次数？
public static void main(String[] args){
int[][] num = {{1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};
String str = "we are happy";
replaceBlank(str);
}
public static void replaceBlank(String str){
char[] charOld = str.toCharArray();
char[] charNew = new char[100];
for(int j = 0;j<charOld.length;j++){
charNew[j] = charOld[j];
}
int blank = 0;
for(int i = 0;i<charNew.length;i++){
if(charNew[i]==' '){
blank++;
}
}
int lengthFront = charOld.length-1;
int lengthBack = charOld.length+2*blank-1;
while(lengthFront>=0&&lengthBack>=0){
if(charNew[lengthFront]!=' '){
charNew[lengthBack--] = charNew[lengthFront];
}
else
{
charNew[lengthBack--] = '0';
charNew[lengthBack--] = '2';
charNew[lengthBack--] = '%';
lengthFront--;
}
lengthFront--;
}
System.out.println(charNew);
}
面试题5.从尾到头打印链表（利用栈或递归来实现）
构建链表
public class ListNode {
private int value;
private ListNode next;
public ListNode(int value){
this.value = value;
}
public ListNode(int value,ListNode next){
this.value = value;
this.next = next;
}
public void setValue(int value){
this.value = value;
}
public int getValue(ListNode node){
return node.value;
}
public void setNext(ListNode next){
this.next = next;
}
public ListNode getNext(){
return this.next;
}
}
Stack s = new Stack(); 栈 public static void method(head){ 递归，但是链表长度较长时就不要用
ListNode p = head; if(head!=null){
while(p!=null){ if(head.getNext()!=null){
stack.push(p.getValue()); method(head.getNext);
p=p.getNext(); }
} System.out.println(head.getValue());
while(!s.isEmpty){ }
System.out.println(s.pop()); }
}
面试题六：根据前序和中序输出构造二叉树
建二叉树
public class BinaryTreeNode {
private int value;
private BinaryTreeNode left;
private BinaryTreeNode right;
public BinaryTreeNode(int value){
this.value = value;
}
public BinaryTreeNode(int value,BinaryTreeNode left,BinaryTreeNode right){
this.value = value;
this.left = left;
this.right = right;
}
public int getValue( ){
return this.value;
}
public void setValue(BinaryTreeNode node){
this.value = value;
}
public void setLeft(BinaryTreeNode node){
this.left = node;
}
public void setRight(BinaryTreeNode node){
this.right = node;
}
public BinaryTreeNode getLeft( ){
return this.left;
}
public BinaryTreeNode getRight( ){
return this.right;
}
}
根据前序找根节点，然后判断根节点在中序输出中的位置，根节点左边的就是左子树，右边的就是右子树，然后递归调用此方法。
public static void main(String[] args){
int[][] num = {{1,2,8,9},{2,4,9,12},{4,7,10,13},{6,8,11,15}};
int[] frontOrder = {1,2,4,7,3,5,6,8};
int[] inOrder = {4,7,2,1,5,3,8,6};
BinaryTreeNode root =BinaryTree(frontOrder,inOrder);
printPostOrder(root);
}
public static void printPostOrder(BinaryTreeNode root){
if(root!=null){
printPostOrder(root.getLeft( ));
printPostOrder(root.getRight( ));
System.out.println(root.getValue());
}
}
public static BinaryTreeNode BinaryTree(int[] frontOrder,int[] inOrder){
BinaryTreeNode root = new BinaryTreeNode(frontOrder[0]);
root.setLeft(null);
root.setRight(null);
int leftLength = 0;
for(int i =0;i<inOrder.length;i++){
if(inOrder[i]==root.getValue( )){
break;
}else{
leftLength++;
}
}
int rightLength = inOrder.length-leftLength-1;
if(leftLength>0){
int[] leftFrontOrder = new int[leftLength];
int[] leftInorder = new int[leftLength];
for(int j = 0;j<leftLength;j++){
leftFrontOrder[j] = frontOrder[j+1];
leftInorder[j] = inOrder[j];
}
BinaryTreeNode leftRoot = BinaryTree(leftFrontOrder,leftInorder);
root.setLeft(leftRoot);
}
if(rightLength>0){
int[] rightFrontOrder = new int[rightLength];
int[] rightInorder = new int[rightLength];
for(int k = 0;k<rightLength;k++){
rightFrontOrder[k] = frontOrder[k+1+leftLength];
rightInorder[k] = inOrder[k+1+leftLength];
}
BinaryTreeNode rightRoot =BinaryTree(rightFrontOrder,rightInorder);
root.setRight(rightRoot);
}
return root;
}
面试题七.两个栈实现一个队列
先用一个栈存，这样就是倒序，然后依次取出放入另一个栈，这就是正序了，然后再取出，就和队列一样了。
public class sQueue<T> {
Stack<T> s1 = new Stack<T>();
Stack<T> s2 = new Stack<T>();
public void appendTrail(T append){
s1.push(append);
}
public T deleteHead(Stack<T> s){
if(s1==null){
if(s2==null){
try{
throw new Exception("队列为空");
}catch(Exception e ){
e.printStackTrace();
}
}
}
while(s1.size()>0){
s2.push(s1.pop());
}
return s2.pop();
}
}
面试题：将企业中员工年龄排序，使用一个长度100的数组作为辅助空间，记录每个年龄出现的次数，然后按照这个记录的次数输出年龄
public static void sort(int[] ages,int length){
int largeAge = 99;
int[] timeAge = new int[largeAge+1];
length = ages.length;
if(ages==null||length<0){
return;
}
for(int i = 0;i<length;i++){
int age = ages[i];
if(ages[i]<0||ages[i]>99){
return;
}
timeAge[age]++;
}
int index = 0;
for(int j = 0;j<=largeAge;j++){
for(int k =0;k<timeAge[j];k++){
ages[index] = j;
index++;
}
}
}
面试题八.求旋转数组的最小值
public static int findMin(int[] num){
if(num==null||num.length<=0){
return 0;
}
int middle = num.length/2;
int front = 0;
int back = num.length-1;
while(num[front]>num[back]){
if(back-front==1){
middle = back;
break;
}
middle = (front+back)/2;
if(num[middle]==num[front]&&num[front]==num[back]){ 10111 这种情况就需要顺序遍历来找了
return 0;
}
if(num[middle]>num[front]){
front = middle;
}
if(num[middle]<num[front]){
back = middle;
}
}
return num[middle];
}
面试题九：斐波那契数列
f(n) = f(n-1)+f(n-2) 类似的有上台阶问题，一次能迈1个或2个台阶，问有多少种方法上楼梯。迈上终点之前肯定是迈了一步或是两步，那n-1个台阶的方法数加上n-2个台阶的方法数就是n个台阶的方法数。
那么如果一次能迈的台阶数没有限制呢，1，2，3，。。。n 用归纳法得出f(n) = 2的n-1次方
public static int fibonaci(int n){
if(n==0){
return 0;
}else if(n==1){
return 1;
}
else{
int front = 0;
int back =1;
int x =0;
for(int i =0;i<=n;i++){
x = front+back;
front = back;
back =x;
}
return x;
}
}
类似的格子填充问题
面试题十：二进制中1的个数
正数（1，0x7FFFFFFF）负数（0x80000000，0xFFFFFFFF）
解法：十进制中的1二进制表示为00000001，我们可以借助它和要检验的二进制数A相与，这样，就可以根据结果获知 A中最后一位是0还是1。
1.第一次相与后，把A右移一位，再次相与，这样依次右移就可以知道每一位是0是1。但是当A为负数时这种方法不可行。移位前是负数的话，就要保证移位后是负数，这样移位后最高位自动置1.
2.第一次相与后，将00000001依次向左移动一位，这是一种较好的方法，因为不确定A的大小，移动可能会产生影响。
3.最好的解法：比如一个1100，将1100减去1是1011，然后将1100和1011相与得出1000，这样1100中最右边的1就变为0。再执行一次的话就变成0000。这样执行n次后A变为0，那么A中就有n个1.
把一个二进制A和B=（A-1）相与，那么A的最后一个1变0.
public static void main(String[] args){
int n =10;
int c = count(n);
System.out.println(c);
}
public static int count(int n){
int num = 0;
while(n!=0){
n = n&(n-1);
num++;
}
return num;
}
相关题目1：一个数是否为2的整数次方。
解法：一个数如果是2的整数次方，那么它的二进制有且只有一个1.
相关题目2：求从一个二进制变为另一个需要改变多少位。
解法：两数异或，统计二进制结果中1的数目。
面试题11.数的整数次幂
base为0，指数为负的情况也要考虑到。 指数为负，把指数取正，然后结果取倒数。
public static void main(String[] args){
double a = power(2,5);
System.out.println(a);
}
public static double power(double base,int exponent){
if(exponent ==0 ){
return 1;
}
if(exponent == 1){
return base;
}
if(exponent>>1==0){
int exponent1 = exponent>>1;
double result = power(base,exponent1);
return result*result;
}else{
int exponent2 = exponent-1;
double result = power(base,exponent2);
return result*base;
}
}
面试题十二：输出1到n位最大整数
如果按照最简单的循环输出，会遇到边界问题，n非常大的话，int甚至long都不能满足需求，所以这里需要用数组或者是字符串来表示要输出的数字。
如果面试题给定了一个n位整数，那么就是大数问题，用字符串来解决。
给定两个整数相加求结果，也是大数问题。
public static void main(String[] args){
bigData(3);
}
public static void bigData(int n){
char[] num = new char[n];
for(int i = 0;i<n;i++){
num[i] = '0';
}
boolean end = false;
while(!end){
num[n-1]++;
for(int k =n-1;k>0;k--){
if(num[k]=='9'+1){
num[k] = '0';
num[k-1]++;
}
}
if(num[0]=='9'+1){
end = true;
break;
}
boolean out = false;
for(int j =0;j<n;j++){
if(num[j]=='0'&&!out){ //out是为了避免像100这样的数字，后边的两个0不会输出，当遇到第一个非0数字后，改变end状态，就不会进入忽略0的语句。
continue;
}else{
out = true;
System.out.print(num[j]);
}
}
System.out.println("...");
}
}
面试题十三：在O(1)时间内删除单向链表中的一个节点
思路：如果从首部开始依次查找，那么时间是O(n).
既然我们知道要删除的结点i，那么我们就知道它指向的下一个结点j，那么我们可以将j的内容复制到i，然后将i的指针指向j的下一个结点，这样虽然看起来我们删除的是j结点，但是实际删除的是i。
此外还要考虑的问题是：如果结点不存在怎么办？如果结点是尾结点怎么办？链表只有一个结点？
public class deleteInode {
public static void main(String[] args) {
ListNode head = new ListNode(0);
ListNode node1 = new ListNode(1);
ListNode node2 = new ListNode(2);
ListNode node3 = new ListNode(3);
head.setNext(node1);
node1.setNext(node2);
node2.setNext(node3);
delete(head,node2);
printListNode(head);
}
public static void delete(ListNode head,ListNode target){
if(head==null||target==null){
return;
}
if(head.getNext()==null){
if(head==target){
head=null;
}else{
return;
}
}
if(target.getNext()==null){
ListNode currentNode = head;
while(currentNode.getNext()!=null){
currentNode = currentNode.getNext();
}
currentNode.setNext(null);
}
if(target.getNext()!=null){
target.setValue(target.getNext().getValue());
if(target.getNext().getNext()!=null){
target.setNext(target.getNext().getNext());
}else{
target.setNext(null);
}
}
}
public static void printListNode(ListNode head){
ListNode current = head;
while(current!=null){
System.out.println(current.getValue()+"...");
current = current.getNext();
}
}
}
面试题十五.链表中倒数第K个结点
思路：两个指针A、B，最开始都指向第一个结点，先让A向前走k-1步，然后从第K步开始，A和B同时向前走，这样，当A到达最后一个结点时，B的位置就是倒数第K个结点。
public static ListNode findKNode(ListNode head,int k){
if(head==null){
return null; //重要！！！鲁棒性的判断
}
if(k<1){
return null;
}
ListNode firstNode = head;
ListNode secondNode = head;
for(int i =0;i<k-1;i++){
if(firstNode.getNext()!=null){
firstNode = firstNode.getNext();
}else{
return null;
}
}
while(firstNode.getNext()!=null){
firstNode = firstNode.getNext();
secondNode = secondNode.getNext();
}
return secondNode;
}
相关问题1：求链表的中间结点
解决方法：两个指针，第一个一次走两步，第二个一次走一步，第一个到达终点时，第二个到达中点。
相关问题2：环形链表问题
解决方法：也是两个指针不一样的速度走，如果第一个指针到达终点（getNext()等于空）时都没有碰到第二个，那么就不是环形链表。
注：环形链表可以是首尾相连（O型），也可以是尾部和中间的某个结点相连（6型）。
面试题十六：反转链表
反转链表相当于喊向后转的口号之后，队首变队尾，队尾变队首。
下图说明了存在的一个隐患，那就是当把（i）结点的指针指向h时，这时如果没有提前将（j）结点存储，那么下一步就找不到（j）结点了，链表会断裂。
所以我们要声明三个变量，分别记录h、i、j，对应上一个、当前、下一个。
public class Test {
public static void main(String[] args){
ListNode head = new ListNode(0);
ListNode node1 = new ListNode(1);
ListNode node2 = new ListNode(2);
ListNode node3 = new ListNode(3);
head.setNext(node1);
node1.setNext(node2);
node2.setNext(node3);
ListNode node = reverseNode(head);
print(node);
}
public static ListNode reverseNode(ListNode head){
if(head==null){
return null;
}
ListNode preNode = null;
ListNode curNode = head;
ListNode nextNode = null;
ListNode reverseNode = null;
while(curNode!=null){
nextNode = curNode.getNext();
if(nextNode==null){
reverseNode = curNode;
}
curNode.setNext(preNode);
preNode = curNode;
curNode = nextNode;
}
return reverseNode;
}
public static void print(ListNode head){
ListNode current = head;
while(current!=null){
System.out.println(current.getValue());
current = current.getNext();
}
}
}
面试题十七：合并两个已排序的链表
其实这是一个递归问题，在比较两个链表的头结点后，选定其中一个做为新链表的结点，那么产生下一个结点的过程和最开始一样，两个链表的头结点中选择一个做为新链表的下一个结点，所以是递归问题。
public class Test {
public static void main(String[] args){
ListNode head1 = new ListNode(1);
ListNode node1 = new ListNode(3);
ListNode node2 = new ListNode(5);
ListNode node3 = new ListNode(7);
head1.setNext(node1);
node1.setNext(node2);
node2.setNext(node3);
ListNode head2 = new ListNode(2);
ListNode node4 = new ListNode(4);
ListNode node5 = new ListNode(6);
ListNode node6 = new ListNode(8);
head2.setNext(node4);
node4.setNext(node5);
node5.setNext(node6);
ListNode head = merge(head1,head2);
print(head);
}
public static ListNode merge(ListNode headA,ListNode headB){
ListNode nodeA = headA;
ListNode nodeB = headB;
ListNode head = null;
if(headA==null&&headB!=null){
head = headB;
}
if(headB==null&&headA!=null){
head = headA;
}
if(headA==null&&headB==null){
return null;
}
if(nodeA!=null&&nodeB!=null){
if(nodeA.getValue()<nodeB.getValue()){
head = nodeA;
head.setNext(merge(nodeA.getNext(),nodeB));
}else{
head = nodeB;
head.setNext(merge(nodeA,nodeB.getNext()));
}
}
return head;
}
public static void print(ListNode head){
ListNode curNode = head;
while(curNode!=null){
System.out.println(curNode.getValue());
curNode = curNode.getNext();
}
}
}
面试题十八：树的子结构
两个递归方法，一个是寻找相同的结点，如果遇到相同结点，就调用比较左右子结点的方法。如果根节点和目标结点不相同，就比较左右子结点和目标是否相同，相同，就调用比较子结点方法，不相同，继续调用寻找相同结点方法。
public class Test {
public static void main(String[] args){
BinaryTreeNode root = new BinaryTreeNode(8);
BinaryTreeNode node1 = new BinaryTreeNode(8);
BinaryTreeNode node2 = new BinaryTreeNode(7);
BinaryTreeNode node3 = new BinaryTreeNode(9);
BinaryTreeNode node4 = new BinaryTreeNode(2);
root.setLeft(node1);
root.setRight(node2);
node1.setLeft(node3);
node1.setRight(node4);
BinaryTreeNode target = new BinaryTreeNode(8);
BinaryTreeNode node5 = new BinaryTreeNode(9);
BinaryTreeNode node6 = new BinaryTreeNode(2);
target.setLeft(node5);
target.setRight(node6);
boolean result2 = findSame(root,target);
System.out.println(result2);
}
public static boolean findSame(BinaryTreeNode root,BinaryTreeNode target){
boolean result = false;
if(root!=null&&target!=null){
if(root.getValue()==target.getValue()){
result = sameTree(root,target);
}
if(!result){
result = findSame(root.getLeft(),target);
}
if(!result){
result = findSame(root.getRight(),target);
}
}
return result;
}
public static boolean sameTree(BinaryTreeNode node,BinaryTreeNode target){
if(target==null){
return true;
}
if(node ==null ){
return false;
}
if(node.getValue()!=target.getValue()){
return false;
}
return sameTree(node.getLeft(),target.getLeft())&&sameTree(node.getRight(),node.getRight());
}
}
面试题十九：二叉树镜像
貌似对于二叉树的整体操作都是递归问题，因为操作过根节点之后，左右两颗子树就可以看成单独的树递归操作。
打印二叉树的时候，每次打印根结点就可以，因为每个结点输出之后，它的子结点都可以看作根结点。
public class Test {
public static void main(String[] args){
BinaryTreeNode root = new BinaryTreeNode(8);
BinaryTreeNode node1 = new BinaryTreeNode(8);
BinaryTreeNode node3 = new BinaryTreeNode(9);
BinaryTreeNode node2 = new BinaryTreeNode(7);
BinaryTreeNode node4 = new BinaryTreeNode(6);
root.setLeft(node1);
root.setRight(node3);
node1.setLeft(node2);
node3.setRight(node4);
mirrorBinary(root);
printBinaryTree(root);
}
public static void mirrorBinary(BinaryTreeNode root){
if(root == null){
return;
}
if(root.getLeft()==null&&root.getRight()==null){
return;
}
BinaryTreeNode temp = root.getLeft();
root.setLeft(root.getRight());
root.setRight(temp);
if(root.getLeft()!=null){
mirrorBinary(root.getLeft());
}
if(root.getRight()!=null){
mirrorBinary(root.getRight());
}
}
public static void printBinaryTree(BinaryTreeNode root){
if(root!=null){
System.out.println(root.getValue());
printBinaryTree(root.getLeft());
printBinaryTree(root.getRight());
}
}
}
按照循环的方法做，就要用到队列了， 利用队列的先进先出的性质，依次添加所有结点，在取出每个结点时，并不对结点操作，而是对结点的两个子结点进行添加进队列和交换的操作。
这里利用队列的方法类似于二叉树的分层遍历所采用的方法。
public static void mirrorBinary(BinaryTreeNode root){
Queue<BinaryTreeNode> q = new LinkedList<BinaryTreeNode>();
BinaryTreeNode temp = new BinaryTreeNode(0);
if(root!=null){
q.add(root);
}
while(q.size()>0){
BinaryTreeNode node = q.poll();
if(node.getLeft()!=null){
q.add(node.getLeft());
}
if(node.getRight()!=null){
q.add(node.getRight());
}
temp = node.getLeft();
node.setLeft(node.getRight());
node.setRight(temp);
}
}
面试题二十：顺时针打印矩阵（按圈打印）
public class Test {
public static void main(String[] args){
BinaryTreeNode root = new BinaryTreeNode(8);
int[][] num = {{1,2,3,4},{5,6,7,8,},{1,3,5,7,},{2,4,6,8}};
print(num,4,4);
}
public static void print(int[][] num,int rows,int columns){
if(num==null||rows<=0||columns<=0){
return;
}
int temp = 0;
while(rows>temp*2&&columns>temp*2){
printCircle(num,temp,rows,columns);
temp++;
}
}
private static void printCircle(int[][] num,int start,int rows,int columns) {
int endRow = rows-1-start;
int endColumn = columns-1-start;
for(int i = start;i<=endColumn;i++){
System.out.print(num[start][i]);
}
//如果行数大于起始值，那么肯定不止一行，所以最右一列可以打印
if(start<endRow){
for(int i = start+1;i<=endRow;i++){
System.out.print(num[i][endRow]);
}
}
//从右到左打印最下一行
if(start<endRow&&start<endColumn){
for(int i = endColumn-1;i>=start;i--){
System.out.print(num[endRow][i]);
}
}
//打印最左边一列
if(start<endColumn&&start<endRow-1){
for(int i =endRow-1;i>start;i--){
System.out.print(num[i][start]);
}
}
System.out.println(".......");
}
}
面试题二十一：包含min函数的栈
创建一个辅助栈，在每次存入新元素时，将新元素和辅助栈的栈顶元素相比，如果栈顶元素小，则再添加一次栈顶元素，否则添加新元素。这样可以保证辅助栈的栈顶始终都是原本栈中的最小元素。
public class minStack {
private Stack<Integer> stack1;
private Stack<Integer> stackHelp;
private int temp,pop1,pop2;
public minStack(){
stack1 = new Stack<Integer>();
stackHelp = new Stack<Integer>();
}
public void push(int num){
stack1.push(num);
if(stackHelp.size()==0||num<stackHelp.peek()){
stackHelp.push(num);
}else{
stackHelp.push(stackHelp.peek());
}
}
public void pop(){
pop1 = stack1.pop();
pop2 = stackHelp.pop();
System.out.println("本栈是"+pop1+"辅助栈是"+pop2);
}
public void min(){
System.out.println("最小值是"+stackHelp.pop());
}
}
面试题二十二：栈的压入，弹出序列
输入两组数，判断一个是否是另一个的弹栈顺序。比如A{1,2,3,4,5} B{1,2,5,3,4} 在依次往A中压入元素时，不断比较栈顶元素，1，2，3，当A栈中4进入时，等于B中栈顶元素，那么4弹出。再比较A和B的栈顶元素，都是3，3出栈。然后A是2，B是5，不相同，则5进入A栈，此时栈顶元素相同，5出栈。然后就是2，1. 则第二个数组满足条件。
public class Test {
public static void main(String[] args){
int[] numPush = {1,2,3,4,5};
int[] numPop = {4,3,5,2,1};
System.out.println(isPopOrder(numPush,numPop));
}
public static boolean isPopOrder(int[] numPush,int[] numPop ){
if(numPush.length<=0||numPop.length<=0||numPush.length!=numPop.length){
return false;
}
Stack<Integer> stackPop = new Stack<Integer>();
for(int i=numPop.length-1;i>=0;i--){
stackPop.push(numPop[i]);
}
Stack<Integer> stackPush = new Stack<Integer>();
int j = 0;
while(j<numPush.length){
if(numPush[j]!=stackPop.peek()){
stackPush.push(numPush[j]);
j++;
}else{
stackPush.push(numPush[j]);
System.out.println(numPush[j]);
while(stackPush.size()>0&&stackPop.size()>0&&stackPush.peek()==stackPop.peek()){
System.out.println("..."+stackPush.pop());
System.out.println(".."+stackPop.pop());
}
j++;
}
}
if(stackPush.size()==0){
return true;
}else{
return false;
}
}
}
面试题二十四：判断一个数组是否是某二叉树的后序遍历顺序
后续遍历结果最后一个是根节点，除去根节点，数组的前半部分应该都比根节点的值小，数组的后半部分应该都比根节点的值大，按照这个规律，递归判断。
int[] left = Arrays.copyOfRange(num, 0, i); 从第0位截取到i-1位。
public static boolean isBinaryTree(int[] num ){
if(num.length<=0){
return false;
}
int root = num[num.length-1];
int i = 0 ;
for(;i<num.length-1;i++){
if(num[i]>root){
break;
}
}
for(int j =i;j<num.length-1;j++){
if(num[j]<root){
return false;
}
}
int[] left = Arrays.copyOfRange(num, 0, i);
int[] right = Arrays.copyOfRange(num, i, num.length-1);
Boolean isLeft = true;
if(left.length>0){
isBinaryTree(left);
}
Boolean isRight = true;
if(right.length>0){
isBinaryTree(right);
}
return(isLeft&&isRight);
}
面试题二十五：二叉树中和为某一值的路径
public static void main(String[] args){
BinaryTreeNode root = new BinaryTreeNode(5);
BinaryTreeNode node1 = new BinaryTreeNode(4);
BinaryTreeNode node2 = new BinaryTreeNode(3);
BinaryTreeNode node3 = new BinaryTreeNode(5);
BinaryTreeNode node4 = new BinaryTreeNode(1);
BinaryTreeNode node5 = new BinaryTreeNode(2);
BinaryTreeNode node6 = new BinaryTreeNode(1);
root.setLeft(node1);
root.setRight(node3);
node1.setLeft(node2);
node3.setLeft(node4);
node3.setRight(node5);
node4.setLeft(node6);
Stack<Integer> stack = new Stack<Integer>();
isPath(12,0,root,stack);
}
public static void isPath(int expectSum,int currentSum,BinaryTreeNode root,Stack<Integer> stack){
if(root==null){
return;
}
stack.push(root.getValue());
currentSum += root.getValue();
if(root.getLeft()==null&&root.getRight()==null&¤tSum==expectSum){
for(Integer e : stack){ //这种方式输出不用谈栈，元素还在栈里
System.out.print(e+"\t");
}
System.out.println();
}
if(root.getLeft()!=null){
isPath(expectSum,currentSum,root.getLeft(),stack);
}
if(root.getRight()!=null){
isPath(expectSum,currentSum,root.getRight(),stack);
}
stack.pop(); //执行到叶结点（倒数第二层的左子结点）之后，pop，就会回到上一层，然后判断一下有没有右子结点，执行下一步没有的话，再pop，又往上一层，再检查右子结点。
}
面试题二十六：复制一个复杂链表
复杂链表：一个结点可以有两个指向，一个是next，一个是乱序
1.首先只复制next链表，把复制结点放到原本结点的后边。
2.复制乱序指向
3.分离两个链表，奇数位的连在一起，偶数位的连在一起，就是两个相同的链表。
分离时，使用两个指针，一个pNode，一个pCloneNode，将pNode的next指向pClonedNode的next之后，移动pNode到第三个，然后将pCloneNode指向pNode的next，然后移动pCloneNode到第四个，这样不断移动，实现分离。
面试题二十七：二叉搜索树转换成有序双向链表
中序遍历二叉树得到的结果是有序的。
1，curNode记录的是上一个结点，当root行进到最左边叶结点的左子结点时，root为空，程序不执行，退回上一步。上一步的root输入是最左边的叶结点。
2，这时从第5行执行，但这时的curNode为空。第9行：curNode = 最左叶结点。第十行：递归最左子结点的右子结点，如果存在，那么验证是否有左子结点，没有，返回上一层执行第5行，和curNode互指。
3，处理完curNode的子结点，就要返回上一层，这时的root输入为curNode的父结点，执行第5行互指。然后curNode被设置成root。再去寻找root的右子结点。
过程中，由于程序的对于二叉树中结点的遍历顺序是左中右，所以curNode的指向也是这个顺序。在每一次退出上一层时，curNode的指向都会更新。
程序最开始位于左中右的中，然后寻找右，这里的中和右其实都是上一层的左。返回上一层的中，寻找上一层的右。
1 private BinaryTreeNode curNode ;
2 public void toTwo(BinaryTreeNode root){
3 if(root!=null){
4 toTwo(root.getLeft());
5 if(curNode!=null){
6 curNode.setLeft(root);
7 root.setRight(curNode);
8 }
9 curNode = root;
10 toTwo(root.getRight());
}
}
面试题二十八：字符串的排列
和八皇后问题一样，都是用 回溯法解决问题。
public class Test {
private final int SET = 1;
private final int UNSET = 0;
private int size;
private int[] set;
private char[] c;
private char[] location;
private int count;
public Test(int size,char[] c){
this.size = size;
this.c = c;
location = new char[size];
set = new int[size];
}
public void charSet(int i,int j,int k){
location[i] = c[j];
if(k==0){
set[j] = UNSET;
}
}
public int isPlace(int j){
return set[j];
}
public void print(){
System.out.println("第"+count+"种方法");
for(int j=0;j<size;j++){
System.out.print(location[j]+".");
}
System.out.println();
}
public void place(int i){
for(int j = 0;j<size;j++){
if(set[j]==UNSET){
charSet(i,j,1);
set[j] = SET;
if(i<size-1){
place(i+1);
}else{
count++;
print();
}
charSet(i,j,0);
}
}
}
public static void main(String[] args){
char[] c = {'a'};
if(c==null){
return;
}
else{
Test t = new Test(c.length,c);
t.place(0);
}
}
}
扩展：求字符的所有组合Input：abc Output：a,b,c,ab,bc,ac,abc
public class Test {
public static void main(String[] args){
perm("abc");
}
public static void perm(String s){
List<String> result = new ArrayList<String>();
for(int i =1;i<=s.length();i++){
perm(s,i,result);
}
}
public static void perm(String s,int m,List<String> result){
if(s.length()<m){
return;
}
if(m==0){
for(int i =0;i<result.size();i++){
System.out.println(result.get(i));
}
System.out.println();
return;
}else{
if(s.length()!=0){
result.add(s.charAt(0)+"");
perm(s.substring(1,s.length()),m-1,result);
result.remove(result.size()-1);
perm(s.substring(1,s.length()),m,result);
}
}
}
}
剑指offer编程题java实现（正在更新）的更多相关文章
- 剑指offer编程题Java实现——面试题5从头到尾打印链表
题目描述* 剑指offer面试题5:从尾到头打印链表 输入一个链表的头结点,从尾到头打印出每个结点的值 解决方案一:首先遍历链表的节点后打印,典型的"后进先出",可以使用栈来实现这 ...
- 剑指offer编程题Java实现——面试题12相关题大数的加法、减法、乘法问题的实现
用字符串或者数组表示大数是一种很简单有效的表示方式.在打印1到最大的n为数的问题上采用的是使用数组表示大数的方式.在相关题实现任意两个整数的加法.减法.乘法的实现中,采用字符串对大数进行表示,不过在具 ...
- 剑指offer编程题Java实现——面试题10二进制中1的个数
题目: 请实现一个函数,输入一个整数,输出该整数二进制表示中1的个数.例如,把9表示成二进制是1001,有2位是1,该函数输出2解法:把整数减一和原来的数做与运算,会把该整数二进制表示中的最低位的1变 ...
- 剑指offer编程题Java实现——面试题7相关题用两个队列实现一个栈
剑指offer面试题7相关题目:用两个队列实现一个栈 解题思路:根据栈的先入后出和队列的先入先出的特点1.在push的时候,把元素向非空的队列内添加2.在pop的时候,把不为空的队列中的size()- ...
- 剑指offer编程题Java实现——面试题7用两个栈实现队列
题目:用两个栈实现一个队列.队列的声明如下:请实现他的两个函数appendTail和deleteHead, 分别完成在队列尾部插入节点和在队列头部删除节点的功能. package Solution; ...
- 剑指offer编程题Java实现——替换空格
题目描述 请实现一个函数,将一个字符串中的空格替换成"%20".例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy. package ...
- 剑指offer编程题Java实现——面试题6重建二叉树
题目: 输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树.假设输入的前序遍历和中序遍历结果中都不含重复的数字.例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2, ...
- 剑指offer编程题Java实现——面试题11数值的整数次方
题目: 实现函数double power(double base,int exponent),求base的exponent次方.不得使用库函数,同时不需要考虑大数问题. 解题思路:最一般的方法实现数值 ...
- 剑指offer编程题Java实现——面试题12打印1到最大的n位数
题目:打印1到最大的n位数 输入数字n,按顺序打印输出从1到最大的n位十进制数,比如输入3,打印从1到999. 这道题考察的地方是如何表示大数问题.由于n是任意大的数组,如果n太大的话n位数就超过了l ...
- 剑指offer编程题Java实现——面试题14调整数组顺序使奇数位于偶数之前
题目: 输入一个整数数组,实现一个函数来调整该数组中数组的顺序,使得所有的奇数位于数组的前半部分,偶数位于数组的后半部分. 解题思路:数组中维护两个指针,第一个指针初始化时候指向数组头部,第二个指针初 ...
随机推荐
- ShareSDK分享失败的原因
关于分享估计很多都用的是ShareSDK的社会化分享,简单方便,支持的种类很多,但是一般的话都还是QQ,微信,新浪微博,腾讯微博为主. 最近需要导入一个分享的模块,失败了几次之后最终成功,分享给大家, ...
- Vue.js介绍样码
了解一下,其它的什么SASS,COMPASS,WEBPACK,VUE.JS都看看,了解一下前端开发的一些知识点吧. <!DOCTYPE html PUBLIC "-//W3C//DTD ...
- C++ 系列：多线程资源收集
Copyright © 1900-2016, NORYES, All Rights Reserved. http://www.cnblogs.com/noryes/ 欢迎转载,请保留此版权声明. -- ...
- SOUI开发者论坛
http://www.lumaba.cn/forum.php?mod=forumdisplay&fid=2 需要的朋友可以上去交流.
- poj分类 很好很有层次感。
初期: 一.基本算法: (1)枚举. (poj1753,poj2965) (2)贪心(poj1328,poj2109,poj2586) (3)递归和分治法. ( ...
- VBA实例收集
1.工作表事件:固定制定区域激活,使之不能选择其他区域. Private Sub Worksheet_SelectionChange(ByVal Target As Range) If Target. ...
- PHP 汉字拼音互转
<?PHP function Pinyin($_String, $_Code='gb2312'){ $_DataKey = "a|ai|an|ang|ao|ba|bai|ban|ban ...
- 1.2.1 OC概述
本文并非最终版本,如想关注更新或更正的内容,详见文末的联系方式,如有疏忽和遗漏,欢迎指正. 本文相关目录:(链接为简书链接) ====================== 所属文集:1.2 Objec ...
- SQLServer CASE WHEN 用法
SELECT sc.NAME AS 学校名称 ,xueyuan.NAME AS 院系 ,StudentNo AS 学号 ,st.StudentName AS 学生姓名 ,st.sex AS 性别 ,s ...
- 安装Python算法库
安装Python算法库 主要包括用NumPy和SciPy来处理数据,用Matplotlib来实现数据可视化.为了适应处理大规模数据的需求,python在此基础上开发了Scikit-Learn机器学习算 ...