剑指offer 题目及参考代码（二）

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量186 收藏 1
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/awyyauqpmy/article/details/80522379
版权

1-22:从上往下打印出二叉树的每个节点，同层节点从左至右打印。
代码：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root)
    {
        queue<TreeNode*>q;
        q.push(root);
        vector<int>r;
        while(!q.empty())
        {
            root = q.front();
            q.pop();
            if(!root) continue;
            r.push_back(root->val);
            q.push(root->left);
            q.push(root->right);
        }
        return r;
    }
};

1-23：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

//思路： 后续遍历要求左子树大于根大于右子树，数组前半段小于最后一个元素，后半段大于最后一个元素，否则返回false；
         // 递归，检查所有子树（数组为空时返回false，递归前先检测子树是不是空
   class Solution {
public:
bool VerifySquenceOfBST(vector<int> sequence) {  
    if(sequence.empty())  
        return false;  
    int len = sequence.size();  
    vector<int> len_left;  
    vector<int> len_right;  
    int i = 0;  
    for(;i < len - 1;i++){  
        if(sequence[i] < sequence[len - 1])  
            len_left.push_back(sequence[i]);  
        else  
            break;  
    }  
    for(;i < len - 1;i++){  
        if(sequence[i] > sequence[len - 1]){  
            len_right.push_back(sequence[i]);  
        }  
        else  
            return false;  
    }  
    bool left = true,right = true;  
    if(!len_left.empty())  
        left = VerifySquenceOfBST(len_left);  
    if(!len_right.empty())  
        right = VerifySquenceOfBST(len_right);  
    return left && right;  
}  
};

1-24：输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

//思路： 遍历二叉树，采用递归的方法，将满足条件的路径压入一维数组当中，注意当找到满足条件的路径时，先将数组压入二维数组，然后将一维数组中的每个元数弹出，以存放新的路径。
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    vector<vector<int>> result;
    vector<int>temp;
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        if(root != NULL)
        findOnePath(root,expectNumber);
        return result;
    }
    //
    void findOnePath(TreeNode* root,int expectNumber){
        temp.push_back(root->val);
        if(expectNumber - root->val==0 && root->right ==NULL && root->left == NULL)
            result.push_back(temp);
        if(root->left != NULL)findOnePath(root->left,expectNumber-root->val);
        if(root->right != NULL)findOnePath(root->right,expectNumber-root->val);
        temp.pop_back();

    }
};

1-25：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead)
            return NULL;
        RandomListNode* tmp,*t = pHead,*head;
        while(t)
        {
            tmp = new RandomListNode(t->label);
            tmp->next = t->next;
            t->next = tmp;
            t = tmp->next;
        }
        t = pHead;
        while(t)
        {
            tmp = t->next;
            if(t->random)
                tmp->random = t->random->next;
            t = tmp->next;
        }
        t = pHead;
        head = t->next;
        while(t->next)
        {
            tmp = t->next;
            t->next = tmp->next;
            t = tmp;
        }
        return head;
    }
};

1-26：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        TreeNode* pLastNode = NULL;
        ConvertNode(pRootOfTree,&pLastNode);
        //plastnode始终是双向链表的最后一个节点
        //通过递归调用，将节点移动到头节点
        TreeNode* pHeadNode = pLastNode;
        while(pHeadNode!=NULL&&pHeadNode->left!=NULL)
            pHeadNode = pHeadNode->left;
        return pHeadNode;
    }//转换函数
    void ConvertNode(TreeNode* pNode,TreeNode** pLastNode)
    {
        if(pNode == NULL)
            return;
        TreeNode*pCurrent = pNode;//获取当前节点
        if(pCurrent->left!=NULL)//左节点非空，则继续向下遍历
            ConvertNode(pCurrent->left,pLastNode);
        pCurrent->left = *pLastNode;//将上一个尾节点作为现在这个节点的  节点，相当于节点的连接
        if(*pLastNode!=NULL)
            (*pLastNode)->right = pCurrent;//双向链表右指针
        *pLastNode = pCurrent;//将当前系欸但设置为为尾节点，继续遍历
        if(pCurrent->right!=NULL)//遍历右子树
            ConvertNode(pCurrent->right,pLastNode);
    }
};

1-27：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
代码：

class Solution {
public:
    vector<string> Permutation(string str)
    {
        vector<string>result;//创建字符串数组
        int len = str.length();//求出字符串的长度，作为递归循环次数
        if(!len)
            return result;//当输入为空，直接返回
        Permutations(result,str,0,len);
        return result;
    }
    //递归函数求所有的可能性
    void Permutations(vector<string>&result,string str,int index,int len)
    {
        if(index == len)//当索引指向字符串尾部时，将str压入数组
        {
            result.push_back(str);
            return;
        }
        for(int i = index;i<len;++i)
        {
            if(i!=index && str[i] == str[index])//保证当输入多个重复字符时，不会重复计算
                continue;
            swap(str[i],str[index]);//每一次，交换从第index位以后的一个元素
            Permutations(result,str,index+1,len);
        }
    }
};

1-28： 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
代码：

// 思路 类似于‘士兵攻打阵地’。我们把数组想象为一群士兵，这些士兵来自不同阵营，士兵们一个一个走出军营去攻打阵地，
//第一个兵占领阵地以后，后面来的兵可能是自己人，也可能不是自己人，是自己人的话，count+1，不是自己人的话，
//同归于尽，最后肯定剩下一个人活到最后，但是这个人并不一定属于人最多的那一个阵营。比如:'3,3,3,1,2,0'，
//第一个3先上去，第二个3再上去，第三个3再上去，这时候count=3，后面1上去，3-1=2，2上去，2-1=1，1上去，
//1-1=0，这时候留在最后的是0，但是0显然不是人数最多那个阵营的兵，人数最多的那个阵营都被别的阵营消耗掉了。
//如果出场顺序变为:'3,1,3,3,2,0'，那最后留下的人就是3，但是3个3并没有> (6/2)。如果3的数量再多一个，
//那么不论怎么出场，最后剩下的就是3，毕竟人多，与一半的人同归于尽后总会剩下人的

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers)
    {
        int length = numbers.size();
        if(length == 0)
            return 0;
        int num = numbers[0],count = 1;
        for(int i = 1;i<length;i++)
        {
            if(numbers[i]==num)
                count++;
            else
                count--;
            if(count == 0)
            {
                num = numbers[i];
                count = 1;
            }
        }
        //上面代码计算出可能最多的数，
        //用num存了那个可能最多的那个数，于是以下代码统计和num相等的出现了多少次，然后再判断次数是否大于一半。
        count = 0;
        for(int i = 0;i<length;i++)
            if(numbers[i]==num)
                count++;
        if(count*2>length)
            return num;
        return 0;
    }
};

1-29： 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

代码：

//
//1-29
//输入n个整数，找出其中最小的K个数。
//思路1：全部排序，然后输出最小的K个
//思路2：选择排序，K次以后，最小的K个就找到了，然后输出排好的部分
class Solution
{
public:
    vector<int>GetLeastNumbers_Solution(vector<int>input,int k)
    {
        sort(input.begin(),input.end());
        vector<int> vec;
        if(k>iput.size())
            return vec;
        auto it = input.begin();
        for(int i =0;i<k;i++)
        {
            if(it==input.end())
                break;
            vec.push_back(*it);
            ++it;
        }
        return vec;
    }
    //思路2：选择排序，K次以后，最小的K个就在最前面了，然后压入vector输出
    vector<int>GetLeastNumbers(vector<int>input,int k)
    {
        int len = input.size();
        vector<int> vec;
        if(len<k)
            return vec;
        for(int i=0;i<k;i++)
        {
            for(int j=i+1;j<len;j++)
            {
                if(input[i]>input[j])
                    swap(input[j],input[i]);
            }
            vec.push_back(input[i]);            
        }
        return vec;
    }
};

1-30： HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

代码：

//
class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array)
    {
        int a = array[0];
        int max = array[0];
        for(int i = 1;i<array.size();i++)
        {
            if(a>=0)
                a = a+array[i];
            else
                a = array[i];
            if(a>max)
                max = a;
        }
        return max;
    }
};

1-31： 求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数

代码：

//每次除以10求余数，看是否余1 。是就++；不是就再除以10求余。
class Solution {
public:
    int NumberOf1Between1AndN_Solution(int n)
    {
        int count = 0;
        for(int i = 0;i<=n;i++)
        {
            int temp = i;
            while(temp!=0)
            {
                if(temp%10==1)
                    count++;
                temp/=10;
            }
        }
        return count;
    }
};

1-32： 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
代码：

/*对vector容器内的数据进行排序，按照 将a和b转为string后 若 a＋b<b+a  a排在在前 的规则排序,
 如 2 21 因为 212 < 221 所以 排序后为 21 2   to_string() 可以将int 转化为string
*/
class Solution {
public:
    string PrintMinNumber(vector<int> numbers)
    {
        string answer="";
        sort(numbers.begin(),numbers.end(),cmp);
        for(int i = 0;i<numbers.size();i++)
        {
            answer+=to_string(numbers[i]);  // 将数组的数连接起来，小的在前面，最终串成answer
        }
        return answer;
    }
    static bool cmp(int a,int b)  // 按从小到大的顺序排列
    {
        string A = "";
        string B = "";
        A+=to_string(a);
        A+=to_string(b);   // A = “a""b"
        B+=to_string(b);
        B+=to_string(a);   // B =   "b""a"
        return A<B;
    }
};

1-33： 把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

代码：

// 思路，根据分析，后面的丑数都是前面的抽数*2或者*3或者*5得到的，所以将丑数分成三类，
// 然后挨个从三类里面挑最小的作为下一个丑数，被挑选到的就++,然后继续下一轮。
class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        if (index < 7)return index;
        vector<int> res(index);
        res[0] = 1;
        int t2 = 0, t3 = 0, t5 = 0, i;
        for (i = 1; i < index; ++i)
        {
            res[i] = min(res[t2] * 2, min(res[t3] * 3, res[t5] * 5));
            if (res[i] == res[t2] * 2)t2++;
            if (res[i] == res[t3] * 3)t3++;
            if (res[i] == res[t5] * 5)t5++;
        }
        return res[index - 1];
    }
};

1-34： 在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置

代码：

//思路：简历一个辅助的数组，以下标来存储该数出现的次数，然后遍历该数组，下标为1的就是所求的。
class Solution {
public:
    int FirstNotRepeatingChar(string str)
    {
        if(str.size() == 0)
            return -1;
        char ch[256] = {0};
        for(int i = 0;i<str.size();i++)
            ch[str[i]]++;
        for(int i = 0;i<str.size();i++)
            if(ch[str[i]]==1)
                return i;
        return 0;
    }
};

1-35：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007输入描述:

题目保证输入的数组中没有的相同的数字
数据范围：
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5
示例1
输入
1,2,3,4,5,6,7,0
输出
7

代码：

// 思路： 先把数组分割成子数组，先统计出子数组内部的逆序对的数目，然后再统计出两个相邻子数组之间的逆序对的数目。在统计逆序对的过程中，还需要对数组进行排序。如果对排序算法很熟悉，我们不难发现这个过程实际上就是归并排序
class Solution {
public:
    int InversePairs(vector<int> data)
    {
        int length = data.size();
        if(length<=0)
            return 0;
        //vector<int>new vector<int>[length];
        vector<int>copy;
        for(int i =0;i<length;i++)
            copy.push_back(data[i]);
        long long count=InversePairsCore(data,copy,0,length-1);
        //delete []copy;
        return count%1000000007;
    }
    long long InversePairsCore(vector<int>&data,vector<int>&copy,int start,int end)
    {
        if(start == end)
        {
            copy[start] = data[start];
            return 0;
        }
        int length = (end-start)/2;
        long long left = InversePairsCore(copy,data,start,start+length);
        long long right= InversePairsCore(copy,data,start+length+1,end);

        int i = start+length;
        int j = end;
        int indexcopy = end;
        long long count = 0;
        while(i>=start&&j>=start+length+1)
        {
            if(data[i]>data[j])
            {
                copy[indexcopy--] = data[i--];
                count=count+j-start-length;
            }
            else
                copy[indexcopy--] = data[j--];
        }
        for(;i>=start;i--)
            copy[indexcopy--] = data[i];
        for(;j>=start+length+1;j--)
            copy[indexcopy--] = data[j];
        return left+right+count;
    }
};

1-36： 输入两个链表，找出它们的第一个公共结点。
代码：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2)
    {
        ListNode *p1 = pHead1;
        ListNode *p2 = pHead2;
        while(p1!=p2)
        {
            p1 = (p1==NULL?pHead2:p1->next);
            p2 = (p2==NULL?pHead1:p2->next);
        }
        return p1;
    }
};

1-37： 统计一个数字在排序数组中出现的次数。
代码：

//一个从头开始遍历，找到第一个出现位置break；
//另外一个从尾部遍历，找到最后一个位置break;然后两个做减法
class Solution
{
public:
    int GetNumberOfK(vector<int> data ,int k)
    {
        if(data.size()==0)
            return -1;
        for(int i=0;i<data.size();i++)
            if(data[i]==k)
                break;
        for(int j=data.size()-1;j>0;j--)
            if(data[j]==k)
                break;
        return j-i;
    }
};
//方法二：
//思路：//因为data中都是整数，所以可以稍微变一下，不是搜索k的两个位置，而是搜索k-0.5和k+0.5
      //这两个数应该插入的位置，然后相减即可。
class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k)
    {
        return biSearch(data,k+0.5)-biSearch(data,k-0.5);
    }
private:
    int biSearch(const vector<int>&data,double num)
    {
        int s = 0,e = data.size()-1;
        while(s<=e)
        {
            int mid = (e-s)/2+s;
            if(data[mid]<num)
                s = mid+1;
            else if(data[mid]>num)
                e = mid-1;
        }
        return s;
    }
};

1-38： 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度

代码：

//方法一：
//思路  必须遍历整棵树，有三种遍历方式，前序、后续和中序。这里不用访问节点值，指的是计数。采用前序。
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if(pRoot == NULL)
            return 0;
        int DepthLeft = TreeDepth(pRoot->left);
        int DepthRight = TreeDepth(pRoot->right);
        return 1+(DepthLeft>DepthRight?DepthLeft:DepthRight);
    }
};
//方法二：在1的基础上缩减代码量
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if(!pRoot)
            return 0;
        return max(1+TreeDepth(pRoot->left),1+TreeDepth(pRoot->right));
    }
};

1-39： 输入一棵二叉树，判断该二叉树是否是平衡二叉树。
代码：

思路： 从下往上遍历，如果子树是平衡二叉树，则返回子树的高度；如果发现子树不是平衡二叉树，则直接停止遍历，这样至多只对每个结点访问一次。
class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot)
    {
        return getDepth(pRoot)!=-1;
    }
private:
    int getDepth(TreeNode* pRoot)
    {
        if(pRoot==NULL)
            return 0;
        int left = getDepth(pRoot->left);
        if(left == -1)
            return -1;
        int right = getDepth(pRoot->right);
        if(right == -1)
            return -1;
        return abs(left-right)>1?-1:1+max(left,right);
    }
};

1-40： 一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

代码：

//方法一：
// 思路： 用set查找，遍历输入的vector，当前数字不在set中则插入，否则从set删除（出现两次的数字），这样结束遍历后set中剩余的就是要找的那两个只出现了一次的数字
class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2)
    {
        set<int>save;
        set<int>::iterator iter;
        for(int i = 0;i<data.size();i++)
        {
            if(save.find(data[i])==save.end())
                save.insert(data[i]);
            else
            {
                iter = save.find(data[i]);
                save.erase(iter);
            }
        }
        iter = save.begin();
        *num1 =*iter;
        *num2 = *(++iter);
    }
};
//方法二：常见的异或方法
//最简短的代码。基本思想是将这个数组一分为二，而这个分法是有讲究的：
//必须将这两个不同的数字分到两个不同数组里，这可以根据这两个数中任意不同的位来划分。
class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
        int Xor = 0;
        for(int i = 0; i < data.size(); ++i)
            Xor ^= data[i];
        //int split = Xor&(Xor-1)^Xor; //找到两个只出现一次的数字的第一个位值不同的位置
        int split = Xor&~(Xor - 1);
        for(int i = 0; i < data.size(); ++i){
            if(data[i]&split) *num1 ^= data[i];
            else *num2 ^= data[i];
        }
    }
};

1-41：小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!输出描述: 输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
代码：

class Solution {
public:
    vector<vector<int> > FindContinuousSequence(int sum)
    {
        int l = 1,r = 1,sumx = 1;
        vector<vector<int> > ans;
        while(l <= r){
            r ++;
            sumx += r;
            while(sumx > sum){
                sumx -= l;
                l ++;
            }
            if(sumx == sum && l != r){
                vector<int> tmp;
                for(int i = l;i <= r;i ++)  tmp.push_back(i);
                ans.push_back(tmp);
            }
        }
        return ans;
    }
};

1-42：输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。输出描述: 对应每个测试案例，输出两个数，小的先输出。
代码：

//思路：O（n）;  数列满足递增，设两个头尾两个指针i和j，
//             若ai + aj == sum，就是答案（相差越远乘积越小）
//             若ai + aj > sum，aj肯定不是答案之一（前面已得出 i 前面的数已是不可能），j -= 1
//             若ai + aj < sum，ai肯定不是答案之一（前面已得出 j 后面的数已是不可能），i += 1
class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum)
    {
        vector<int> res;
        int n = array.size();
        int i=0,j=n-1;
        while(i<j)
        {
            if(array[i]+array[j] == sum)
            {
                res.push_back(array[i]);
                res.push_back(array[j]);
                break;
            }
            while(i<j && array[i]+array[j]>sum) --j;
            while(i<j && array[i]+array[j]<sum) ++i;
        }
        return res;
    }
};

未完待续。。。

decouples
关注
《剑指offer》题目汇总
李滚滚的博客
03-28 1716
文章目录面试题1 赋值运算符函数以上是基本的内容，但还是有代码异常安全性问题存在。 面试题1 赋值运算符函数 题目：如下为类型CMyString的声明，请为该类型添加赋值运算符函数。 class CMyString { public: CMyString(char* pData = nullptr); CMyString(const CMyString& str); ~CMyStri...
《剑指Offer》题目及代码（修订版4）.pdf
06-16
《剑指Offer》是程序员面试时必备的一本书籍，其内容主要是针对常见的编程面试题目进行分析，并提供Java语言的实现。修订版4作为该系列的更新，不仅包含了题目和解题思路，还对部分代码进行了重新排版，以解决原书中...
剑指offer所有的题目（附代码）
liangzier的博客
04-28 1111
转载地址：https://blog.csdn.net/wszy1301/article/details/80910626#2.0%C2%A0%E4%BB%8E%E4%B8%8A%E5%BE%80%E4%B8%8B%E6%89%93%E5%8D%B0%E4%BA%8C%E5%8F%89%E6%A0%91 github地址：https://github.com/MisterBooo/LeetCode...
剑指offer题目描述+代码
JJJJJJames的博客
03-28 1478
1、剑指Offer 25：合并两个有序链表 题目描述 解题思路 通过不断对比l1和l2的值的大小对链表进行添加。 代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def mergeTwoLists(self, l1: ListNode,
剑指offer题目汇总及解答
qq_24095055的博客
05-28 973
文章目录数组中重复的数字二维数组中的查找替换空格从尾到头打印链表重建二叉树 数组中重复的数字 题目链接 题目描述 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。 解题思路 利用Ha...
剑指offer题目大全
大树叶 技术专栏
10-06 2359
　剑指Offer这本书已经学习完了，从中也学习到了不少的东西，现在做一个总的目录，供自已和大家一起参考，学如逆水行舟，不进则退。只有不断地学习才能跟上时候，跟得上技术的潮流！ 所有代码下载【https://github.com/Wang-Jun-Chao/coding-interviews】 目录 第01-10题   【剑指Offer学习】【面试题02：实现Singleton 模式——七...
算法之剑指offer题目总结
pl0321的博客
05-07 1216
简介 剑指offer中的题目是面试中考察的重点，本篇文章对这些题目进行总结，方便日后阅读。 题目 题目顺序参考 leetcode 中出现的顺序。 1. 数组中重复的数字 2. 二维数组中的查找 3. 替换空格 4. 从尾到头打印链表 5. 重建二叉树 6. 用两个栈实现队列 7. 斐波那契数列 8. 青蛙跳台阶问题 9. 旋转数组的最小数字 10. 矩阵中的路径 解析 1. 数组中重复的数字 题目描述 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有
剑指offer所有的题目总结及解题代码 C++实现
来知晓的博客
09-09 1226
目录   基本都是参考别的博客和书本的代码，仅作为自己笔记用！！ 零、小结： 一、位运算 1、二进制中1的个数...
剑指offer所有的题目的总结
xuxinrk的博客
02-26 2355
目录 基本都是参考别的博客和书本的代码，仅作为自己笔记用！！ 零、小结： 一、位运算 1、二进制中1的个数 2、判断二进制中0的个数 3.二进制高位连续0的个数 二、二叉树 1、二叉搜索树第k个结点 2.0 从上往下打印二叉树 2.1二叉树打印成多行 2.2按之字形顺序打印二叉树 题目描述 3.数据流中位数 4.二叉树中和为某一值的路径 5.重建二叉树 6.树的子结...
剑指Offer题集（力扣）
qq_42958831的博客
05-07 1万+
力扣题单：https://leetcode.cn/problemset/all/?listId=lcof&page=1
剑指offer所有的题目总结
热门推荐
wszy1301的博客
09-17 10万+
目录 基本都是参考别的博客和书本的代码，仅作为自己笔记用！！ 零、小结： 一、位运算 1、二进制中1的个数 2、判断二进制中0的个数 3.二进制高位连续0的个数 二、二叉树 1、二叉搜索树第k个结点 2.0从上往下打印二叉树 2.1二叉树打印成多行 2.2按之字形顺序打印二叉树 题目描述 3.数据流中位数 4.二叉树中和为某一值的路径 5.重建二叉树 6.树...
《剑指Offer》题目及Java版代码（带目录）
03-03
《剑指Offer》中的题目覆盖了大量编程面试中的常见问题，通过对这些题目的练习，不仅能够提高编程能力和解题技巧，而且还能在面试中展示出自己的算法和数据结构知识。因此，无论是对于在校学生还是正在准备职场人士...
《剑指offer》Java版代码
02-05
通过深入研究《剑指Offer》Java版的代码实现，不仅能提升编程能力，还能对面试中常见的问题有更深刻的理解。这些代码实例为学习者提供了实践平台，帮助他们在解决实际问题时能快速找到思路，提高问题解决能力。对于...
剑指offer全部代码
03-07
《剑指Offer》是面试官在招聘过程中常常参考的一本书，它涵盖了大量经典的编程面试题，旨在帮助求职者提升算法和编程能力。该压缩包包含了《剑指Offer》中的所有代码，适合用Visual Studio（VS）开发环境打开，并且...
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 852
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1691
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 145
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
C++：图的最短路径问题
han2205277149的博客
10-04 710
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 895
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
剑指Offer C++题解：二维查找与替换空格算法详解
剑指OFFER题解(C++)文档是一份全面的编程题解资料，针对C++语言，特别适合那些正在刷《剑指Offer》这本书中的题目或者希望提升算法能力的学习者。这份资源由作者Sidney.Tan整理，包含了牛客网讨论区、原著书中的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值