剑指offer
面试题4：二维数组中的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
代码：
public class Solution {
public boolean Find(int target, int [][] array) {
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
if(target==array[i][j]){
return true;
}
}
}
return false;
}
}
面试题5：替换空格
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
代码：
public class Solution {
public String replaceSpace(StringBuffer str) {
String str1=str.toString();
String str2=str1.replace(" ","%20");
return str2;
}
}
面试题6：从尾到头打印链表
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
代码：
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
public class Solution {
ArrayList<Integer> arrayList=new ArrayList<>();
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode!=null){
this.printListFromTailToHead(listNode.next);
arrayList.add(listNode.val);
}
return arrayList;
}
}
面试题7：重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
代码：
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
return root;
}
public TreeNode reConstructBinaryTree(int[] pre,int preStart,int preEnd,int[] in,int inStart,int inEnd){
//表示数组为空
if(preStart>preEnd || inStart>inEnd){
return null;
}
TreeNode root=new TreeNode(pre[preStart]);
for(int i=inStart;i<=inEnd;i++){
if(in[i]==pre[preStart]){
root.left=reConstructBinaryTree(pre,preStart+1,preStart+i-inStart,in,inStart,i-1);
root.right=reConstructBinaryTree(pre,i-inStart+preStart+1,preEnd,in,i+1,inEnd);
}
}
return root;
}
}
面试题9：用两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
代码：
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
//进队列的方法和栈是一样的
stack1.push(node);
}
public int pop() {
//如果第出栈为空那么我们就将第一个栈里面的元素进栈
if(stack2.isEmpty()){
while(!stack1.isEmpty()){
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}
面试题11：旋转数组中最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
代码：
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length==0){
return 0;
}else{
for(int i=0;i<array.length-1;i++){
if(array[i]>array[i+1]){
return array[i+1];
}else {
if(i==array.length-2){
return array[0];
}
}
}
}
return 0;
}
}
面试题10：斐波那契额数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
代码：
public class Solution {
public int Fibonacci(int n) {
if(n<0) {
return 0;
}else if(n==1||n==2){
return 1;
}
return Fibonacci(n-1)+Fibonacci(n-2);
}
}
面试题8：跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
代码：
public class Solution {
public int JumpFloor(int target) {
if(target<0){
return 0;
}else if(target==1){
return 1;
}else if(target==2){
return 2;
}
else {
int one=1;
int two=2;
int result=0;
for(int i=2;i<target;i++){
result = one+two;
one=two;
two=result;
}
return result;
}
}
}
面试题9：变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
代码：
public class Solution {
public int JumpFloorII(int target) {
if(target==0){
return 0;
}
int num=1;
return num<<(target-1);
}
}
面试题10：矩形覆盖
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
代码：
public class Solution {
public int RectCover(int target) {
if(target<=0){
return 0;
}
if(target==1){
return 1;
}
if(target==2){
return 2;
}
//其实质就是斐波那契数
//int result=RectCover(target-1)+RectCover(target-2);
int one=1;
int two=2;
int result=0;
for(int i=2;i<target;i++) {
result = one + two;
one = two;
two = result;
}
return result;
}
}
面试题15：二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
代码：
public class Solution {
public int NumberOf1(int n) {
int num=0;
String b=Integer.toBinaryString(n);
char[] c=b.toCharArray();
for(int i=0;i<c.length;i++){
if(c[i]=='1'){
num++;
}
}
return num;
}
}
面试题16：数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
代码：
public class Solution {
public double Power(double base, int exponent) {
double result=1;
if(exponent>0){
for(int i=1;i<=exponent;i++){
result=result*base;
if(result>1.7976931348623157E308){
System.out.println("已经超出了double类型的范围");
return -1;
}
}
return result;
}
if(exponent<0){
exponent=-exponent;
for(int i=1;i<=exponent;i++){
result=result*base;
if(result>1.7976931348623157E308){
System.out.println("已经超出了double类型的范围");
return -1;
}
}
result=1.0/result;
return result;
}else {
return 1;
}
}
}
面试题21：调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
代码：
public class Solution {
public void reOrderArray(int [] array) {
for(int i=0;i<array.length-1;i++){
for(int j=0;j<array.length-1-i;j++){
if(array[j]%2==0&&array[j+1]%2==1){
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
}
面试题22：链表中倒数第k个结点
输入一个链表，输出该链表中倒数第k个结点。
代码：
面试题24：反转链表
输入一个链表，反转链表后，输出新链表的表头。
代码：
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
if(head==null){
return null;
}
ListNode prev=null;
ListNode cur=head;
ListNode next=cur.next;
while(cur!=null){
cur.next=prev;
prev=cur;
cur=next;
if(next!=null){
next=next.next;
}
}
return prev;
}
}
面试题25：合并两个有序链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
代码：
/*
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 result=null;
if(list1==null){
return list2;
}
if(list2==null){
return list1;
}
if(list1.val<list2.val){
result=list1;
result.next=Merge(list1.next,list2);
}
if(list1.val>=list2.val){
result=list2;
result.next=Merge(list1,list2.next);
}
return result;
}
}
面试题17：树的子结构
输入两棵二叉树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){
return false;
}
if(root1==null&&root2!=null){
return false;
}
boolean result=false;
if(root1.val==root2.val){
result=isSameTree(root1,root2);
}
if(!result){
result=HasSubtree(root1.left,root2);
if(!result){
result=HasSubtree(root1.right,root2);
}
}
return result;
}
//在进行判断一个树是否为另外一个树的子树的时候我们首先需要直到如何判断两棵树的结构是相同的树
public boolean isSameTree(TreeNode root1,TreeNode root2){
if(root2==null){
return true;
}
if(root1==null&&root2!=null){
return false;
}
//下面是两个树都不为空树的情况
if(root1.val==root2.val){
return isSameTree(root1.left,root2.left) && isSameTree(root1.right,root2.right);
}
return false;
}
}
面试题27：二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
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;
}
TreeNode temp;
if(root!=null){
temp=root.left;
root.left=root.right;
root.right=temp;
if(root.left!=null){
Mirror(root.left);
}
if(root.right!=null){
Mirror(root.right);
}
}
}
}
面试题29：顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.
代码：
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printMatrix(int [][] matrix) {
//定义一个集合来存放按照题目顺序输出的集合元素
ArrayList<Integer> result=new ArrayList<>();
if(matrix==null||matrix.length==0){
return result;
}
printMatrixClockWisely(matrix, 0, 0, matrix.length - 1, matrix[0].length - 1, result);
return result;
}
public void printMatrixClockWisely(int[][] matrix,int startRow,int startCol,int endRow,int endCol,ArrayList<Integer> result){
if(startRow<endRow && startCol<endCol){
//从左向右的遍历
for(int j=startCol; j<=endCol; j++){
result.add(matrix[startRow][j]);
}
//从上到下的遍历
for(int i=startRow+1; i<=endRow-1; i++){
result.add(matrix[i][endCol]);
}
//从右向左
for(int j=endCol; j>=startCol; j--){
result.add(matrix[endRow][j]);
}
//从下向上
for(int i=endRow-1; i>=startRow+1; i--){
result.add(matrix[i][startCol]);
}
printMatrixClockWisely(matrix,startRow+1,startCol+1,endRow-1,endCol-1,result);
}else if(startRow==endRow && startCol<endCol){
//如果只有一行则直接打印这一行
for(int j=startCol;j<=endCol;j++){
result.add(matrix[startRow][j]);
}
}else if(startRow<endRow&&startCol==endCol){
//只有一列
for(int i=startRow;i<=endRow;i++){
result.add(matrix[i][startCol]);
}
}else if(startRow==endRow&&startCol==endCol){
result.add(matrix[startRow][startCol]);
}else{
return;
}
}
}
面试题30：包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
代码：
import java.util.Stack;
public class Solution {
//需要两个栈来实现这个功能：一个栈就是正常的进栈出栈，一个栈用来存放当前最小元素
Stack<Integer> stack1=new Stack<>();
Stack<Integer> min=new Stack<>();
public void push(int node) {
stack1.push(node);
if(min.isEmpty()){
min.push(node);
}else{
int top=min.peek();
if(node<top){
min.push(node);
}else{
min.push(top);
}
}
}
public void pop() {
//出栈就正常出栈
stack1.pop();
min.pop();
}
public int top() {
int topNum=stack1.peek();
return topNum;
}
public int min() {
int minNum=min.peek();
return minNum;
}
}
面试题31：栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
代码：
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
if(pushA.length==0||popA.length==0){
return false;
}
Stack<Integer> stack = new Stack<Integer>();
int j=0;
for(int i=0;i<popA.length;i++){
stack.push(pushA[i]);
while(j<popA.length&&stack.peek()==popA[j]){
stack.pop();
j++;
}
}
return stack.isEmpty()?true:false;
}
}
面试题32：从上往下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
代码：
import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
//首先定义一个集合，存放层序遍历二叉树以后的节点
ArrayList<Integer> list=new ArrayList<>();
if(root==null){
return list;
}
Queue<TreeNode> queue=new LinkedList<TreeNode>();
queue.add(root);
while(!queue.isEmpty()){
TreeNode t=queue.poll();
list.add(t.val);
if(t.left!=null){
queue.add(t.left);
}
if(t.right!=null){
queue.add(t.right);
}
}
return list;
}
}
面试题33：二叉搜索树的后序遍历序列
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
代码：
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
//首先我们需要分析二叉搜索树的特点，然后再进行分析后需遍历二叉搜索树的特点：
//就是后序遍历二叉搜索树，最后一个节点就是根节点，根节点的前面如果出现了比它大的节点
//那么这个节点以后数组里的所有节点都应该比它大，如果不满足那么就不是二叉搜索树的后序遍历的结果。
if(sequence.length==0){
return false;
}
return isTreeBST(sequence,0,sequence.length-1);
}
public boolean isTreeBST(int[] sequence,int start,int end){
if(end<=start){
return true;
}
int i;
for(i=start;i<end;i++){
if(sequence[i]>sequence[end]){
break;
}
}
for(int j=i;j<end;j++){
if(sequence[j]<sequence[end]){
return false;
}
}
//判断它的左右子树是不是二叉搜索树
return isTreeBST(sequence, start, i-1) && isTreeBST(sequence, i, end-1);
}
}
面试题34：二叉树中和为某一值的路径
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
代码：
import java.util.ArrayList;
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
// 全局变量，用于存储得到的每一个路径,它里面的元素是数
ArrayList<ArrayList<Integer>> resultsList = new ArrayList<ArrayList<Integer>>();
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
if(root==null){
return resultsList;
}
int curSum=0;
int index=0;
int[] path=new int[1000];
this.isTargetPath(root,target,curSum,path,index);
return this.resultsList;
}
/**
递归函数求解：
把根节点到叶节点路径上的值加起来
*/
public void isTargetPath(TreeNode eleNode,int target,int curSum,int[] path,int index){
if(eleNode==null){
return;
}
curSum+=eleNode.val;
path[index] = eleNode.val;
index++;
if(curSum==target&&eleNode.left==null&&eleNode.right==null){
//这个集合是存放满足条件的一条路径
ArrayList<Integer> pathList=new ArrayList<>();
for(int i=0;i<index;i++){
pathList.add(path[i]);
}
//这个是将满足条件的所有路径添加到集合里面
resultsList.add(pathList);
return;
}
if(curSum<target&&eleNode.left!=null){
this.isTargetPath(eleNode.left,target,curSum,path,index);
}
if(curSum<target&&eleNode.right!=null){
this.isTargetPath(eleNode.right,target,curSum,path,index);
}
}
}
面试题35：复杂链表的复制
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
代码：
/*
public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
RandomListNode(int label) {
this.label = label;
}
}
*/
public class Solution {
//这个题的重点是我们要将复制的过程分解为三个步骤：
//首先是普通的链表复制，并且将复制的链表连接在原链表的后面
//其次是复制指向任意节点的关系
//最后是将这个链表分解开，并返回复制的链表
//第一步
public void cloneNode(RandomListNode pHead){
RandomListNode pNode=pHead;
if(pNode!=null){
//开始复制链表
RandomListNode cloneNode=new RandomListNode(pNode.label);
cloneNode.next=pNode.next;
cloneNode.random=null;
pNode.next=cloneNode;
pNode=cloneNode.next;
}
}
//第二步：复制任意节点的指向
public void connectRandom(RandomListNode pHead){
RandomListNode pNode=pHead;
while(pNode!=null){
RandomListNode cloneNode=pNode.next;
if(pNode.random!=null){
cloneNode.random=pNode.random.next;
}
pNode=cloneNode.next;
}
}
//第三步：将复制好的链表分解为两个链表并且返回复制后的链表
public RandomListNode reConnectRandom(RandomListNode pHead){
RandomListNode pNode=pHead;
//复制链表的头节点
RandomListNode cloneHead=null;
//复制链表的当前操作节点
RandomListNode cloneNode=null;
//如果当前节点不为空，那么将节点的关系赋值准备好
if(pNode!=null){
cloneNode=cloneHead=pNode.next;
pNode.next=cloneNode.next;
pNode=pNode.next;
}
//现在开始拆分
while(pNode!=null){
cloneNode.next=pNode.next;
cloneNode=cloneNode.next;
pNode.next=cloneNode.next;
pNode=pNode.next;
}
return cloneHead;
}
public RandomListNode Clone(RandomListNode pHead){
this.cloneNode(pHead);
this.connectRandom(pHead);
return this.reConnectRandom(pHead);
}
}
面试题36：二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
代码：
面试题38：字符串的排列
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
代码：
import java.util.ArrayList;
import java.util.TreeSet;
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> result = new ArrayList<String>() ;
if(str==null || str.length()==0) { return result ; }
char[] chars = str.toCharArray() ;
TreeSet<String> temp = new TreeSet<>() ;
Permutation(chars, 0, temp);
result.addAll(temp) ;
return result ;
}
public void Permutation(char[] chars, int begin, TreeSet<String> result) {
if(chars==null || chars.length==0 || begin<0 || begin>chars.length-1) {
return ;
}
if(begin == chars.length-1) {
result.add(String.valueOf(chars)) ;
}else {
for(int i=begin ; i<=chars.length-1 ; i++) {
swap(chars, begin, i) ;
Permutation(chars, begin+1, result);
swap(chars, begin, i) ;
}
}
}
public void swap(char[] x, int a, int b) {
char t = x[a];
x[a] = x[b];
x[b] = t;
}
}
面试题39：数组中出现次数超多一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
代码：
import java.util.Arrays;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
int len=array.length;
if(len<1){
return 0;
}
int count=0;
//采用java数组里面的排序
Arrays.sort(array);
//根据数组的特性：可以知道数组中的数字出现了超过它长度的一半的数字一定排序后一定在数组中出现
int num=array[len/2];
for(int i=0;i<len;i++){
if(array[i]==num){
count++;
}
}
if(count<=len/2){
return 0;
}
return num;
}
}
面试题40：最小的k个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
代码：
import java.util.Arrays;
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> list=new ArrayList<>();
if(input.length==0||k==0||k>input.length){
return list;
}
Arrays.sort(input);
for(int i=0;i<k;i++){
list.add(input[i]);
}
return list;
}
}
面试题42：连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
代码：
public class Solution {
//定义一个全局变量来定义输入是否有效
boolean invaildInput=false;
public int FindGreatestSumOfSubArray(int[] array) {
if(array.length==0){
invaildInput=true;
return 0;
}
invaildInput=false;
int curSum=0;
//这个表示最大子数组之和
int greatestSum=array[0];
for(int i=0;i<array.length;i++){
//每进行一次加的操作就要进行判断当前的和与之前的和之间的大小
if(curSum<=0){
curSum=array[i];
}else{
curSum+=array[i];
}
if(curSum>greatestSum){
greatestSum=curSum;
}
}
return greatestSum;
}
}
面试题43：数组中1出现的次数
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
代码：
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int num=0;
for(int i=1;i<=n;i++){
num+=numOf1(i);
}
return num;
}
public int numOf1(int n){
int num=0;
while(n!=0){
if(n%10==1){
num++;
}
n=n/10;
}
return num;
}
}
面试题45：把数组排成最小的数
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
代码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Solution {
public String PrintMinNumber(int [] numbers) {
int n;
String s="";
ArrayList<Integer> list=new ArrayList<>();
n=numbers.length;
for(int i=0;i<n;i++){
//将数组中的元素添加到集合里面
list.add(numbers[i]);
}
//实现了Comparator接口的compare方法，将集合元素按照compare方法的规则进行排序
Collections.sort(list,new Comparator<Integer>(){//这个是函数式接口
//方法重载为：比较两个字符串的大小
@Override
public int compare(Integer str1, Integer str2) {
//与字符串连接的参数也会变成字符串
String s1=str1+""+str2;
String s2=str2+""+str1;
return s1.compareTo(s2);
}
});
//此时集合里面存放的是最小的字符串排列，遍历集合进行拼接，然后返回
for(int j:list){
s+=j;
}
return s;
}
}
面试题49：丑数
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
代码1：（超时）
public class Solution {
public int GetUglyNumber_Solution(int index) {
//注意：这个index表示有多少个丑数，但是它并不是我们真正的丑数，所以我们需要根据给定的index找到
//这个index对应的是哪个丑数
if(index<=0){
return 0;
}
int numbers=0;
//找到丑数的个数
int uglyFound=0;
while(uglyFound<index){
if(isUgly(numbers)){
uglyFound++;
}
}
return numbers;
}
//首先我们判断什么样的数是丑数：
public boolean isUgly(int numbers){
while(numbers%2==0){
numbers=numbers/2;
}
while(numbers%3==0){
numbers=numbers/3;
}
while(numbers%5==0){
numbers=numbers/5;
}
return (numbers==1)?true:false;
}
}
代码2：
//这个做法就是我们直接添加所有的是丑数的数，这样的话就不需要对每个数字进行判断
import java.util.*;
public class Solution {
public int GetUglyNumber_Solution(int index) {
if(index<=0){
return 0;
}
ArrayList<Integer> list=new ArrayList<Integer>();
list.add(1);
int i2=0;
int i3=0;
int i5=0;
while(list.size()<index){
//从1开始判断丑数的个数并且按照从小到大的顺序添加到这个链表里面
int m2=list.get(i2)*2;
int m3=list.get(i3)*3;
int m5=list.get(i5)*5;
int min=Math.min(m2,Math.min(m3,m5));
list.add(min);
//判断如果上次添加的是这个元素那么它的下标就应该加1
if(m2==min) i2++;
if(m3==min) i3++;
if(m5==min) i5++;
}
//获取链表中最后一个元素
return list.get(list.size()-1);
}
}
面试题50：第一次只出现一次的字符——HashMap的使用
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
代码：
import java.util.HashMap;
public class Solution {
public int FirstNotRepeatingChar(String str) {
//我们将字符串出现的次数装进HashMap里面
HashMap<Character,Integer> map=new HashMap<Character,Integer> ();
for(int i=0;i<str.length();i++){
char temp=str.charAt(i);
//下面进行判断是否已经有这个值了
if(map.containsKey(temp)){
int count=map.get(temp);
count++;
map.put(temp,count);
}else{//注意：如果这个地方不加else，那么每次执行都会执行到这个地方
//如果不包含就是第一次出现这个数字
map.put(temp,1);
}
}
//下面进行循环判断value为1的第一个key
for(int i=0;i<str.length();i++){
char ch=str.charAt(i);
if(map.get(ch)==1){
return i;
}
}
return -1;
}
}
面试题51：数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
题目保证输入的数组中没有的相同的数字
数据范围：
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5
代码：
import java.io.*;
import java.util.*;
public class Solution {
public int InversePairs(int [] array) {
if(array.length==0||array==null){
return 0;
}
int[] copy=new int[array.length];
for(int i=0;i<array.length;i++){
copy[i]=array[i];
}
int count=InversePairsCore(array,copy,0,array.length-1);
return count;
}
public int InversePairsCore(int[] array,int[] copy,int start,int end){
if(start==end){
//表示数组里面只有一个元素
copy[start]=array[start];
return 0;
}
//否则就将数组一分为二进行判断
int mid=(end+start)>>1;
int left=InversePairsCore(array,copy,start,mid)%1000000007;
int right=InversePairsCore(array,copy,mid+1,end)%1000000007;
int i=mid;//p1
int j=end;//p2
int copyIndex=end;//p3
int count=0;
while(i>=start&&j>=mid+1){
if(array[i]>array[j]){
copy[copyIndex--]=array[i--];
count=count+(j-mid);//逆序对的数目就是右边数组的长度
if(count>=1000000007){
count=count%1000000007;
}
}else{
copy[copyIndex--]=array[j--];
}
}
//最后还需要将data数组拷贝到copy数组里面
for(;i>=start;i--){
copy[copyIndex--]=array[i];
}
for(;j>=mid+1;j--){
copy[copyIndex--]=array[j];
}
for(int s=start;s<=end;s++){//最后需要将array数组进行更新操作
array[s]=copy[s];
}
return (count+left+right)%1000000007;
}
}
面试题52：两个链表的第一个公共结点
输入两个链表，找出它们的第一个公共结点。
代码：
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
if(pHead1==null||pHead2==null){
return null;
}
//先分别获取两个链表的长度
int len1=getListLength(pHead1);
int len2=getListLength(pHead2);
int diffLen=len1-len2;
ListNode pListHeadLong=pHead1;
ListNode pListHeadShort=pHead2;
if(len2>len1){
pListHeadLong=pHead2;
pListHeadShort=pHead1;
diffLen=len2-len1;
}
for(int i=0;i<diffLen;i++){
pListHeadLong=pListHeadLong.next;
}
while(pListHeadLong!=null&&pListHeadShort!=null&&pListHeadLong.val!=pListHeadShort.val){
pListHeadLong=pListHeadLong.next;
pListHeadShort=pListHeadShort.next;
}
ListNode commonCode=pListHeadLong;
return commonCode;
}
//获取链表长度
public int getListLength(ListNode head){
ListNode cur=head;
int len=0;
while(cur!=null){
len++;
cur=cur.next;
}
return len;
}
}
面试题53：数字在排序数组中出现的次数——出现这种一个数字对应次数，或者其他内容的就是两个关键字key和value就是用HashMap。
统计一个数字在排序数组中出现的次数。
代码：
import java.util.HashMap;
public class Solution {
public int GetNumberOfK(int [] array , int k) {
//首先这个数组是已经排好序了的，我们先统计数组里面数字出现的次数
if(array.length==0){
return 0;
}
//需要排出一种情况：就是这个数字在数组里面根本不存在
int flag=0;//设置一个标记位
for(int i=0;i<array.length;i++){
if(array[i]==k){
flag=1;
break;
}
}
if(flag==0){//没有出现过这个数字
return 0;
}else{
HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
for(int i=0;i<array.length;i++){
int key=array[i];
if(map.containsKey(key)){
int number=map.get(key);
number++;
map.put(key,number);
}else{
map.put(key,1);
}
}
//然后直接根据key取得对应value的值:注意可以取值的情况是这个值在集合里面是存在的否则就是错误的
int count=0;
count=map.get(k);
return count;
}
}
}
面试题55：二叉树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
代码：
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public int TreeDepth(TreeNode root) {
if(root==null){
return 0;
}
//这个是递归终止条件
if(root.left==null&&root.right==null){
return 1;
}
//这道题我们采用递归的算法进行求解：求得左子树的高度和右子树的高度，然后得到它们之间较大者加1就是二叉树的最大高度
int left=TreeDepth(root.left);
int right=TreeDepth(root.right);
return left>right?(left+1):(right+1);
}
}
面试题56：平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
代码：
import java.lang.*;
public class Solution {
//首先在做题之前我们需要知道什么是平衡二叉树：平衡二叉树就是左右子树的深度差值小于等于1
public boolean IsBalanced_Solution(TreeNode root) {
if(root==null){
return true;
}
if(root.left==null&&root.right==null){
return true;
}
int leftDepth=depthTree(root.left);
int rightDepth=depthTree(root.right);
int diff=Math.abs(leftDepth-rightDepth);
return diff<=1?true:false;
}
//所以我们需要一个求得二叉树深度的函数
public int depthTree(TreeNode root){
if(root==null){
return 0;
}
if(root.left==null&&root.right==null){
return 1;
}
int left=depthTree(root.left);
int right=depthTree(root.right);
return left>right?(left+1):(right+1);
}
}
面试题56：数组中只出现一次的数字——难题
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
代码：
//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
if(array.length < 2) return ;
int myxor = 0;
int flag = 1;
for(int i = 0 ; i < array.length; ++ i )
myxor ^= array[i];
while((myxor & flag) == 0) flag <<= 1;
// num1[0] = myxor;
//num2[0] = myxor;
for(int i = 0; i < array.length; ++ i ){
if((flag & array[i]) == 0) num2[0]^= array[i];
else num1[0]^= array[i];
}
}
}
面试题57：和为S的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
代码：
import java.util.ArrayList;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
//这道题最总要的就是理解题意：怎么样实现有序的进行序列和的相加，我们采用双指针的方法
ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> list=new ArrayList<>();
//(1)首先是如果这个传入的参数小于3，那么绝对不会满足题意出现两个数字之和等于它
if(sum<3){
return res;
}
int small=1;
int big=2;
int cursum=small+big;
int mid=(1+sum)/2;
list.add(small);
list.add(big);
while(small<mid){
if(cursum==sum){
res.add(new ArrayList(list));
big++;
cursum+=big;
list.add(big);
}
else if(cursum < sum){
big ++;
cursum += big;
list.add(big);
}else {
cursum -= small;
list.remove(new Integer(small));
small ++;
}
}
return res;
}
}
面试题58：和为S的两个数字
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。
代码：
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
//还是采用快慢指针的方法，我们进行两个数的相加
ArrayList<Integer> res=new ArrayList<>();
if(array.length<1){
return res;
}
int small=0;
int big=array.length-1;
while(big>small){
int cursum=array[big]+array[small];
if(cursum==sum){
break;
}else if(cursum>sum){
big--;
}else{
small++;
}
}
if(array[small]<array[big]){
res.add(array[small]);
res.add(array[big]);
}
return res;
}
}
面试题59：左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
代码：
import java.util.Queue;
import java.util.LinkedList;
public class Solution {
public String LeftRotateString(String str,int n) {
//如果这个str不是字符串就返回空字符串
if(str.length()==0){
return str;
}
//根据这个题的特性我们可以采用队列来进行实现
Queue<Character> queue=new LinkedList<>();
//首先把这个字符串转化为字符
for(int i=0;i<str.length();i++){
queue.add(str.charAt(i));
}
//现在再根据n等于几，将这个队列前面的字符移动到后面
while(n>0){
Character ch=queue.poll();
queue.add(ch);
--n;
}
//下面就是将这个队列里面的元素取出来转化为String
StringBuilder sb=new StringBuilder();
while(!queue.isEmpty()){
char temp=queue.poll();
sb.append(temp);
}
String res=sb.toString();
return res;
}
}
面试题60：翻转单词顺序序列
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
代码：
public class Solution {
public String ReverseSentence(String str) {
//特殊情况
if(str==null){
return null;
}
if(str.trim().equals("")){
return str;
}
//首先进行整体的翻转，然后再进行单个字符串的反转
str=reverse(str);
//然后再度每个字符串进行翻转
String[] temp=str.split(" ");//以空格为标准将字符串进行分割
for(int i=0;i<temp.length;i++){
temp[i]=reverse(temp[i]);
}
//再将经过翻转以后的字符串进行拼接
StringBuilder res=new StringBuilder();
for(int i=0;i<temp.length;i++){
res.append(temp[i]);
res.append(" ");
}
//但是最后这个空格需要去掉
String resString=res.toString();
resString=resString.trim();//去掉开头结尾的空格
return resString;
}
public String reverse(String str){
StringBuilder s=new StringBuilder();
int i=str.length()-1;
while(i>=0){
s.append(str.charAt(i));
i--;
}
return s.toString();
}
}
面试题61：扑克牌顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
代码：
import java.util.*;
/*
1.分析可以知道如果0的个数大于等于间隔数都是顺子，此外需要注意如果出现了对子那么就一定不是顺子
2.统计0的个数
3.统计间隔数
4.进行比较
*/
public class Solution {
public boolean isContinuous(int [] numbers) {
if(numbers==null||numbers.length==0){
return false;
}
Arrays.sort(numbers);
int numberOfZero=0;//数组在0的个数
int numberOfGap=0;//数组中不连续的间隔
//统计0的个数
for(int i=0;i<numbers.length&&numbers[i]==0;i++){
++numberOfZero;
}
//统计数组中的间隔数目
int small=numberOfZero;//下标
int big=small+1;
while(big<numbers.length){
if(numbers[small]==numbers[big]){//出现对子就不可能是顺子
return false;
}
numberOfGap+=numbers[big]-numbers[small]-1;//1-3:3-1-1=1相差一个2
small=big;
++big;
}
return (numberOfGap<=numberOfZero)?true:false;
}
}
面试题62：孩子们的游戏（圆圈中最后剩下的数——约瑟夫环）
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
代码：
import java.util.ArrayList;
public class Solution {
public int LastRemaining_Solution(int n, int m) {
if(m==0||n==0){
return -1;
}
//这道题目就是约瑟夫环的题型，我们可以采用一个唤醒链表来实现，最后一个还在链表里面的这个数就是最后一个数
ArrayList<Integer> list=new ArrayList<>();
//将这n个数装进链表里面
for(int i=0;i<n;i++){
list.add(i);
}
int index=-1;
while(list.size()>1){//表示链表里面的数字剩余的大于1个数
index=(index+m)%list.size();
list.remove(index);
index--;
}
return list.get(0);
}
}
面试题64：求1+2+3+……+n
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
代码：
public class Solution {
public int Sum_Solution(int n) {
/*
方法一：我们通过我们实际的数字对该题进行分析以后可以得到我们这个加法的一些特性
就能知道我们可以采用数学函数来解决这个问题
*/
// int sum=(int)(Math.pow(n,2)+n);
// sum=sum>>1;
// return sum;
/*
方法2：这个题本来最初的想法就是使用循环和递归来实现，但是因为限制我们使用循环的关键字
但是我们可以通过短路来实现我们的递归终止条件
*/
int sum=n;
boolean ans=(n>0)&&((sum+=Sum_Solution(n-1))>0);
return sum;
}
}
面试题65：不用加减乘除做加法
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
代码：
public class Solution {
public int Add(int num1,int num2) {
/*
首先看十进制是如何做的： 5+7=12，三步走
第一步：相加各位的值，不算进位，得到2。
第二步：计算进位值，得到10. 如果这一步的进位值为0，那么第一步得到的值就是最终结果。
第三步：重复上述两步，只是相加的值变成上述两步的得到的结果2和10，得到12。
同样我们可以用三步走的方式计算二进制值相加：
第一步，5->101，7->111 第一步：相加各位的值，不算进位，得到010，二进制每位相加就相当于各位做异或操作，101^111。
第二步：计算进位值，得到1010，相当于各位做与操作得到101，再向左移一位得到1010，(101&111)<<1。
第三步重复上述两步， 各位相加 010^1010=1000，进位值为100=(010&1010)<<1。
继续重复上述两步：1000^100 = 1100，进位值为0，跳出循环，1100为最终结果。
*/
while(num2!=0){
int temp=num1^num2;//异或操作
num2=(num1&num2)<<1;
num1=temp;
}
return num1;
}
}
面试题：把字符串转换成整数
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
代码：
public class Solution {
public int StrToInt(String str) {
//首先进行判断这个传入的字符串是否为空
if(str.equals("")||str.length()==0){
return 0;
}
//接下来先判断符号位
int fuhao=0;//用来标记符号位到底是正还是负的
char[] ch=str.toCharArray();
if(ch[0]=='-'){
fuhao=1;
}
int sum=0;//用来记录我们转化为整数的结果
for(int i=fuhao;i<ch.length;i++){
if(ch[i]=='+') continue;//终止本次循环
if(ch[i]<48||ch[i]>57) return 0;
//下面这条语句是相加的关键：每次进行一次乘10相当于是扩大的一个级别，从个位-->十位-->百位
sum=sum*10+(ch[i]-48);
}
return fuhao==0?sum:sum*-1;
}
}
面试题：数组中的重复数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
代码：
public class Solution {
// Parameters:
// numbers: an array of integers
// length: the length of array numbers
// duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
// Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
// 这里要特别注意~返回任意重复的一个，赋值duplication[0]
// Return value: true if the input is valid, and there are some duplications in the array number
// otherwise false
public boolean duplicate(int numbers[],int length,int [] duplication) {
//注意：我们的返回值是任意的一个重复的值
if(length==0 || length==1){
return false;
}
//采用双指针两层遍历
for(int i=0;i<length-1;i++){
int slow=numbers[i];
for(int j=i+1;j<length;j++){
int fast=numbers[j];
if(slow==fast){
duplication[0]=slow;
return true;
}
}
}
return false;
}
}
面试题66：构建乘积数组
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。
代码：
import java.util.ArrayList;
public class Solution {
public int[] multiply(int[] A) {
int length=A.length;
int[] B=new int[length];
if(B.length!=0){
B[0]=1;
for(int i=1;i<length;i++){
B[i]=B[i-1]*A[i-1];
}
int temp=1;
for(int j=length-2;j>=0;j--){
temp*=A[j+1];
B[j]*=temp;
}
}
return B;
}
}
面试题19：正则表达式匹配
请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配。
代码：
public class Solution {
public boolean match(char[] str, char[] pattern){
if (str == null || pattern == null) {
return false;
}
int strIndex = 0;
int patternIndex = 0;
return matchCore(str, strIndex, pattern, patternIndex);
}
public boolean matchCore(char[] str, int strIndex, char[] pattern, int patternIndex) {
//str到尾，pattern到尾，匹配成功
if (strIndex == str.length && patternIndex == pattern.length) {
return true;
}
//str未到尾，pattern到尾，匹配失败
if (strIndex != str.length && patternIndex == pattern.length) {
return false;
}
//str到尾，pattern未到尾(不一定匹配失败，因为a*可以匹配0个字符)
if (strIndex == str.length && patternIndex != pattern.length) {
//只有pattern剩下的部分类似a*b*c*的形式，才匹配成功
if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] == '*') {
return matchCore(str, strIndex, pattern, patternIndex + 2);
}
return false;
}
//str未到尾，pattern未到尾
if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] == '*') {
if (pattern[patternIndex] == str[strIndex] || (pattern[patternIndex] == '.' && strIndex != str.length)) {
return matchCore(str, strIndex, pattern, patternIndex + 2)//*匹配0个，跳过
|| matchCore(str, strIndex + 1, pattern, patternIndex + 2)//*匹配1个，跳过
|| matchCore(str, strIndex + 1, pattern, patternIndex);//*匹配1个，再匹配str中的下一个
} else {
//直接跳过*（*匹配到0个）
return matchCore(str, strIndex, pattern, patternIndex + 2);
}
}
if (pattern[patternIndex] == str[strIndex] || (pattern[patternIndex] == '.' && strIndex != str.length)) {
return matchCore(str, strIndex + 1, pattern, patternIndex + 1);
}
return false;
}
}
面试题20：表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
代码：
public class Solution {
//所有可能出现的情况
// A[.[B]][e|EC]或者.B[e|EC],注意B是一个无符号整数
private int index=0;
public boolean isNumeric(char[] str) {
if(str.length<1) return false;
boolean flag = scanInteger(str);
//如果出现'.'，则接下来是数字的小数部分
if (index < str.length && str[index] == '.') {
index++;
//下面一行代码用||的原因：
//1.小数可以没有整数部分，如.123==0.123
//2.小数点后面可以没有数字，如223.==223.0
//3.当然，小数点前面和后面都可以有数字
flag = scanUnsignedInteger(str) || flag;
}
//如果出现'e'或者'E',则接下来是数字的指数部分
if (index < str.length && (str[index] == 'E' || str[index] == 'e')) {
index++;
//下面一行代码用&&的原因：
//1.当e或者E前面没有数字的时候表示整个字符串不是数值类型
//2.当e或者E后面没有数字的时候，整个字符串不是数值类型
flag = flag && scanInteger(str);
}
return flag && index == str.length;
}
//函数scanInteger扫描可以表示正负的'+'或者'-'位起始位置的0——9的数位，类似于一个可能带正负符号的整数，
//用来匹配前面的A和C部分
private boolean scanInteger(char[] str){
if (index < str.length && (str[index] == '+' || str[index] == '-') )
index++;
return scanUnsignedInteger(str);
}
//函数scanUnsignedInteger用来扫描字符串中0——9的数位（类似于一个无符号整数），可以用来匹配前面数值模式中的B部分
private boolean scanUnsignedInteger(char[] str){
int start = index;
while (index < str.length && str[index] >= '0' && str[index] <= '9')
index++;
return start < index; //是否存在整数
}
}
面试题：字符流中第一个不重复的字符
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符。
代码：
import java.util.HashMap;
import java.util.ArrayList;
public class Solution {
//定义一个HashMap来存放字出现的字符串以及该字符串出现的次数
HashMap<Character,Integer> map=new HashMap<>();
//定义一个ArrayList用来存放这个字符流里面存在的字符，然后方便我们取出进行判断
ArrayList list=new ArrayList();
//Insert one char from stringstream
public void Insert(char ch)
{
if(!map.containsKey(ch)){
map.put(ch,1);
list.add(ch);
}else{
map.put(ch,map.get(ch)+1);
}
}
//return the first appearence once char in current stringstream
public char FirstAppearingOnce()
{
for(int i=0;i<list.size();i++){
if(map.get(list.get(i))==1){
return (char)list.get(i);
}
}
return '#';
}
}
面试题：链表中环的入口结点
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
代码：
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ListNode EntryNodeOfLoop(ListNode pHead)
{
if(pHead==null||pHead.next==null||pHead.next.next==null){
return null;
}
ListNode slow=pHead.next;
ListNode fast=pHead.next.next;
//判断是否有环
while(slow!=fast){
if(fast.next!=null&&fast.next.next!=null){
fast=fast.next.next;
slow=slow.next;
}else{
return null;
}
}
//出了循环就表示有环，这个时候就进行判断入口节点：第一个相遇的结点就是入口结点
fast=pHead;
while(fast!=slow){
fast=fast.next;
slow=slow.next;
}
return slow;
}
}
面试题：二叉树的下一个结点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
代码：
/*
public class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null;
TreeLinkNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public TreeLinkNode GetNext(TreeLinkNode pNode)
{
if(pNode==null){
return null;
}
//如果有右子树，就找右子树的最左结点
if(pNode.right!=null){
pNode=pNode.right;
while(pNode.left!=null){
pNode=pNode.left;
}
return pNode;
}
//如果没有右子树，就找第一个当前结点是父节点的左子节点
//这道题里面定义的next是一个父子节点
while(pNode.next!=null){
if(pNode.next.left==pNode){
return pNode.next;
}
pNode=pNode.next;
}
return null;
}
}
面试题：对称的二叉树
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
代码：
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
boolean isSymmetrical(TreeNode pRoot)
{
//采用递归的算法：我们知道对称的二叉树就是出去根节点以后其他的结点左右的值都是相等的
if(pRoot==null){
return true;
}
return isSymmetrical(pRoot.left,pRoot.right);
}
boolean isSymmetrical(TreeNode left,TreeNode right){
if(left==null&&right==null) return true;
if(left==null||right==null) return false;
return left.val==right.val//为镜像二叉树的条件就是左右子树的值相等
&&isSymmetrical(left.left,right.right)//其次是镜像二叉树的左右子树还是对称的二叉树
&&isSymmetrical(left.right,right.left);
}
}
面试题：按照之字形顺序打印二叉树
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
代码：
import java.util.ArrayList;
import java.util.Stack;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
//采用两个栈来实现：一个栈用来存放奇数行结点（先存放右子树再存放左子树，因为对于栈来说它出栈的顺序正好是和进栈的顺序相同的）
//一个用来存放偶数行结点（先存放左子树再存放右子树）
int layer=1;//表示现在在第几层
Stack<TreeNode> s1=new Stack<>();
s1.push(pRoot);
Stack<TreeNode> s2=new Stack<>();
ArrayList<ArrayList<Integer>> ret=new ArrayList<ArrayList<Integer>>();
while(!s1.isEmpty()||!s2.isEmpty()){
if(layer%2==1){//表示奇数层
ArrayList<Integer> list=new ArrayList<>();
while(!s1.isEmpty()){
TreeNode node=s1.pop();
if(node!=null){
list.add(node.val);
s2.push(node.left);//当前层是奇数层那么它的下一层就是偶数层
s2.push(node.right);
}
}
if(!list.isEmpty()){
ret.add(list);
layer++;
}
}else{//否则是偶数层
ArrayList<Integer> list=new ArrayList<>();
while(!s2.isEmpty()){
TreeNode node=s2.pop();
if(node!=null){
list.add(node.val);
s1.push(node.right);
s1.push(node.left);
}
}
if(!list.isEmpty()){
ret.add(list);
layer++;
}
}
}
return ret;
}
}
面试题：把二叉树打印成多行
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
代码：
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
/**
在二叉树的层序遍历上面多了一个判定当前层已经打印和总共结点个数之间的关系，因为它需要将每一层的结点存放到一个list里面
而层序遍历其实是将所有的结点按照顺序存放到一个list里面的，所以这个地方就是区别点。
**/
ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
//采用递归的方法将从根节点开始往下按照从左向右的顺序进行递归调用
ArrayList<ArrayList<Integer>> ret=new ArrayList<ArrayList<Integer>>();
if(pRoot==null){
return ret;
}
Queue<TreeNode> queue=new LinkedList<>();
queue.add(pRoot);
int count;//记录当前层已经打印的个数
int last;//记录当前层一共有多少个
while(!queue.isEmpty()){
count=0;
last=queue.size();
ArrayList<Integer> list=new ArrayList<>();
//打印一层
while(count<last){
TreeNode node=queue.poll();
list.add(node.val);
count++;
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
}
ret.add(list);
}
return ret;
}
}
面试题：序列化二叉树
请实现两个函数，分别用来序列化和反序列化二叉树。
代码：
import java.util.Queue;
import java.util.LinkedList;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
/**
序列化和反序列化二叉树
二叉树被记录为文件的过程叫作二叉树的序列化，通过文件内容重建远原来
的二叉树的过程叫做二叉树反序列化。
一般情况下，需要采用前/后序遍历和中序遍历才能确定一个二叉树，但是其实可以只采用前序遍历（从根节点开始）
将空结点（null）输出为一个特殊符号(如"$"),就可以确定一个二叉树了。
序列化思路：将二叉树序列化为字符串，就是前序遍历的过程，遇见空结点时，序列化为"$"，每个结点间使用逗号分隔开。
反序列化思路：将字符串反序列化为二叉树，也使用前序遍历，遇见一个新数字(或者"$")就建立一个新结点，不过需要注意
的是，数字可能不只是个数字，因此创建了一个全局int变量index（在字符串上移动的指针），以便于截取字符串中当前的
结点值。
**/
String Serialize(TreeNode root) {
//通过前序遍历实现
StringBuilder sb=new StringBuilder();
if(root==null){
sb.append("$,");
}else{
sb.append(root.val+",");
sb.append(Serialize(root.left));
sb.append(Serialize(root.right));
}
return sb.toString();
}
int index=0;
TreeNode Deserialize(String str) {
//将序列化的二叉树元素分别保存到数组
String[] values=str.split(",");
//创建队列
Queue<String> queue=new LinkedList<>();
//循环二叉树元素字符加入队列中
for(int i=0;i<values.length;i++){
queue.add(values[i]);
}
/*创建二叉树*/
return reconPreOrder(queue);
}
/*根据队列创建二叉树*/
public TreeNode reconPreOrder(Queue<String> queue){
//从队列取出头元素并删除
String value=queue.poll();
//如果没有数据则退出递归
if(value.equals("$")) return null;
TreeNode head=new TreeNode(Integer.valueOf(value));
//递归得到当前孩子的左节点（遇到“$”结束）
head.left=reconPreOrder(queue);
//递归得到当前孩子的右节点（遇到“$”结束）
head.right=reconPreOrder(queue);
return head;
}
}
面试题：二叉搜索树的第k个结点
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
代码：
import java.util.HashMap;
import java.util.Stack;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
// int count=0;//计数器
//第一种：递归算法
// TreeNode KthNode(TreeNode pRoot, int k)
// {
// if(pRoot==null){
// return null;
// }
// //左子树
// TreeNode node=KthNode(pRoot.left,k);
// if(node!=null) return node;
// //根节点
// if(++count==k) return pRoot;
// //右子树
// node=KthNode(pRoot.right,k);
// if(node!=null) return node;
// return null;
// }
//第二种：非递归算法
TreeNode KthNode(TreeNode pRoot, int k){
if(pRoot==null||k==0) return null;
int count=0;
Stack<TreeNode> stack=new Stack<>();
while(pRoot!=null||!stack.isEmpty()){
//按照中序遍历进行访问二叉树
while(pRoot!=null){
stack.push(pRoot);//这个地方只是先把结点放进栈里面
pRoot=pRoot.left;//左子树
}
pRoot=stack.pop();//根节点
count++;
if(count==k) return pRoot;//右子树
pRoot=pRoot.right;
}
return null;
}
}
面试题：滑动窗口的最大值
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
代码：
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> maxInWindows(int [] num, int size)
{
ArrayList<Integer> list=new ArrayList<>();
if(size>num.length||size==0){
return list;
}
int index=0;
while((index+size)<=num.length){
int[] arr=new int[size];
for(int i=index,j=0;i<index+size;i++,j++){
arr[j]=num[i];
}
int temp=getMax(arr);
list.add(temp);
index++;
}
return list;
}
//寻找数组里面的最大值
public int getMax(int[] array){
int max=array[0];
for(int i=0;i<array.length;i++){
if(array[i]>max){
max=array[i];
}
}
return max;
}
}
【剑指offer】java实现
最新推荐文章于 2021-10-31 15:31:38 发布
2333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
