剑指offer(java代码版)

本文章转载之：https://www.cnblogs.com/ysw-go/p/6272551.html

1,singleTon实例
题目描述：设计一个类，我们只能生成该类的一个实例
//volatile:防止指令重排序
public class singletonClass{

private static volitile singletonClass instance;

private singletonClass(){

}

public static singletonClass getInstance(){

if(instance==null){
   synchronized(singletonClass.class){
      if(instance==null){
      instance = new singletonClass();
} 
}   
return instance;

}
}
}

2,二位数组中的查找
在一个二位数组中，每一行都按照从左到右递增的顺序排列，每一列都按照从上到下的顺序排序，完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否包含该整数

public class find(){

public static boolean find(int arr[][],int keyNumber){

 int column =arr[0].length-1;
 int row = 0;
 while(column>0&&row<arr.length){
   if(arr[row][column]==keyNumber){
       return true;
   }  
  else if(arr[arr][column]>keyNumber){
      column--;
   } 
  else{
     row++;
   }         
 }

}
return false;
}
//测试find函数
public static void main(String args[]){
//测试这个数组
/*
* 1 2 8 9
* 2 4 9 12
* 4 7 10 13
* 6 8 11 15
*/
int array[][] = new int[4][4];
array[0][0]=1;
array[0][1]=2;
array[0][2]=8;
array[0][3]=9;
array[1][0]=2;
array[1][1]=4;
array[1][2]=9;
array[1][3]=12;
array[2][0]=4;
array[2][1]=7;
array[2][2]=10;
array[2][3]=13;
array[3][0]=6;
array[3][1]=8;
array[3][2]=11;
array[3][3]=15;
System.out.println(find(array,7));
System.out.println(find(array,5));
}

3,空格替换
题目描述： 请实现一个函数，将字符串的每个空格替换为"%20"。
例如输入"We are happy",则输出"We%20are%20happy."。

public class replaceBlank{

public String replace(String input){

StringBuilder build = new StringBuilder();
if(input==null||input.length()==0){
  return null;
}
for(int i=0;i<input.length();i++){
  
   if(input.charAt(i)==' '){
     builder.append("%");
     builder.append("2");
     builder.append("0");
   }else{
    builder.append(input.charAt(i));
   }
}
return builder.toString(); 

}
}

//测试用例
public static void main(String[] args){
ReplaceBlank test = new ReplaceBlank();

String str1=“We are happy”
System.out.println(test.replace(str1));

}

4,从尾到头打印链表
题目描述：输入一个链表的头结点，从头到尾反过来打印每个结点的值

//首先定义链表结构
class LinkNode{
LinkNode next;
int node_value;
}

public class PrintListReverse{
public void reverse(LinkNode headNode){
//用栈的思想来实现链表的倒叙输出
Stack stack = new Stack();
while(headNode!=null){
stack.push(headNode);
headNode = headNode.next;
}
while(!stack.isEmpty()){
System.out.println(stack.pop().node_value+"");
}
System.out.print();
}

public static void main(String[] args){

PrintListReverse plr = new PrintReverse();
LinkNode node1 = new LinkNode();
LinkNode node2 = new LinkNode();
LinkNode node3 = new LinkNode();

node1.next_value=1;
node2.next_value=2;
node3.next_value=3;

node1.next=node2;
node2.next=node3;
plr.reverse(node1);
}

}

4,题目描述:输入某二叉树的前序遍历和中序遍历结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不包含重复的数字。例如输入前序遍历序列:{1,2,4,7,3,5,6,8}和中序遍历{4,7,2,1,5,3,8,6},则重建出图中所示二叉树并且输出它的头结点。

重建的二叉树：

//定义二叉树节点
class BinaryTreeNode{
public int value;
public BinaryTreeNode leftNode;
public BinaryTreeNode rightNode;

//无参构造函数
public BinaryTreeNode{

}

//定义有参的构造函数
public BinaryTreeNode(int value){
this.value = value;
this.leftNode = null;
this.rightNode = null;
}
}

//构造二叉树
public Class ConstructBinaryTree{

public static BinaryTreeNode construct(int preOrder{},int inOrder{},int length) throws Exception{
   
  if(preOrder ==null||inOrder==null||length<0){
    return null;
  }
  return constructCore(preOrder,0,preOrder.length-1,inOrder,0,inOrder.length - 1);      
}

public static BinaryTreeNode constructCore(int preOrder{},
int startPreIndex, int endPreIndex, int inOrder{},
int startInIndex,int endInIndex)throws InvalidPutException{

//头结点的值
int rootValue = preOrder[startInIndex];

//构建一个只有一个根节点的二叉树
BinaryTreeNode root  = new BinaryTreeNode(rootValue);

//只有一个元素的情况下
if(startPreIndex == endPreIndex){
   if(startInIndex == endInIndex
    && preOrder[startInIndex] == inOrder[endInIndex]){
     System.out.println("只有一个元素");
     return root;
    }else{
      throw new InvalidPutException();
    }
 }

//最重要的一步：在中序遍历中找到根结点的索引
int rootInIndex = startInIndex;
while(rootInIndex<=endInIndex && inOrder[rootInIndex]!=rootValue){
     rootInIndex++;
}
if(rootInIndex == endInIndex && inOrder[rootInIndex]!=rootValue){
   throw new InvalidPutException();
}

//根结点的左子数的长度
int leftLength = rootInIndex - startInIndex;
//根节点的左子数的最右端的索引值
int leftPreEndIndex = startPreIndex + leftLength;    
//构建左子树
if(leftLength>0){
 root.leftNode = constructCore(preOrder,startPreIndex + 1,
    leftPreEndIndex, inOrder,startInIndex,rootInIndex - 1);
}
//说明根结点存在右子数
if(leftLength < endPreIndex - startPreIndex){
   root.rightNode = constructCore(preOrder,leftPreEndIndex+1,
   endPreIndex,inOrder,rootInIndex+1,endInIndex);
}     
return root;

}

//按照前序遍历打印二叉树的节点
public static void printPreBinaryTree(BinaryTreeNode root){
if(root ==null){
return;
}else{
System.out.println(root.value+"");
}

if(root.leftNode!=null){
 printPreBinaryTree(root.rightNode);
}
if(root.rightNode!=null){
 printPreBinaryTree(root.rightNode);
}

}

public static class InvalidPutException extends Exception {

      private static final long serialVersionUID = 1L;
}

public static void main(String[] args) throws Exception{
int preOrder[] = {1,2,4,7,3,5,6,8};
int inOrder[] = {4,7,2,1,5,3,8,6};
ConstructBinaryTree test = new ConstructBinaryTree();
printPreBinaryTree(test.construct(preOrder,inOrder,preOrder.length));
}

}

6,用两个栈实现队列
题目描述：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数appendTail和deleteHead,分别完成在队列尾部插入结点和在队列头部删除结点的功能。

public class constractQueue{

Stack stack1 = new Stack();
Stack stack2 = new Stack();

public void appendTail(int a){
stack1.push(a);
}

public void deleteHead() Throws Exception{
if(stack2.isEmpty){
if(!stack1.isEmpty){
stack2.push(stack1.pop());
}
}
if(stack2.isEmpty){
System.out.println(“队列为空不能删除”);
}
return stack2.pop();
}

public static void main(String args[]){

ConstractQueue test = new ConstractQueue();
//向空的队列中添加元素，删除元素
test.append(“1”);
System.out.println(test.deleteHead());
}
}

7,旋转数组的最小数字
题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1;
public class MinInReversingList{

public static int minElement(int array[]) throws Exception{

   //条判断
  if(array==null||array.length<=0){
    throw new Exception(Invalid parameters);
   }

  int left = 0;
  int right = array.length-1;
  int mid = left;
  while(array[left]>=array[right]){
    //跳出循环的条件
    if(right-left==1){
     mid = right;
     break;
     }
     mid = (left + right)/2;
     if(array[left]==array[mid] && array[mid] == array[right]){
         return minFromSortSearch(array);
      }else{
         //算法的核心思想
        if(array[mid]>array[left]){
          left = mid;
        }
        if(array[mid]<=array[right]){
         right = mid
        }
      }            
  }
   return array[right];

}
}
8,斐波那契数列
题目描述：写一个函数，输入n，求斐波那契数列的第n项，斐波那契数列的定义如下： n=0,f(n)=0 ;n=1,f(n)=1 n>1;f(n)=f(n-1)+f(n-2).
青蛙跳台阶的问题，也可以用裴波那契数列
package Fibonacci;

public class Fibonacci {

 public static long Fib2(int n) {
	       long FibOne = 0;
	       long FibTwo = 1;
	       long FibN = 0;
	       int result[] = { 0,1 };
	       if (n < 2) {
	           return result[n];
	       } else {
	           for (int i = 2; i <= n; i++) {
	               FibN = FibTwo + FibOne;
	               FibOne = FibTwo;
	               FibTwo = FibN;
	           }
	       }
	       return FibN;
	   }
	
	   public static void main(String[] args) {
	       // 用解法1求序列的第100项,直接不动了
	       // System.out.println(Fib1(100));
	       System.out.println(Fib2(2));
	   }

}
9，问题描述： 请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。例如把9表示成二进制是1001，有2位是1 因此如果输入9，该函数输出2;
public class NumbleOf1{

public int numble(int n ){
int count = 0;
int flag = 1;
while(flag!=0){
if((n&flag)!=0){
count++;
}
flag= flag<<1;
}
return count;
}

public static void main(String args){
NumbleOf1 test = new NumbleOf1();
System.out.println(test.numble(9));
}

}

10,问题描述：实现函数double power(double base,int exponent),求base的exponent次方。不能使用库函数，同时不需要考虑大数问题。

public class Power{

public double power(double base,int export){
double result = 0.0;
if(equal(base,0)&& export0){
System.out.println(“0的负数次幂没有意义”);
}
if(export0){
return result = 1.0;
}
if(export<0){
return unsignPower(base,-export);
}else{
return unsignPower(base,export);
}
return result;
}

public double unsignPower(double base,int export){
double result = 1.0;
for(int i=0;i<export;i++){
result = result * base;
}
return result;
}

//由于计算机有限的保留位数，因此当一个数与0相差0.000001时，默认为0，
public boolean equal(double numble1,double numble2){
if((numble1 - numble2>-0.000001)&&(numble1 - numble2<0.000001)){
return ture;
}
return false;
}
}