19版考研数据结构王道课后习题代码-树 上【完】

最新推荐文章于 2022-06-22 15:07:10 发布
最新推荐文章于 2022-06-22 15:07:10 发布
阅读量265 收藏
点赞数
分类专栏： 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36927714/article/details/101763087
版权 
#include <iostream>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <stack>
using namespace std;
#define maxSize 101
#include <iostream>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <stack>
using namespace std;
#define maxSize 101

/*
 //从图的邻接表转换成邻接矩阵 王道P192.4
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;  //边表节点
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];  //顶点表节点
typedef struct Graph
{
    int VNum,ENum;
    VNodeL adjlist;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
void Transfer(Graph g,int matrix[][maxSize])
{
    for(int i=0;i<g.VNum;i++)
    {
        ENode *p=g.adjlist[i].firstchild;
        while(p)
        {
            matrix[i][p->adjvex]=1;
            p=p->next;
        }
    }
}
int main()
{
    Graph g;
    Create(g);
    int matrix[maxSize][maxSize];
    for(int i=0;i<g.VNum;i++)
    {
        for(int j=0;j<g.VNum;j++)
        {
            matrix[i][j]=0;
        }
    }
    Transfer(g,matrix);
    for(int i=0;i<g.VNum;i++)
    {
        for(int j=0;j<g.VNum;j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<endl;
    }
}
 
 // 4
 // 4
 // 0 1 2 3
 // 0 1
 // 0 2
 // 0 3
 // 1 3
 // 0 1 1 1
 // 1 0 0 1
 // 1 0 0 0
 // 1 1 0 0
 */

/*
 //判断一个无向图是否是一棵树  王道P201.2  若深搜经过的顶点=图的总顶点数，经过的边数等于总顶点数-1则是图
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;  //边表节点
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];  //顶点表节点
typedef struct Graph
{
    int VNum,ENum;
    VNodeL adjlist;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int visited[maxSize];
void DFS(Graph g,int v,int &d,int &e)
{
    visited[v]=1;
    d++;  //统计经过的点的个数！！
    ENode *p=g.adjlist[v].firstchild;
    while (p) {
        e++;  //统计经过的边的个数！！
        if(visited[p->adjvex]==0)
        {
            DFS(g,p->adjvex,d,e);
        }
        p=p->next;
    }
    
}
bool Judge(Graph g,int d,int e)
{
    if(d==g.VNum&&e/2==g.VNum-1)
    {
        return true;
    }
    return false;
}
int main()
{
    Graph g;
    Create(g);
    int d=0;
    int e=0;
    DFS(g,0,d,e);
    cout<<d<<" "<<e<<endl;
    bool x=Judge(g,d,e);
    cout<<x<<endl;
}
 
 // 4
 // 4
 // 0 1 2 3
 // 0 1
 // 0 2
 // 0 3
 // 1 3
 // 4 8
 // 0
*/


/*
//图的深搜的非递归算法 王道P201.3
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;  //边表节点
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];  //顶点表节点
typedef struct Graph
{
    int VNum,ENum;
    VNodeL adjlist;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int visited[maxSize];
void DFS(Graph g,int v)
{
    visited[v]=1;
    int stack[maxSize];
    int top=-1;
    stack[++top]=v;
    while(top!=-1)
    {
        v=stack[top--];
        cout<<v<<endl;
        ENode *p=g.adjlist[v].firstchild;
        while(p)
        {
            if(visited[p->adjvex]==0)
            {
                visited[p->adjvex]=1;
                stack[++top]=p->adjvex;
            }
            p=p->next;
        }
    }
}
int main()
{
    Graph g;
    Create(g);
    for(int i=0;i<g.VNum;i++)
        visited[i]=0;
    DFS(g,2);
}
*/


/*
 //判断是否存在由顶点i到顶点j的路径 使用DFS和BFS 王道P201.4
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;  //边表节点
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];  //顶点表节点
typedef struct Graph
{
    int VNum,ENum;
    VNodeL adjlist;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int visited[maxSize];
int BFS(Graph g,int i,int j)
{
    int queue[maxSize];
    int front=1;
    int rear=1;
    queue[rear++]=i;
    visited[i]=1;
    while(front!=rear)
    {
        i=queue[front++];
        if(i==j)
        {
            return 1;
        }
        ENode *p=g.adjlist[i].firstchild;
        while(p)
        {
            if(visited[p->adjvex]==0)
            {
                visited[p->adjvex]=1;
                queue[rear++]=p->adjvex;
            }
            p=p->next;
        }
    }
    return 0;
}
int DFS(Graph g,int i,int j)
{
    int stack[maxSize];
    int top=-1;
    visited[i]=1;
    stack[++top]=i;
    while(top!=-1)
    {
        i=stack[top--];
        if(i==j)
        {
            return 1;
        }
        ENode *p=g.adjlist[i].firstchild;
        while(p)
        {
            if(visited[p->adjvex]==0)
            {
                visited[p->adjvex]=1;
                stack[++top]=p->adjvex;
            }
            p=p->next;
        }
    }
    return 0;
}
int main()
{
    Graph g;
    Create(g);
    for(int k=0;k<g.VNum;k++)
        visited[k]=0;
    int i=1,j=2;
    int d1=BFS(g,i,j);
    cout<<d1<<endl;
    for(int k=0;k<g.VNum;k++)
        visited[k]=0;
    int d2=DFS(g,i,j);
    cout<<d2<<endl;
}
*/


/*
 //输出从i到j的所有简单路径 王道P201，5  ！！重点
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;  //边表节点
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];  //顶点表节点
typedef struct Graph
{
    int VNum,ENum;
    VNodeL adjlist;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int visited[maxSize];

void DFS(Graph g,int i,int j,int d,int path[])
{
    visited[i]=1;
    int stack[maxSize];
    int top=-1;
    stack[++top]=i;
    d++;
    path[d]=i;
    while(top!=-1)
    {
        i=stack[top];
        cout<<i<<endl;
        //        if(i==j)
        //        {
        //            for(int k=0;k<=d;k++)
        //            {
        //                cout<<path[k];
        //            }
        //        }
        ENode *p=g.adjlist[i].firstchild;
        while (p&&visited[p->adjvex]==1) {
            p=p->next;
        }
        if(p==NULL)
        {
            // visited[stack[top]]=0;
            top--;
        }
        else
        {
            d++;
            path[d]=p->adjvex;
            stack[top++]=p->adjvex;
            visited[p->adjvex]=1;
        }
    }
}

//void DFS(Graph g,int i,int j,int d,int path[])
//{
//    visited[i]=1;
//    d++;
//    path[d]=i;
//    if(i==j)
//    {
//        for(int k=0;k<=d;k++)
//        {
//            cout<<path[k]<<" ";
//        }
//        cout<<endl;
//    }
//    ENode *p=g.adjlist[i].firstchild;
//    while(p)
//    {
//        if(visited[p->adjvex]==0)
//        {
//            DFS(g,p->adjvex,j,d,path);
//            visited[p->adjvex]=0;
//        }
//        p=p->next;
//    }
//}

int main()
{
    Graph g;
    Create(g);
    for(int i=0;i<g.VNum;i++)
    {
        visited[i]=0;
    }
    int i=1,j=3;
    int path[maxSize];
    int d=0;
    DFS(g,i,j,d,path);
}


//6
//6
//0 1 2 3 4 5
//0 1
//1 2
//2 3
//1 4
//4 3
//3 5
//0 1 4 3
//0 1 2 3
*/


/*
 //对于顺序存储的树，求编号i,j的两个节点的最近公共祖先节点的值 P110 5
 //顺序存储的树直接用数组表示就好了
int FindParent(int tree[],int i,int j,int n)
{
    while(i!=j)
    {
        if(i>j)
            i=i/2;
        else if(i<j)
            j=j/2;
    }
    return i;
}
int main()
{
    int i,j;
    cin>>i>>j;
    int n;
    int tree[maxSize];
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>tree[i];
    int d=FindParent(tree,i,j,n);
    cout<<d<<endl;
}

//5 8
//9
//1 2 3 4 5 6 7 8 9
//2
*/


/*
 //后序遍历二叉树的非递归算法  P123.3
typedef struct Tree
{
    int data;
    Tree *lchild,*rchild;
};
void PostTraval(Tree *t)
{
    Tree *stack[maxSize];
    int top=-1;
    stack[++top]=t;
    Tree *r;
    while(top!=-1)
    {
        while(t)
        {
            stack[++top]=t;
            t=t->lchild;
        }
        t=stack[top];
        if(t->lchild==NULL&&t->rchild!=r)
        {
            t=t->rchild;
        }
        else
        {
            top--;
            cout<<t->data<<" ";
            r=t;
            t=NULL;
        }
    }
}
Tree *Create(Tree *&t,int ch)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=ch;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    else if(ch<=t->data)
        t->lchild=Create(t->lchild,ch);
    else if(ch>t->data)
        t->rchild=Create(t->rchild,ch);
    return t;
}
int main()
{
    Tree *t=NULL;
    int n,a[maxSize];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        t=Create(t,a[i]);
    }
    PostTraval(t);
}
 */



/*
 //给出自下而上从右到左的层次遍历算法 P123 4  先把从上到下从左到右的层次遍历结果存到栈中，再从栈中输出
typedef struct Tree{
    int data;
    Tree *lchild,*rchild;
}Tree;
int s[maxSize];
int top=-1;
void LayerTraval(Tree *t)
{
    Tree *queue[maxSize];
    int front=1;
    int rear=1;
    queue[rear++]=t;
    while(front!=rear)
    {
        Tree *q=queue[front];
        s[++top]=q->data;
        front++;
        if(q->lchild)
        {
            queue[rear++]=q->lchild;
        }
        if(q->rchild)
        {
            queue[rear++]=q->rchild;
        }
    }
}
Tree *insert(Tree *&t,int ch)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=ch;
        t->lchild=NULL;
        t->rchild=NULL;
    }
    if(ch<t->data)
    {
        t->lchild=insert(t->lchild,ch);
    }
    else if(ch>t->data)
    {
        t->rchild=insert(t->rchild,ch);
    }
    return t;
}
int main()
{
    Tree *t=NULL;
    int n,a[maxSize];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        t=insert(t,a[i]);
    }
    LayerTraval(t);
    while(top!=-1)
    {
        cout<<s[top--]<<" ";
    }
}
 
 //6
 //5 3 6 1 4 8
 //8 4 1 6 3 5
 */


/*
 //非递归法求二叉树的高度 P123 5
typedef struct Tree{
    int data;
    Tree *lchild,*rchild;
}Tree;
Tree *insert(Tree *&t,int ch)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=ch;
        t->lchild=t->rchild=NULL;
    }
    else if(ch<t->data)
    {
        insert(t->lchild,ch);
    }
    else if(ch>t->data)
    {
        insert(t->rchild,ch);
    }
    return t;
}
void DFS(Tree *t,int &max)
{
    Tree *stack[maxSize];
    int top=-1;
    int h=0;
    while(t||top!=-1)
    {
        while(t)
        {
            stack[++top]=t;
            t=t->lchild;
            h++;
            if(h>max)
                max=h;
        }
        if(top!=-1)
        {
            t=stack[top--];
            h--;
            t=t->rchild;
        }
    }
}
int main()
{
    Tree *t=NULL;
    int n;
    int a[maxSize];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        t=insert(t,a[i]);
    }
    int max=0;
    DFS(t,max);
    cout<<max<<endl;
}
//
// 6
// 5 3 6 2 1 8
// 4
*/


/*
 //由先序遍历和中序遍历建树 P123 6
typedef struct Tree{
    int data;
    Tree *lchild,*rchild;
}Tree;
Tree *CreatTree(int pre[],int in[],int preL,int preR,int inL,int inR)
{
    if(preL<=preR)
    {
        Tree *p=(Tree*)malloc(sizeof(Tree));
        p->lchild=NULL;
        p->rchild=NULL;
        p->data=pre[preL];
        int k;
        for(int i=inL;i<=inR;i++)
        {
            if(in[i]==pre[preL])
            {
                k=i;
                break;
            }
        }
        p->lchild=CreatTree(pre,in,preL+1,preL+(k-inL),inL,k-1);
        p->rchild=CreatTree(pre,in,preL+(k-inL)+1,preR,k+1,inR);
        return p;
    }
    return NULL;
}
void postTraval(Tree *t)
{
    if(t)
    {
        postTraval(t->lchild);
        postTraval(t->rchild);
        cout<<t->data<<" ";
    }
}
int main()
{
    int pre[maxSize],in[maxSize];
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>pre[i];
    }
    for(int i=0;i<n;i++)
    {
        cin>>in[i];
    }
    Tree *t=NULL;
    t=CreatTree(pre,in,0,n-1,0,n-1);
    postTraval(t);
}
 
 //6
 //5 3 2 1 6 8
 //1 2 3 5 6 8
 //1 2 3 8 6 5
*/


/*
 //链表形式，判断二叉树是否是完全二叉树 P123 7  //检查每一层的节点数
typedef struct Tree{
    int data,lev;
    Tree *lchild,*rchild;
}Tree;
Tree *insert(Tree *&t,int ch)
{
    if(t==NULL)
    {
        t=(Tree*)malloc(sizeof(Tree));
        t->data=ch;
        t->lchild=t->rchild=NULL;
    }
    else if(ch<t->data)
    {
        insert(t->lchild,ch);
    }
    else if(ch>t->data)
    {
        insert(t->rchild,ch);
    }
    return t;
}
int BFS (Tree *t)
{
    Tree *queue[maxSize];
    int front=0;
    int rear=0;
    int l;
    queue[rear]=t;
    queue[rear]->lev=1;
    rear++;
    while(front!=rear)
    {
        Tree *p=queue[front];
        l=queue[front]->lev;
        front++;
        if(p->lchild)
        {
            queue[rear]=p->lchild;
            queue[rear]->lev=l+1;
            rear++;
        }
        if(p->rchild)
        {
            queue[rear]=p->rchild;
            queue[rear]->lev=l+1;
            rear++;
        }
    }
    for(int i=1;i<l;i++)
    {
        int cnt=0;
        for(int j=0;j<rear;j++)
        {
            if(queue[j]->lev==i)
            {
                cnt++;
            }
        }
        if(cnt!=pow(2,i-1))
            return 0;
    }
    return 1;
}
int main()
{
    Tree *t=NULL;
    int n;
    int a[maxSize];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
        t=insert(t,a[i]);
    }
    int d=BFS(t);
    cout<<d<<endl;
}
 */



/*
 //输出从i到j的所有简单路径 王道P201，5  ！！重点
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;  //边表节点
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];  //顶点表节点
typedef struct Graph
{
    int VNum,ENum;
    VNodeL adjlist;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int visited[maxSize];

void DFS(Graph g,int i,int j,int d,int path[])
{
    visited[i]=1;
    int stack[maxSize];
    int top=-1;
    stack[++top]=i;
    d++;
    path[d]=i;
    while(top!=-1)
    {
        i=stack[top];
        cout<<i<<endl;
        //        if(i==j)
        //        {
        //            for(int k=0;k<=d;k++)
        //            {
        //                cout<<path[k];
        //            }
        //        }
        ENode *p=g.adjlist[i].firstchild;
        while (p&&visited[p->adjvex]==1) {
            p=p->next;
        }
        if(p==NULL)
        {
            // visited[stack[top]]=0;
            top--;
        }
        else
        {
            d++;
            path[d]=p->adjvex;
            stack[top++]=p->adjvex;
            visited[p->adjvex]=1;
        }
    }
}

//void DFS(Graph g,int i,int j,int d,int path[])
//{
//    visited[i]=1;
//    d++;
//    path[d]=i;
//    if(i==j)
//    {
//        for(int k=0;k<=d;k++)
//        {
//            cout<<path[k]<<" ";
//        }
//        cout<<endl;
//    }
//    ENode *p=g.adjlist[i].firstchild;
//    while(p)
//    {
//        if(visited[p->adjvex]==0)
//        {
//            DFS(g,p->adjvex,j,d,path);
//            visited[p->adjvex]=0;
//        }
//        p=p->next;
//    }
//}

int main()
{
    Graph g;
    Create(g);
    for(int i=0;i<g.VNum;i++)
    {
        visited[i]=0;
    }
    int i=1,j=3;
    int path[maxSize];
    int d=0;
    DFS(g,i,j,d,path);
}

 
 //6
 //6
 //0 1 2 3 4 5
 //0 1
 //1 2
 //2 3
 //1 4
 //4 3
 //3 5
 //0 1 4 3
 //0 1 2 3
*/


/*
 //对于顺序存储的树，求编号i,j的两个节点的最近公共祖先节点的值 P110 5
 //顺序存储的树直接用数组表示就好了
 int FindParent(int tree[],int i,int j,int n)
{
    while(i!=j)
    {
        if(i>j)
            i=i/2;
        else if(i<j)
            j=j/2;
    }
    return i;
}
int main()
{
    int i,j;
    cin>>i>>j;
    int n;
    int tree[maxSize];
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>tree[i];
    int d=FindParent(tree,i,j,n);
    cout<<d<<endl;
}
 
 //5 8
 //9
 //1 2 3 4 5 6 7 8 9
 //2
*/

 

努力努力再努力0.0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
19版考研数据结构王道课后习题代码-查找【完】
努力努力再努力0.0的博客
09-17 432
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
数据结构课后习题源代码
02-26
数据结构数据
王道数据结构课后代码题（可直接运行，不断更新）
weixin_45552475的博客
10-21 2045
题目目录1、从线性表中删除最小元素，并将最后一个值赋值2、逆置线性表3、删除线性表指定元素x 下面是我所遇到的数据结构的代码题，哈哈哈做个记录，可能算法不够优秀嘻嘻！！ 1、从线性表中删除最小元素，并将最后一个值赋值 /** * 从顺序表中删除具有最小的元素（假设唯一）并由函数返回被删除元素的值， * 空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行 * @return */ #include "bits/stdc++.h" using namespace std; #defi
19版考研数据结构王道课后习题代码-图【未完】
努力努力再努力0.0的博客
09-18 426
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
考研王道数据结构代码.zip
11-26
"考研王道数据结构代码.zip"这个压缩包包含了2020年王道数据结构课程的课后习题代码，对于考生来说是一个宝贵的参考资料。 王道数据结构教材以其清晰易懂的讲解和丰富的例题著称，其配套的可执行代码可以帮助学生更...
王道数据结构2019考研视频讲解+视频讲义PPT+课后习题讲解
06-10
这个资源包"王道数据结构2019考研视频讲解+视频讲义PPT+课后习题讲解"是针对准备计算机专业考研，特别是北大867科目考生的重要学习资料。 首先，"王道数据结构2019考研视频讲解"部分，可能是由专业讲师录制的一系列...
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
王道数据结构考研复习指导（2022年）-选择题(CSDN).pdf
12-28
数据结构是计算机科学中的核心课程，对于准备考研的学生来说，理解和掌握数据结构至关重要。本复习指导聚焦于2022年的考研选择题，涵盖了数据结构的基础概念和算法评估等相关知识。 1. 数据结构的基本概念： - ...
数据结构课后答案+代码版数据结构课后答案+代码版
04-19
数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版数据结构课后答案+代码版
王道计算机网络2019考研视频讲解视频+课后习题视频+讲义
06-10
本资源里包含王道自己出的配套王道考研书籍的讲解视频，视频讲义PPT，课后习题讲解（课后习题讲解只选取部分题讲解，不是全部讲解）！！上传的压缩文件里包含视频百度云链接）
二叉树的考研常见问题代码
03-09
408考试二叉树习题答案. 主要有递归和非递归二种写法.
数据结构复习（王道参考书部分习题代码）
太菜了
05-15 757
线性表（主要是题目要求的函数） 部分未测试 //设计一个算法，删除不带头结点的单链表L中所有值为x的结点 void Del(LinkList &L,ElemType e) { Node *p = L;//L不是头结点，没有头结点 if(p==NULL)//为空 return; if(L->data==x){ //当前结点的值为x L=L->next;//L后移 free(p);//p为开始的L
19版考研数据结构王道课后习题代码-排序【未完】
努力努力再努力0.0的博客
09-16 363
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
王道数据结构习题代码2.3.8(链表)
weixin_46503238的博客
05-02 1234
第一题(链表中递归删除元素x) #include <stdio.h> #include <stdlib.h> #include<stdbool.h> //双向链表 typedef int Elemtype; typedef struct LNode { Elemtype data; struct LNode *next; } LNode,*LinkList; void Delete_x(LNode *P,LNode *C,Elemtype e)
王道考研数据结构顺序表相关例题习题代码
Eknight123的博客
05-15 1381
代码是自己写的。 我的顺序表是以1为开始的下标，和书上的不一样。其中习题部分的代码是我自己写的，和书中答案不太一样，比如习题第8题，觉得书上答案用三次倒置操作很智障，自己写的代码多消耗了点空间，但时间效率比答案好。 #include <bits/stdc++.h> #define MAX_SIZE 50 using namespace std; //顺序表 typedef int...
王道课后代码题整理第二章2.2（1-7）
qq_46160683的博客
06-22 229
思路来源：考研数据结构重点代码题速成&王道数据结构算法题(代码大题)详解_哔哩哔哩_bilibili1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小元素的位置。bool Del_Min(sqList &L,ElemType &value){ //删除顺序表L中的最小值元素结点，并通过引用型value返回其值 /
19版考研数据结构王道课后习题代码-树 下【未完】
努力努力再努力0.0的博客
10-09 212
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
23王道数据结构代码题全解（一）
漫磋嗟
04-09 9421
此次更新线性表（7/14）计划更新23王道数据结构所有课后代码习题的实现，虽然考试写的一般都是伪代码，但是强迫症的我还是全部实现了一遍，都可以编译运行，包含暴力解和最优解，仓库在这里 https://github.com/mancuoj/wangdao
王道考研数据结构精华笔记：逻辑与存储结构解析
"王道计算机考研 数据结构 笔记（包括PPT内容和笔记内容）" 数据结构是计算机科学中的核心课程，对于准备计算机考研的学生来说尤为重要。本资源提供了全面的数据结构笔记，涵盖了从基本概念到高级主题的详细讲解。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值