经典算法题整合

最新推荐文章于 2022-11-19 18:39:48 发布
置顶 最新推荐文章于 2022-11-19 18:39:48 发布
阅读量5k 收藏 4
点赞数 4
文章标签： 程序设计 二叉树 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44048219/article/details/89191521
版权
本文整理了多个经典的算法题目，包括二维数组查找、字符串空格替换、链表操作、二叉树重建、队列实现等，并提供了详细的程序解析，旨在帮助读者巩固算法知识，提升编程能力。
摘要由CSDN通过智能技术生成

——记录我的学习之路
2019/12/27
期末停更，准备pat甲级，复习期末QAQ

1.题目描述

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

程序解析

class Solution {
   
public:
    bool Find(int target, vector<vector<int> > array) {
   
        int i=array.size()-1,j=0;
        while(i>=0 && j<array[0].size())
        {
   
            if(target>array[i][j])j++;
            else if (target<array[i][j])i--;
            else return true;
        }
        return false;
    }
};

2.题目描述

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

程序解析

class Solution {
   
public:
	void replaceSpace(char *str,int length) {
   
        int blank=0,space=0;
        for(int i=0;i<length;i++)
            if(*(str+i)==' ')blank++;
        space=length+2*blank+1;
        
        for(int i=length+1;i>=0;i--)
        {
   
            if(*(str+i)==' ')
            {
   
                *(str+space)='0';
                space--;
                *(str+space)='2';
                space--;
                *(str+space)='%';
                space--;
            }
            else
            {
   
                *(str+space)=*(str+i);
                space--;
            }
        }
	}
};

3.题目描述

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

程序解析

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
   
public:
    vector<int> printListFromTailToHead(ListNode* head) {
   
        vector<int>reV;
        while(head!=NULL)
        {
   
            reV.push_back(head->val);
            head=head->next;
        }
        reverse(reV.begin(),reV.end());
        return reV;
    }
};

4.题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

程序解析

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
   
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
   
        int root=pre[0],length=0;
        for(int i=0;i<vin.size();i++)
        {
   
            if(root==vin[i])break;
            length++;
        }
        TreeNode* T=new TreeNode(root);
        if(length!=0)
        {
   
            vector<int> p1(pre.begin()+1,pre.begin()+length+1);
            vector<int> i1(vin.begin(),vin.begin()+length);
            T->left=reConstructBinaryTree(p1,i1);
        }
        
        if(length+1!=vin.size())
        {
   
            vector<int> p2(pre.begin()+length+1,pre.end());
            vector<int> i2(vin.begin()+length+1,vin.end());
            T->right=reConstructBinaryTree(p2,i2);
        }
        
        return T;
    }
};

5.题目描述

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

程序解析

class Solution
{
   
public:
    void push(int node) {
   
        stack1.push(node);
    }

    int pop() {
   
        while(!stack1.empty())
        {
   
            stack2.push(stack1.top());
            stack1.pop();
        }
            
        int temp=stack2.top();
        stack2.pop();
        while(!stack2.empty())
        {
   
            stack1.push(stack2.top());
            stack2.pop();
        }
        return temp;
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

6.题目描述

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

程序解析

class Solution {
   
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
   
        if(rotateArray.empty())return 0;
        int i=0;
        while(true)
        {
   
            if(i==rotateArray.size())
            {
   
                return rotateArray[0];
            }
            if(rotateArray[i]>rotateArray[i+1])return rotateArray[i+1];
            i++;
        }
    }
};

7.题目描述

给定一个根为R，权为W的非空树
分配给每个树节点T . 从R到L的路径的权重被定义为沿从R到任何叶节点L的路径的所有节点的权重之和。
现在给定任何加权树，你应该找到所有的路径，它们的权重等于给定的数。例如，让我们考虑树：对于每个节点，上面的数字是节点ID，这是一个两位数的数字，下面的数字是该节点的权重。假设给定数为24，则存在4个不同的路径，它们具有相同的给定权重：{ 105 2 7 }，{10 4 10 }，{10 3 3 3 }和{α} }。

程序解析

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn=200;
struct node{
   
    int weight;
    vector<int> child;
}Node[maxn];
int n,m,theweight,tempweight=0,equalnum=0;
int father,childnum,child;
vector<int> temppath;
vector<vector<int> >ans;
bool cmp(vector<int> a,vector<int> b){
   
    for(int i=0;i<a.size()&&i<b.size();i++){
   
        if(a[i]!=b[i]) return a[i]>b[i];
    }
    return false;
}
void DFS(int now){
   
    temppath.push_back(Node[now].weight);
    tempweight+=Node[now].weight;
    if(Node[now].child.size()==0){
   
        if(tempweight==theweight) ans.push_back(temppath);
    }
    for(int i=0;i<Node[now].child.size();i++)
        DFS(Node[now].child[i]);
    temppath.pop_back();
    tempweight-=Node[now].weight;
}
int main(){
   
    cin>>n>>m>>theweight;
    for(int i=0;i<n;i++)
        cin>>Node[i].weight;
    for(int i=0;i<m;i++){
   
        cin>>father>>childnum;
        for(int j=0;j<childnum;j++){
   
            cin>>child;
            Node[father].child.push_back(child);
        }
    }
    DFS(0);
    sort(ans.begin(),ans.end(),cmp);
    for(int i=0;i<ans.size();i++){
   
        for(int j=0;j<ans[i].size();j++){
   
            if(j!=ans[i].size()-1) cout<<ans[i][j]<<" ";
            else cout<<ans[i][j]<<endl;
        }
    }
    return 0;
}

8.题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39

程序解析

class Solution {
   
public:
    int Fibonacci(int n) {
   
        if(n==0)return 0;
        if(n==1)return 1;
        int n1=0,n2=1,n3;
        for(int i=3;i<=n+1;i++)
        {
   
            n3=n1+n2;
            n1=n2;
            n2=n3;
        }
        return n3;
    }

};

9.题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

程序解析

class Solution {
   
public:
    int jumpFloor(int number) {
   
        if(number==1)return 1;
        if(number==2)return 2;
        int n1=1,n2=2,n3;
        for(int i=3;i<=number;i++)
        {
   
            n3=n1+n2;
            n1=n2;
            n2=n3;
        }
        return n3;
    }
};

10.题目描述

实现一个图的类库

程序解析

//main.cpp
#include"graph.h"
#include"graph.template.h"
void test();
int main()
{
   
    test();
    
    return 0;
}

void test()
{
   
    char data[6] = {
   'A', 'B', 'C', 'D', 'E', 'F'};
    UnDMaGraph<char> G2(data, 6, 10);
    G2.Dijstra(0);
    G2.DFS(0);
    G2.BFS(0);
    G2.Show();
}


//graph.h

#ifndef __GRAPH__H__
#define __GRAPH__H__

#include<iostream>
#include <queue>
#define INFINITY 2e9
#define UnDAlGraph DAlGraph
//邻接矩阵和邻接表的最大存储空间
const int MAXSIZE=10;


//点的数据域，访问状态，权重
template<class T>
struct Vertex
{
   
    T data;
    bool visited;
    int weight;
};

//弧结点，邻接顶点所在表头的下标以及下一条弧的信息

struct ArcNode
{
   
    int adjvex;
    int weight;
    struct ArcNode* nextArc;
};

//表头结点，顶点，第一条弧以及是否访问的信息
template<class T>
struct VertexNode
{
   
    T vertex;
    ArcNode* firstArc;
    bool visited;
};

//---------------------邻接矩阵无向图数据结构---------------------
template<class T>
class UnDMaGraph
{
   
public:
    
    Vertex<T> vertex[MAXSIZE];
    int arc[MAXSIZE][MAXSIZE];
    int vNum, arcNum;
    
public:
    /**
     *输入每个点的数据，图的总点数目和总边数目并生成图
     *
     *
     */
    
    UnDMaGraph(T a[], int n, int e);
    
    /**
    *
    *输出每个点及其对应的数据域
    *从0点以dfs算法遍历输出点
    */
    void Show();
    
    /**
    *
    *将点的访问情况初始化
    *
    */
    void clear();
    
    /**
    *
    *深度优先遍历算法：递归实现
    *
    */
    void DFS_traversal(int i);
    void DFS(int i);
    
    /**
    *
    *广度优先遍历算法：队列实现
    *
    */
    void BFS_traversal(int i);
    void BFS(int i);
    
    /**
     *
     *单源最短路径算法，各点到S点的最小距离
     *
     */
    
    void Dijstra(int S);
};
//---------------------邻接矩阵无向图数据结构---------------------



//---------------------邻接矩阵有向图数据结构---------------------
template<class T>
class DMaGraph:public UnDMaGraph<T>
{
   
public:
    /**
    *输入每个点的数据，图的总点数目和总边数目并生成图
    *
    *
    */
    DMaGraph(T a[], int n, int e);
};
//---------------------邻接矩阵有向图数据结构---------------------


//---------------------邻接表无向图数据结构---------------------

template<class T>
class UnDAlGraph
{
   
private:
    VertexNode<T> adjList[MAXSIZE];        ///结点（顶点）表
    int vNum, arcNum;       //顶点个数和弧的数目
    
public:
    /**
    *给定一个边的数组，图的总点数目和总边数目并生成图
    *
    *
    */
    UnDAlGraph(T a[], int n, int e, int arc[][3]);
    
    /**
    *
    *初始化有n个顶点的图
    *
    */
    UnDAlGraph(T a[], int n);
    
    /**
    *
    *进一步初始化成有e条弧的图，以输入模式进行
    *
    */
    void CreateGraph(int e);
    
    /**
    *
    *析构函数
    *
    */
    ~UnDAlGraph();
    
    /**
    *
    *
    *
    */
    void Show();
    
    /**
    *
    *
    *
    */
    void clear();                   ///用于将遍历后visited[]重置为false，即未访问过的状态
    
    /**
    *
    *
    *
    */
    void DFS_traversal(int i);
    void DFS(int i);
    
    /**
    *
    *
    *
    */
    void BFS_traversal(int i);
    void BFS(int i);
    
    
    void Dijkstra(int v0);
};
//---------------------邻接表无向图数据结构---------------------



#else
// DO NOTHING.
#endif


//graph.template.h
#include"graph.h"

template<class T>
DMaGraph<T>::DMaGraph(T a[], int n, int e)
{
   
        this->vNum = n;
        this->arcNum = e;
        int i, j,w;
        for(int k=0; k<n; ++k)
        {
   
            this->vertex[k].data = a[k];
            this->vertex[k].visited = false;
        }
        for(i=0; i<n; ++i)
            for(j=0; j<n; ++j)
                this->arc[i][j] = 0;
        this->Show();
        std::cout<<"初始化图:输入一条边两点的值，并输入边的权重\n";
        for(int k=0; k<e; ++k)
        {
   
            std::cin>>i>>j>>w;
            this->arc[i][j] = w;
        }
};


template<class T>
UnDMaGraph<T>::UnDMaGraph(T a[], int n, int e)
{
   
    vNum = n;
    arcNum = e;
    int i, j,w;
    for(int k=0; k<n; ++k)
    {
   
        vertex[k].data = a[k];
        vertex[k].visited = false;
    }
    for(i=0; i<n; ++i)
        for(j=0; j<n; ++j)
            arc[i][j] = INFINITY;
    Show();
    std::cout<<"初始化图:输入一条边两点的值，并输入边的权重\n";
    for(int k=0; k<e; ++k)
    {
   
        std::cin>>i>>j>>w;
        arc[i][j] = w;
        arc[j][i] = arc[i][j];
    }
}

template<class T>
void UnDMaGraph<T>::DFS_traversal(int i)
{
   
    std::cout<<vertex[i].data<<"->";
    vertex[i].visited = true;
    for(int j=0; j<vNum; ++j)
    {
   
        if(arc[i][j]!=INFINITY && vertex[j].visited==false)
            DFS_traversal(j);
    }
}

template<class T>
void UnDMaGraph<T>::DFS(int i)
{
   
    std::cout<<"DFS:"<<std::endl;
    DFS_traversal(i);
    std::cout<<"None"<<std::endl;
    for(int j=0; j<vNum; ++j)
    {
   
        if(arc[i][j]==INFINITY && vertex[j].visited==false)
           {
   
               DFS_traversal(j);
               std::cout<<"None"<<std::endl;
           }
    }
    clear();
}

template<class T>
void UnDMaGraph<T>::BFS_traversal(int i)
{
   
    int queue[MAXSIZE];
    int f=0, r=0;
    std::cout<<vertex[i].data<<"->";
    vertex[i].visited = true;
    queue[++r] = i;
    while(f!=r)
    {
   
        i = queue[++f];
        for(int j=0; j<vNum; ++j)
        {
   
            if(arc[i][j]!=INFINITY && vertex[j].visited==false)
            {
   
                std::cout<<vertex[j].data<<"->";
                vertex[j].visited = true;
                queue[++r] = j;
            }
        }
    }
}

template<class T>
void UnDMaGraph<T>::BFS(int i)
{
   
    std::cout<<"BFS:"<<std::endl;
    BFS_traversal(i);
    std::cout<<"None"<<std::endl;
    for(int j=0; j<vNum; ++j)
    {
   
        if(arc[i][j]==INFINITY && vertex[j].visited==false)
            {
   
                BFS_traversal(j);
                std::cout<<"None"<<std::endl;
            }
    }
    clear();
}

template<class T>
void UnDMaGraph<T>::Show()
{
   
    std::cout<<"————————————数据域与下标对照表————————————"<<std::endl;
    std::cout<<"下标：|";
    for(int i=0; i<vNum; ++i)
        std::cout<<i<<"   |";
    std::cout<<std::endl;
    std::cout<<"数据：|";
    for(int i=0; i<vNum; ++i)
        std::cout<<vertex[i].data<<"   |";
    std::cout<<std::endl<<"——————————————————————————————————————————"<<std::endl;
    std::cout<<"图的连接情况："<<std::endl;
    DFS(0);
    BFS(0);
}


template<class T>
void UnDMaGraph<T>::clear()
{
   
    for(int k=0; k<vNum; ++k)
        vertex[k].visited = false;
}
template<class T>
void UnDMaGraph<T>::Dijstra(int S)
{
   
    bool isvisit[MAXSIZE]={
   false};
    int dist[MAXSIZE];
    for(int i=0;i<vNum;
最低0.47元/天 解锁文章
鹅螺丝zz
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
题目96：把一张一元的钞票换成一分、两分、和五分的硬币，每种硬币至少一枚。问有哪几种换法？
run_noob_vip的博客
03-22 4893
Python 把一张一元的钞票换成一分、两分、和五分的硬币，每种硬币至少一枚。问有哪几种换法？
C语言：习题4-5 换硬币 (20分)
extern_int_Lin的博客
03-15 3716
将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ 输入格式: 输入在一行中给出待换的零钱数额x∈(8,100)。 输出格式: 要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。最后一行输出“count = 换法个...
3.10 把一张一元纸币换成一分、二分和五分的硬币，假如每种至少一枚，问有多少 种换法？编程将各种换法显示出来。
孑澈的专栏
07-24 1万+
3.10 把一张一元纸币换成一分、二分和五分的硬币，假如每种至少一枚，问有多少 种换法？编程将各种换法显示出来。
将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量,
最新发布
m0_74481649的博客
11-19 1259
将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？
习题4-5 换硬币 (20分) 将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？
qq_44643789的博客
05-14 9156
因为用的贪心的解法，处理效率不高，可能运行时间较长
ACM算法题100题-经典算法库
12-29
根据给定文件的信息，我们可以提炼出与ACM算法题及经典算法库相关的多个知识点。以下是对这些知识点的详细解析： ### ACM国际大学生软件大赛简介 ACM（Association for Computing Machinery）国际大学生软件大赛是...
2019中科大算法设计与分析试题资料.zip
01-09
首先，我们可以看到综合考题.pdf，这很可能是一份整合了多届考试的综合练习题，涵盖了算法设计与分析的多个主题，包括排序算法、搜索算法、图论问题、动态规划以及复杂度分析等。通过解这类题目，学习者可以检验自己...
算法设计与分析期末复习笔记+期末习题解答
05-19
根据提供的文件内容，我们可以整理出以下IT知识点...通过上述知识点的整合，我们可以看出文档内容涵盖了算法设计与分析的多个重要方面，包括但不限于各类算法的定义、性质、应用、以及在特定问题下的时间复杂度分析等。
算法导论第三版-课后习题英文参考答案.zip
01-16
《算法导论》是计算机科学领域的一本经典教材，它深入浅出地介绍了各种重要的算法，并提供了详尽的分析和实现。第三版更是对前两版进行了更新和扩展，覆盖了更多的现代算法和数据结构。这份名为“算法导论第三版-...
广工算法设计与分析
05-04
1. **基础算法**：包括排序（如冒泡排序、插入排序、快速排序、归并排序）、查找（线性查找、二分查找）等经典算法，这些是所有算法学习的基础，理解和掌握它们对于后续的学习至关重要。 2. **图论算法**：如最短...
Python 硬币兑换问题
09-18
主要介绍了Python 硬币兑换问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
7-69 换硬币 (20 分) 将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ PTA：中M2021春C、Java入门练习第I段—变量、表达式、分支、循环
count_Yeah的博客
05-23 1615
7-69 换硬币 (20 分) 将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ 输入格式: 输入在一行中给出待换的零钱数额x∈(8,100)。 输出格式: 要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。最后一行输出“count = 换法个数”。 输入样例: 13 输出样例: fen5:2, fen2:1, fen1:1, t
PTA换硬币（枚举）
haha_7的博客
11-20 3210
将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ 输入格式: 输入在一行中给出待换的零钱数额x∈(8,100)。 输出格式: 要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法，格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。最后一行输出“count = 换法个数”。 输入样例: 13 输出样例: fen5:2, fen2:1, fen1:1, total:4 fen5:1, f
python循环结构程序设计硬币兑换问题_Python 硬币兑换问题
weixin_30600605的博客
02-20 691
硬币兑换问题：给定总金额为A的一张纸币，现要兑换成面额分别为a1,a2,....,an的硬币，且希望所得到的硬币个数最少。# 动态规划思想 dp方程式如下# dp[0] = 0# dp[i] = min{dp[i - coins[j]] + 1}, 且 其中 i >= coins[j], 0 <= j < coins.length# 回溯法，输出可找的硬币方案# path[i] ...
python 换硬币
Disball的博客
12-25 1811
将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ def solve(): a = int(input()) i = 0 b = a while b > 0: i += 1 b = a - i * 5 j = 0 c = b while c >...
7-4 换硬币（20 分）
个人学习，如有不当，望指正，万分感谢！
08-13 4692
将一笔零钱换成5分、2分和1分的硬币，要求每种硬币至少有一枚，有几种不同的换法？ 输入格式: 输入在一行中给出待换的零钱数额x∈(8,100)。 输出格式: 要求按5分、2分和1分硬币的数量依次从大到小的顺序，输出各种换法。每行输出一种换法， 格式为：“fen5:5分硬币数量, fen2:2分硬币数量, fen1:1分硬币数量, total:硬币总数量”。 最后一行输出“count = 换法个...
Python货币转换
热门推荐
ChengQian_的博客
06-24 1万+
人民币和美元是世界上通用的两种货币之一，人民币和美元间汇率固定为：1美元 = 7.00人民币。 请用程序实现 将用户输入的美元转换为人民币，或将输入的人民币转换为美元。 要求如下： (1) 输入输出的人民币采用大写的 RMB 开头，金额可以是整数或小数，如：RMB123 指人民币123元； (2) 输入输出的美元采用大写的 USD 开头，金额可以是整数或小数，如：USD20 指美元 20 元； (3) 输出保留小数点后两位，方法为：print("%.2f" % a)。输入格式错误时，输出提示：输入格式错误；
硬币组合问题python_Python,求钱币组合情况,用一分两分和五分的硬币攒的钱一元钱，的所有情况...
weixin_42660494的博客
01-30 2183
展开全部total = 5000 #总额500元one_yuan = 10 #面额1元five_jiao = 5 #面额5角32313133353236313431303231363533e4b893e5b19e31333436316335one_jiao = 1 #面额1角count=0for i in range(total // one_yuan+1):for j in range((tot...
将1元或多元钱分成5、2、1分的
qq_43587158的博客
11-16 607
#include &lt;iostream&gt; using namespace std; int main() { int n, a=0, b, c=0; cout &lt;&lt; "请输入钱数："; cin &gt;&gt; n; n = n * 100; for (int i = n / 5; i &gt;= 0; i--) { b = a *5/ 2; b = b ...
微软数据结构算法面试100题答案集
本文档是一份珍贵的面试指南，由作者July和阿财共同整理，涵盖了微软等公司数据结构和算法面试中的100道题目及其全部答案。这份资料发布于2011年10月13日，正值作者开博一周年，作者希望通过分享这些面试题目，回馈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值