剑指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&&currentSum==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调整数组顺序使奇数位于偶数之前
题目: 输入一个整数数组,实现一个函数来调整该数组中数组的顺序,使得所有的奇数位于数组的前半部分,偶数位于数组的后半部分. 解题思路:数组中维护两个指针,第一个指针初始化时候指向数组头部,第二个指针初 ...

随机推荐

用C++实现的解数独（Sudoku）程序
我是一个C++初学者,控制台实现了一个解数独的小程序. 代码如下: //"数独游戏"V1.0 //李国良于2016年11月11日编写完成 #include <iostream ...
JS 模块化和打包方案收集
1.这里想讨论的是拆分规则,不是在问哪个工具怎么使用.2.这里没有在想找正确答案,因为感觉这个问题要结合具体业务场景. 随着项目开发越来越大,一开始代码全打包到一个文件的方式,让文件越来越大,接下来要 ...
海外建VPS并支持VPN
推荐 DigitalOcean http://www.digitalocean.com/?refcode=7c26aea99ed6
Optimal Flexible Architecture(最优灵活架构)
来自:Oracle® Database Installation Guide 12_c_ Release 1 (12.1) for Linux Oracle base目录命名规范: /pm/s/u 例 ...
Redis到底该如何利用（三）？
上两篇受益匪浅,秉着趁热打铁,不挖到最深不罢休的精神,我决定追加这篇.上一篇里最后我有提到实现分级缓存管理应该是个可行的方案,因此今天特别实践了一下.不过缓存分级之后也发现了一些问题,例如下图: 当a ...
TDD学习笔记【五】一隔绝相依性的方式与特性
前言在上一篇文章中,提到了如何通过 IoC 的设计,以及 Stub Object 的方式,来独立测试目标对象. 这一篇文章,则要说明有哪些设计对象的方式,可以让测试或需求变更时,更容易转换. 并说明 ...
数据分析(9):DataFrame介绍
DataFrame 表格型的数据结构创建DataFrame 可以通过传入dict的方式,DataFrame会自动加上索引,并且列会有序排列 data = {'state':['a', 'b', 'c ...
jshint 一些选项(转载)
内容来自: http://www.cnblogs.com/qianduanjingying/p/6185793.html 一些变量的作用: http://www.cnblogs.com/CloudMu ...
修改socket为keepAlive
参考文章:http://blog.csdn.net/ctthuangcheng/article/details/8596818 [root@mdw- gpadmin]# vi /etc/sysctl. ...
布局包含Image和Title的UIButton
UIButton中的titleEdgeInsets和imageEdgeInsets可以管理button中image和title的布局. 如果对其理解不够深入,用纯数字进行布局管理,经过不断的调试,还是 ...

剑指offer编程题java实现（正在更新）

剑指offer编程题java实现（正在更新）的更多相关文章

随机推荐

热门专题