2016.12.11起，每日练习1-2道剑指offer算法题，为了监督自己，记录每天练习的题目。
1.二维数组中的查找(2016.12.11)
题目描述
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路
矩阵是有序的，从左到右，从上到下递增，从每个元素来看，向右是增加，向上是减小。所以有以下思路，从左下角出发开始比较，比给定数大，向上移，反之，向右移，直到右上角为止。时间复杂度为m+n(m为行数，n为列数)。（我想到的就只能是二分查找了）
答案
public class Solution {
public boolean Find(int target, int [][] array) {
int col = array[0].length;
int i = array.length-1;
int j = 0;
while(i>=0&&j<col){
if(array[i][j]<target){
j++;
}else if(array[i][j]>target){
i--;
}else{
return true;
}
}
return false;
}
}2.替换空格(2016.12.11)
题目描述
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路
题意不明，理解为只能在原有的字符串上进行操作，从后往前替换，每个字符只移动一次，效率高，但要先遍历一遍空格出现的次数，计算所需空间。
答案
public class Solution {
public String replaceSpace(StringBuffer str) {
int spaceNum = 0;
for(int i=0;i<str.length();i++){
if(str.charAt(i)==' ')
spaceNum++;
}
int oldSubscript = str.length()-1;
int len = str.length() + spaceNum*2;
int subscript= len-1;
str.setLength(len);
for(;subscript>=0 && subscript<len;--oldSubscript){
if(str.charAt(oldSubscript ) == ' '){
str.setCharAt(subscript--, '0');
str.setCharAt(subscript--, '2');
str.setCharAt(subscript--, '%');
}else{
str.setCharAt(subscript--, str.charAt(oldSubscript ));
}
}
return str.toString();
}
}3.从尾到头打印链表(2016.12.12)
题目描述
入一个链表，从尾到头打印链表每个节点的值。
思路
利用栈先进后出的特点，实现此功能。
答案
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.Stack;
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<Integer> stack = new Stack<>();
while(listNode!=null)
{
stack.push(listNode.val);
listNode=listNode.next;
}
ArrayList<Integer> arrayList = new ArrayList<>();
while(!stack.isEmpty())
{
arrayList.add(stack.pop());
}
return arrayList;
}
}4.重建二叉树(2016.12.13)
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路
前序遍历的第一个节点是根节点，找到中序遍历根节点的位置为i，则i的左侧和右侧分别是左子树和右子树的中序遍历，前序遍历的2到i位置，和i右侧分别是左子树和右子树的前序遍历，左右分别递归()。
答案
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.Arrays;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if(pre.length==0){
return null;
}
TreeNode root = new TreeNode(pre[0]);
for(int i=0;i<pre.length;i++){
if(in[i]==pre[0]){
root.left=reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+1), Arrays.copyOfRange(in, 0, i));
root.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
}
}
return root;
}
}5.用两个栈实现队列(2016.12.14)
题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路
栈A负责push，栈B负责pop，入队时，元素进栈A。出队时，判断栈B是否为空，如果不为空，直接出栈B，如果为空，栈A中的元素全部弹出进栈B，栈B出栈。
如果是两个队列实现栈：入栈时,将元素进队列A。出栈时，判断队列A中元素的个数是否为1，如果等于1，则出队列，否则将队列A中的元素 以此出队列并放入队列B，直到队列A中的元素留下一个，然后队列A出队列，再把 队列B中的元素出队列以此放入队列A中。
答案
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(stack1.empty()&&stack2.empty()){
throw new RuntimeException("Queue is empty!");
}
if(stack2.empty()){
while(!stack1.empty()){
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}6.旋转数组的最小数字(2016.12.15)
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
思路
从左向右查找，当出现右边比左边小时，即为最小值，考虑边界情况和数组为空或长度为1时即可。二分查找效率更高，应该是题目的本意。
答案
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length==0){
return 0;
}
if(array.length==1){
return array[0];
}
for(int i=0;i<array.length-2;i++){
if(array[i]>array[i+1]){
return array[i+1];
}else{
if(i==array.length-2){
return array[0];
}
}
}
return 0;
}
}7.斐波那契数列(2016.12.19)
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
n<=39
思路
使用递归的话，不保留中间计算结果，会存在大量的重复计算，容易造成Stack Overflow,所以使用循环。
答案
public class Solution {
public int Fibonacci(int n) {
int a =1,b = 1;
if(n==0){
return 0;
}else if(n==1||n==2){
return 1;
}
n-=2;
while(n-->0){
int temp = a;
a = b;
b = a + temp;
}
return b;
}
}8.跳台阶(2016.12.20)
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路
n为1时，有1种跳法，n为2时，有2种跳法。n>2时，如果最后一跳是跳1级台阶，前n-1级台阶有f(n-1)种跳法，最后一跳是跳2级台阶，前n-2级台阶有f(n-2)种跳法。综上，这是一个斐波那契数列。同上一题。
答案
public class Solution {
public int JumpFloor(int target) {
int a = 1,b = 2;
if (target==1){
return 1;
}
if(target==2){
return 2;
}
target-=2;
while(target-->0){
int temp = a;
a = b;
b = a + temp;
}
return b;
}
}9.变态跳台阶(2016.12.22)
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路
定义跳n级台阶时，跳法有f(n)种，直接跳n级，是一种跳法。如果最后一跳是跳1级，前n-1级台阶有f(n-1)种台阶，如果最后一跳是跳级2级，前n-2级台阶有f(n-2)种跳法，所以，当n>=2时，有f(n)=f(n-1)+……+f(1)+1;n=1时，显然有f(1)=1;当n>2时，f(n-1)=f(n-2)+……+f(1)+1;所以，f(n)=2*f(n-1)。
综上，我们有：f(n)=1,n=1;
= 2f(n-1),n>1;
即f(n)=2^(n-1)，但这样就没意思了。看到有人一行代码，return 1<<–target。
答案
public class Solution {
public int JumpFloorII(int target) {
if(target==0)
{
return 0;
}
int num=1;
for(int i=1;i<target;i++)
{
num+=JumpFloorII(i);
}
return num;
}
}10.矩阵覆盖(2016.12.22)
题目描述
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
思路
n=1时，f(n)=1;n=2时，f(n)=2。当n>2时，最后一列竖着放一个，前面有f(n-1)种放法，最后两列横着放两个，前面有f(n-2)种放法，综上f(n)=f(n-1)+f(n-2);跟第8题一样。
答案
public class Solution {
public int RectCover(int target) {
int a = 1,b = 2;
if(target==0){
return 0;
}
if (target==1){
return 1;
}
if(target==2){
return 2;
}
target-=2;
while(target-->0){
int temp = a;
a = b;
b = a + temp;
}
return b;
}
}11.二进制中1的个数(2016.12.25)
题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路
看到的一个非常巧妙的方法，如果一个数大于0，则这个数的二进制一定包含1，把这个整数减1后，这个数最右边的1会变成0，这个1后面的所有0都会变成1(如果有的话)，这个1前面的所有数字都不会受影响，我们把n和n-1进行或运算时，这个1和后面的所有位置都变成了0，整个数的二进制1的个数少了一个，重复该计算，直到数字变成0，计算的次数就是二进制中1的个数。
答案
public class Solution {
public int NumberOf1(int n) {
int count=0;
while(n!=0)
{
++count;
n=(n-1)&n;
}
return count;
}
}12.数值的整数次方(2016.12.25)
题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
思路
直接连乘的的复杂度为O(n)，再求高次幂时，可以把指数转换成二进制，例如求a^13时，a^13=a^1101=a^1000*a^100*a^1。通过&1和>>1来逐位读取这个指数，为1时将该位代表的乘数累乘到最终结果。如果exponent为负数，求base的-exponent次方，再求倒。
答案
public class Solution {
public double Power(double base, int n) {
double res = 1,curr = base;
int exponent;
if(n>0){
exponent = n;
}else if(n<0){
exponent = -n;
}else{
return 1;
}
while(exponent!=0){
if((exponent&1)==1)
res*=curr;
curr*=curr;
exponent>>=1;
}
return n>=0?res:(1/res);
}
}13.调整数组顺序使奇数位于偶数前面(2016.12.27)
题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
思路
类似于冒泡法，前面是偶数，后面是奇数就交换。
答案
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;
}
}
}
}
}14.链表中倒数第k个节点(2016.12.27)
题目描述
输入一个链表，输出该链表中倒数第k个结点。
思路
新建两个指针指向链表头节点，第一个先向后走k次，两个指针同时向后走，当第一个指针指向空时，第二个指针指向倒数第k个节点。
答案
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
if(head==null||k<=0){
return null;
}
ListNode first = head;
ListNode second = head;
for(int i=1;i<k;i++)
{
if(first.next!=null){
first=first.next;
}else{
return null;
}
}
while(first.next!=null)
{
first=first.next;
second=second.next;
}
return second;
}
}15. 反转链表(2016.12.27)
题目描述
输入一个链表，反转链表后，输出链表的所有元素。
思路
从原链表取出一个节点，一个指针向后走一步，取出的节点指向新的链表的头节点，直到取完节点为止。
答案
public class Solution {
public ListNode ReverseList(ListNode head) {
ListNode temp = null;
ListNode current = head;
ListNode pre = null;
while(current!=null){
temp=current.next;
current.next=pre;
if(temp==null){
break;
}
pre=current;
current=temp;
}
return current;
}
}16. 合并两个排序的链表(2017.01.03)
题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
思路
两种方法，递归和非递归，递归：返回两个链表头节点更小的节点，该链表后移一位，继续调用，直到其中一个为空为止。非递归：建立一个新链表，比较两个链表的头节点值，小的加入到新链表，直到有一个为空为止。
答案
//递归
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1==null){
return list2;
}else if(list2==null){
return list1;
}
ListNode mergeHead=null;
if(list1.val<list2.val){
mergeHead=list1;
mergeHead.next=Merge(list1.next,list2);
}else{
mergeHead=list2;
mergeHead.next=Merge(list1,list2.next);
}
return mergeHead;
}
}
//非递归
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1==null){
return list2;
}else if(list2==null){
return list1;
}
ListNode mergeHead = null;
ListNode temp = null;
while(list1!=null&&list2!=null){
if(list1.val<list2.val){
if(mergeHead==null){
temp = mergeHead = list1;
}else{
temp.next = list1;
temp = temp.next;
}
list1 = list1.next;
}else{
if(mergeHead==null){
temp = mergeHead = list2;
}else{
temp.next = list2;
temp = temp.next;
}
list2 = list2.next;
}
}
if(list1==null){
temp.next = list2;
}else if(list2==null){
temp.next = list1;
}
return mergeHead ;
}
}17.树的子结构(2017.01.03)
题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路
答案
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
if(root1==null||root2==null){
return false;
}
return isSubTree(root1,root2)||HasSubtree(root1.left,root2)
||HasSubtree(root1.right,root2);
}
private boolean isSubTree(TreeNode root1,TreeNode root2){
if(root2==null)
return true;
if(root1==null)
return false;
if(root1.val==root2.val){
return isSubTree(root1.left,root2.left)
&&isSubTree(root1.right,root2.right);
}else
return false;
}
}18.二叉树的镜像(2017.01.04)
题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5
思路
根节点的左子树变成右子树的镜像，右子树变成左子树的镜像，递归的把左右子树进行镜像，注意考虑子树为空的情况即可。
答案
public class Solution {
public void Mirror(TreeNode root) {
if(root!=null){
if(root.left!=null&&root.right!=null){
TreeNode temp=null;
temp=root.left;
root.left=root.right;
root.right=temp;
Mirror(root.left);
Mirror(root.right);
}else if(root.left==null&&root.right!=null)
{
root.left=root.right;
root.right=null;
Mirror(root.left);
}else if(root.left!=null&&root.right==null){
root.right=root.left;
root.left=null;
Mirror(root.right);
}
}
}
}19.顺时针打印矩阵(2017.01.11)
题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 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.
思路
顺时针打印一圈后，相当于继续打印一个少了2行2列的矩阵，打印前记录要打印矩阵左上和右下的位置坐标，打印时判断剩下的矩阵够不够2行2列即可。
答案
public class Solution {
public ArrayList<Integer> printMatrix(int[][] matrix) {
ArrayList<Integer> result = new ArrayList<Integer>() ;
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]) ; } //Right
for(int i=startRow+1; i<=endRow-1; i++) { result.add(matrix[i][endCol]) ; } //Down
for(int j=endCol; j>=startCol; j--) { result.add(matrix[endRow][j]) ; } //Left
for(int i=endRow-1; i>=startRow+1; i--) { result.add(matrix[i][startCol]) ; } //Up
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][endCol]) ; }
}else if(startRow==endRow && startCol==endCol) {
result.add(matrix[startRow][startCol]) ;
}else {
return ;
}
}
}
20.包含min函数的栈(2017.01.11)
题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。
思路
用一个栈data保存数据，用一个栈保存一次最小的数。每次入栈时判断是否比栈顶元素小，如果小，则入栈。
答案
public class Solution {
Stack<Integer> data = new Stack<Integer>();
Stack<Integer> min = new Stack<Integer>();
Integer temp = null;//记录当前最小值
public void push(int node) {
if(temp != null){
if(node < temp ){
temp = node;
min.push(node);
}
data.push(node);
}else{
temp = node;
data.push(node);
min.push(node);
}
}
public void pop() {
int num = data.pop();
int num2 = min.pop();
if(num != num2){
min.push(num2);
}
}
public int top() {
int num = data.pop();
data.push(num);
return num;
}
public int min() {
int num = min.pop();
min.push(num);
return num;
}
}
扫一扫
1729
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
