leetcode学习打卡特别专题--剑指offer前五题(搜索/字符串/链表/树)

剑指offer 03 04 05 06 07前五题汇总

---

面试题03. 数组中重复的数字(普通搜索–桶/原地置换)

---

题目
找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

---

前台样例

示例 1：
输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 
 

限制：
2 <= n <= 100000

---

题目分析:
1.只需要找到一个就行
2.数据不是很大，只到10w级别
3. 数字在0～n-1 的范围内

解题思路:
1.桶 基于上面第三点与第二点，可以类似桶排序 建立标志桶统计每个数出现了几次
bucket[i]代表数字i出现了多少次

//c++代码
class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        int len=nums.size();
        int *bucket=new int[len];
        for(int i=0;i<len;i++)
        bucket[i]=0;
        int res;
        for(int i=0;i<len;i++)
        {
            bucket[nums[i]]++;
        }
        for(int j=0;j<len;j++)
        {
            if(bucket[j]!=0&&bucket[j]!=1)
            {
                res=j; break;
            }
        }
        return res;
    }
};

//java代码
class Solution {
    public int findRepeatNumber(int[] nums) {
        int len = nums.length;//行
        int i=0,res=0;
        int bucket[] = new int[len];     
        for(i=0;i<len;i++)
        {
           bucket[nums[i]]++;
        }
        for(i=0;i<len;i++)
        {
            if(bucket[i]!=1&&bucket[i]!=0)
            {
                res=i;break;
            }
        }
        return res;
    }
}

2.原地置换 我们遍历数组 把遇到的每一个nums[i]都交换到它在的位置，也就是i上
当i位置上已经有一个一模一样的数存在时就可以返回，找到重复的了。

//java
class Solution {
    public int findRepeatNumber(int[] nums) {
        int len = nums.length;//行
        int i=0;      
        for(i=0;i<len;i++)
        {
            if(nums[i]!=i)
            {
                int temp=nums[nums[i]];
                if(nums[nums[i]]==nums[i]) return nums[i];
                nums[nums[i]]=nums[i];
                nums[i]=temp;
            }
        }
        return 0;
    }
}

---

面试题04. 二维数组中的查找(普通搜索–蛮力/优化)

题目
二维数组中的查找
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

---

前台样例

示例:
现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

 

限制：
0 <= n <= 1000
0 <= m <= 1000

---

题目分析:
1.数据极限为1000*1000 蛮力法很吃力
2.数组暗含一定特殊规律，可以以此优化
3.数组的右上点很特殊(后面会提到)

解题思路:
1.蛮力 暴力搜索

//java代码
class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if(matrix==null) return false;
        if(matrix.length==0) return false;
        if(matrix[0].length==0) return false;
        int len=matrix.length;
        int high=matrix[0].length;
        int i=0,j=0;
        boolean res=false;
        for(i=0;i<len;i++)
        for(j=0;j<high;j++)
        {
            if(matrix[i][j]==target)
            {
                res=true;break;
            }
        }
        return res;
    }
}

2.简单优化
我们缩小搜索的i j范围来实现减少搜索量
这不一定能保证优化，譬如搜索的数本来就在右下角

//c++代码
class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        int x=-1,y=-1;
        int lenx=matrix.size();
        if(lenx==0) return false;
        int leny=matrix[0].size();
        if(lenx==0||leny==0) return false;
        for(int i=0;i<lenx;i++)
        {
            if(matrix[i][0]>target) {i-1<0?x=0:x=i-1;break;}
        }
        for(int j=0;j<leny;j++)
        {
            if(matrix[0][j]>target) {j-1<0?y=0:y=j-1;break;}
        }
        if(x==-1) x=lenx-1; if(y==-1) y=leny-1;
        bool res=false;
        for(int i=0;i<=x;i++)
        for(int j=0;j<=y;j++)
        {
            //cout<
            if(matrix[i][j]==target)
            {
                res=true;break;
            }
        }
        return res;
    }
};

3.使用好右上角这个点
对于下面这个数组 我们从15开始看
假定要搜索5 首先15>5 而且15的下方都比15大，所以15这列就不用考虑了
接下来是11 同样也不用考虑的 还有7也是不考虑
当到达4的时候停止，搜索4这一列，从上到下即可找到5，如果没有找到5也就说明数组里面没有5
一句话表述就是
从右上角搜 大于左移(i–) 小于下移(j++)

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

//java代码
class Solution {
    public boolean findtar(int[][] matrix, int target,int len,int high)
    {
            int i=len-1,j=0;
            boolean res=false;
            while(i>=0&&j<high)
            {
                if(matrix[j][i]==target) { res=true; break;}
                else if(matrix[j][i]>target) i--;
                else if(matrix[j][i]<target) j++;
            }
            return res;
    }
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if(matrix==null) return false;
        if(matrix.length==0) return false;
        if(matrix[0].length==0) return false;
        int high=matrix.length; //行数
        int len=matrix[0].length;//列数
        boolean res=findtar(matrix,target,len,high);
        return res;
    }
}

面试题05. 替换空格(字符串处理–水题)

题目
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

---

前台样例

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."
 

限制：
0 <= s 的长度 <= 10000

---

题目分析:
1.长度10000没啥说的
2.可以开3倍长度来遍历替换

解题思路:
无

//c++代码
class Solution {
public:
    string replaceSpace(string s) {
        string res="";
        for(int i=0;i<s.length();i++)
        {
            if(s[i]!=' ') res+=s[i];
            else res+="%20";
        }
        return res;
    }
};

//java代码
class Solution {
    public String replaceSpace(String s) {
        int length = s.length();
        char[] array = new char[length * 3];
        int size = 0;
        for (int i = 0; i < length; i++) {
            char c = s.charAt(i);
            if (c == ' ') {
                array[size++] = '%';
                array[size++] = '2';
                array[size++] = '0';
            } else {
                array[size++] = c;
            }
        }
        String newStr = new String(array, 0, size);
        return newStr;
    }
}

---

面试题06. 从尾到头打印链表(链表遍历/栈–水题)

题目
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

---

前台样例

示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
 

限制：
0 <= 链表长度 <= 10000

---

题目分析:
不是一般定义的链表逆序，而是返回数组

解题思路:
遍历，拿栈倒一下就可以了

//c++代码
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        stack<int> contraryres;
        ListNode*temp=head;
        while(temp!=NULL)
        {
            contraryres.push(temp->val);
            temp=temp->next;
        }
        vector<int> res;
        while(!contraryres.empty()) {
            res.push_back(contraryres.top());
            contraryres.pop();
        }
        return res;
    }
};

//java代码
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<Integer> stack = new Stack<Integer>();
        ListNode temp=head;
        while(temp!=null)
        {
            stack.push(temp.val);
            temp=temp.next;
        }
        int size = stack.size();
        int[] res = new int[size];
        int i=0;
        while(!stack.empty())
        {
            res[i++]=stack.peek();
            stack.pop();
        }
        return res;
    }
}

---

面试题07. 重建二叉树(递归建树/先序中序遍历–略难)

题目
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

---

前台样例

例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7
 

限制：
0 <= 节点个数 <= 5000

---

题目分析:
1.节点5000没有必要考虑
2.需要结合先序与中序节点来建树
3.建树一般都是递归

解题思路:
对于下面的遍历序列 可以分析
1.先序的第一个是根节点—3是树的根
2.从中序考虑(中序指的是根中序访问)—所以根前面是左子树，根后面是右子树，
即 9是左子树 ，15 20 7是右子树
3.对于 15 20 7 继续看前序 返回第1点 即20是根。继续第2点第3点…
至此 思路过程出现循环递归。

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

代码实现如下
注意:i-inStart表示在中序中得出的左子树包含的元素个数
结束条件就是 没有元素了
即 if(preStart>preEnd||inStart>inEnd) return NULL;

//c++代码
class Solution {
public:
    TreeNode* build_(vector<int>& preorder, vector<int>& inorder,int preStart,int preEnd,int inStart,int inEnd)
    {
        //cout<
        if(preStart>preEnd||inStart>inEnd) return NULL;
        TreeNode *Node=new TreeNode(preorder[preStart]);
        cout<<preorder[preStart]<<endl;
        int i=0;
        for(int i=inStart;i<=inEnd;i++)
        {
            if(inorder[i]==preorder[preStart])
            {
                Node->left=build_(preorder,inorder,preStart+1, preStart+i-inStart, inStart, i);
                Node->right=build_(preorder,inorder,preStart+i-inStart+1, preEnd, i+1, inEnd);
            }
                  
        }
        return Node;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size()==0) return NULL;
        return build_(preorder,inorder,0,preorder.size()-1,0,inorder.size()-1);
    }
};

---

完结，后面写完5题继续发…
剑指offer专题 写5题合并一次发