剑指offer

Posted 2022-09-17 zhangzx

二维数组中查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

//思路：从左下角/右上角开始遍历，每走一步就可以剔除一行或者一列。
//复杂度：O(m+n)
    public boolean Find(int target, int [][] array) 
         int rowCount = array.length;
         int colCount = array[0].length;
         int i,j;
         for(i=rowCount-1,j=0;i>=0&&j<colCount;)
         
             if(target == array[i][j]) return true;
             if(target < array[i][j])
                 i--;
                 continue;
             
             if(target > array[i][j])
                 j++;
                 continue;
             
         
         return false;
    

替换函数

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

/*问题1：替换字符串，是在原来的字符串上做替换，还是新开辟一个字符串做替换！
问题2：在当前字符串替换，怎么替换才更有效率（不考虑java里现有的replace方法）
从前往后替换，后面的字符要不断往后移动，要多次移动，所以效率低下
从后往前，先计算需要多少空间，然后从后往前移动，则每个字符只为移动一次，这样效率更高一点。*/
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 indexHold=str.length()-1; 
        int newlength=str.length()+spacenum*2;
        int indexNew = newlength -1;
        str.setLength(newlength);
        for(;indexHold>=0;indexHold--)
            if(str.charAt(indexHold)==‘ ‘)
                str.setCharAt(indexNew--,‘0‘);
                str.setCharAt(indexNew--,‘2‘);
                str.setCharAt(indexNew--,‘%‘);
            
            else str.setCharAt(indexNew--,str.charAt(indexHold));
        
        return str.toString();
    

反向遍历链表

/**
*    public class ListNode 
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) 
*            this.val = val;
*        
*    
*
*/
import java.util.*;
public class Solution 
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) 
        Stack<Integer> result = new Stack<Integer>();
        ArrayList<Integer> list = new ArrayList<Integer>();
        while(listNode!=null) 
            result.push(listNode.val);
            listNode=listNode.next;
        
        int value=0;
        while(!result.isEmpty())
            value=result.pop();
            list.add(value);
        
        return list;
    

重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列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;    
        //前序遍历1,2,4,7,3,5,6,8和中序遍历序列4,7,2,1,5,3,8,6
    //先左后右，按照前序遍历的顺序
    private TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,
                                           int [] in, int startIn, int endIn)                 
        if(startPre>endPre||startIn>endIn)            
            return null;        
        TreeNode root=new TreeNode(pre[startPre]);                 
        for(int i=startIn;i<=endIn;i++)            
            if(in[i]==pre[startPre])//前序遍历是以子树根节点顺序进行的                
                root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,
                                                in,startIn,i-1);//左子树                
                root.right=reConstructBinaryTree(pre,startPre+i-startIn+1,endPre,
                                                 in,i+1,endIn);//右子树                      
                break;            
                                     
        return root;    
    

两个栈实现队列

import java.util.Stack;

public class Solution 
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    //stack1实现入队列，stack2实现出队列
    public void push(int node) 
        stack1.push(node);
    
    
    public int pop() 
        if(stack1.isEmpty()&&stack2.isEmpty())
            throw new RuntimeException("Queue is empty!");
        if(stack2.isEmpty())
            while(!stack1.isEmpty())
                stack2.push(stack1.pop());
            
        return stack2.pop();
    

旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组3,4,5,1,2为1,2,3,4,5的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。　　

public int minNumberInRotateArray(int [] array) 
        if(array.length==0) return 0;
        int low=0,high=array.length-1,mid=0;
        while(array[low]>=array[high])//不满足这个说明是从小到大顺序，根本没变
            if(high-low==1)
                mid=high;
                break;
            
            mid = low + (high - low) / 2;
            if(array[mid]>=array[low]) low=mid;
            else  high=mid;
        
        return array[mid];
    

斐波那契数列

public int Fibonacci(int n) 
        if(n==0) return 0;
        if(n==1||n==2) return 1;
        return Fibonacci(n-1)+Fibonacci(n-2);
    
public int Fibonacci(int n) //动态规划
        int f = 0, g = 1;        
        while(n-->0)            
            g += f;//前一项            
            f = g - f;//前二项        
                
        return f;
    

(DP)跳台阶（1或2）　　

public int JumpFloor(int target) 
        int f = 1, g = 1;        
        while(target-->0)            
            g += f;            
            f = g - f;        
                
        return f;//主要注意返回的是前面一阶而不是现在阶的数目
    

(贪心)变态跳台阶（1，2...n)

public int JumpFloorII(int target) 
        if(target<=0) return 0;
        if(target==1) return 1;
        int a=1,b=1;
        while(target-->0)
            a=b;
            b*=2;
        //经过变化，b是当前跳法，a是前一阶跳法
        return a;//平台不算台阶
    　　

（递归）矩形覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

public int RectCover(int target) 
        if(target<=0) return 0;
        if(target==1) return 1;
        if(target==2) return 2;
        return RectCover(target-1)+RectCover(target-2);//横着竖着
    

（反码补码）二进制1的个数

　

/*
分析一下代码：这段小小的代码，很是巧妙。
如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，
原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。
减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.
我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，
从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.
也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.
那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
*/
public class Solution 
    public int NumberOf1(int n) 
        int count=0;
        while(n!=0)
            n=n & (n-1);
            count++;
        
        return count;
    

数值的整数次方

public double Power(double base, int exponent) 
        if(base==0) return 0;
        if(base==1) return 1;
        if(exponent==0) return 1;
        if(exponent==1) return base;
        double temp = base;
        if(exponent>0)
            for(;exponent>1;exponent--)
                base = base * temp;
            
        
        else 
            for(;exponent<=0;exponent++)
                base = base / temp;
            
        
        return base;
  //注意幂次是负数的情况

调整数组次序，奇数在前，偶数在后

1.插入我觉得太蠢了，o（n**2），归并o（n*logn）

2.空间换时间，o（n）　

public void reOrderArray(int [] array) 
        if (array != null)            
            int[] even = new int[array.length];            
            int indexOdd = 0;            
            int indexEven = 0;            
            for (int num : array)                
                if ((num & 1) == 1)                    
                    array[indexOdd++] = num;                
                 else                    
                    even[indexEven++] = num;                
                            
                         
            for (int i = 0; i < indexEven; i++)                
                array[indexOdd + i] = even[i];            
                
        
    

链表第k个元素

public ListNode FindKthToTail(ListNode head,int k) //需要空间少
        ListNode pre=null,p=null;                
        p=head;        pre=head;        //两个指针都指向头结点        
        int a=k;        //记录k        
        int count=0;        //记录节点的个数
        //p指针先跑，并且记录节点数，当p指针跑了k-1个节点后，pre指针开始跑，        
        //当p指针跑到最后时，pre所指指针就是倒数第k个节点        
        while(p!=null)            
            p=p.next;            
            count++;            
            if(k<1)                
                pre=pre.next;            
                        
            k--;        
                //如果节点个数小于所求的倒数第k个节点，则返回空        
        if(count<a) return null;        
        return pre;
    

反转链表

public ListNode ReverseList(ListNode head) 
        if(head==null) return null;
        ListNode pre = null, next = null;
        while(head!=null)
            next=head.next;//防止丢失下个节点
            head.next=pre;
            pre=head;
            head=next;
        
        return pre;