北航机试准备+常用数据结构（算法笔记）

最新推荐文章于 2022-10-02 15:55:17 发布
原创 最新推荐文章于 2022-10-02 15:55:17 发布 · 3.4k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#机试

本文提供了一系列经典的算法题目解答，涵盖中位数查找、变量定义检查、家谱成员关系搜索、并存集处理、Bellman-Ford算法、Flory算法、Prim算法及KMP算法的应用实例。通过实际代码示例，深入解析了各种算法的工作原理和实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

17年

1.求中位数的位置

先输入一个整形数字N，接着输入N个无序的数字。要求输出升序排列后的中位数，以及该中位数输入的次序。如果N为偶数，则输出有二个中位数，如果N为奇数，输出最中间的数即可。

样例1：

输入：5

9 2 7 1 6

输出：6 5

样例2：

输入：6

9 6 7 1 2 3

输出：3 6

#include<stdio.h>
#include<math.h>
#include<string.h>
#define maxn 1000
int main()
{
    
    int n[maxn];
    int i=0;
    int j=0;
    int ii=0;
    int m;
    int k;
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    scanf("%d",&i);
    for (ii=0;ii<i;ii++)
    {
        scanf("%d",&n[ii]);
    }
    for (ii=i-1;ii>0;ii--)
    {    
        for(k=0;k<ii;k++)
        {
            if(n[k]>n[k+1])
            {
                j=n[k];
                n[k]=n[k+1];
                n[k+1]=j;
            }
        }
        for(m=0;m<i;m++)
        {
            printf("%d ",n[m]);
        }
        printf("\n");
    }
    if(i%2==0)
    {
        printf("%d %d\n",n[i/2-1],n[i/2]);
    }else{
        printf("%d\n",n[(i-1)/2]);
    }
}


 

2.查找未定义变量

输入两个C语言语句，第一句为正常的C语言变量定义语句，符合C语言语法要求，变量间可以有多个空格，包含数组，指针定义等。第二句为变量运算语句，要求输出第二个C语言语句中未定义的变量。

样例：

输入： int x12, y=1, num_stu=89, a[30], *p;

Sum=num+x12*y;

输出：

Sum num

#include<stdio.h>
#include<math.h>
#include<string.h>
#define maxn 1000
#define true 1
#define false 0
int Isword(char c);
int END(char c);
int check(char word[]);
int num;
char name[1000][20];
int main()
{
    int xx;
    char word[20];
    int n=0,i=0,ii;
    int flag=true;
    char c;
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    while((c=getchar())!=EOF)
    {
        if(c==' ') break;
    }
    while((c=getchar())!=EOF)
    {
        if(END(c)&&i!=0) 
        {
            name[n][i]='\0';
            n++;
            i=0;
            flag=false;
        }
        if(c==';'){
            name[n][i]='\0';
            break;
        }
        if(flag && Isword(c))name[n][i++]=c;
        flag=true;
    }
    //for(ii=0;ii<n;ii++){
    //    printf("%s ",name[ii]);
    //}
    num=n;
    getchar();
    //printf("%d ",c);
    //n=0;
    i=0;
    
    getchar();
    getchar();
    //printf("asda\n");
    while((c=getchar())!=EOF)
    {
        //printf("%d ",c);
        if(END(c))
        {
            word[i]='\0';
            i=0;
            if(!check(word)) printf("%s ",word,);
            memset(word,0,20);
            
        }else
        {
            word[i++]=c;
        }
        if (c==';') break;
    }
    
}
int Isword(char c)
{
    if((c>='a'&&c<='z')||(c>='A'&&c<='Z')||(c>='0'&&c<='9')||c=='_') return 1;
    return 0;
}
int END(char c)
{
    if(c=='='||c=='+'||c=='-'||c=='*'||c=='/'||c=='%'||c==';'||c==','||c=='['||c==']'||c==' ') return true;
    return false;
}
int check(char word[])
{
    int i=0;
    for(;i<num;i++)
    {
        if(strcmp(name[i],word)==0) 
            return 1;
    }
    return 0;
}

3.找家谱成员

输入若干行，每一行的第一个输入为家谱中的某成员，该行接着输入的信息为每个孩子姓名。最后一行的输入为要求查找的两个家谱成员的关系。要求：根据输入的家谱成员信息，建立二叉树家谱关系图，并输出二位待查找成员在家谱中的关系，包括输出他们最邻近的共同祖先以及在家谱中相差的层次数。

样例：

输入：

YE SHU MEI

SHU GE MEI1

BA SELF MEI2

GE SON1 SON2

SON2 MEI1

输出：

SHU 1

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define maxn 1000
struct node{
    char name[20];
    int lchild;
    int rchild;
    int layer;
}Node[maxn];

int dfs(int n,char s[])
{
    int l,r;
    
    if(strcmp(Node[n].name,s)==0) return n;
    if(Node[n].lchild==0) return -1;
    l=dfs(Node[n].lchild,s);
    r=dfs(Node[n].rchild,s);
    return (l>r)?l:r;
}
int find(char s[])
{
    return dfs(1,s);
}
int main()
{
    char m[3][20];
    int n=1;
    int i,ii,father=0;
    int flag=0; 
    int layer1,layer2;
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    while(scanf("%s %s %s",m[0],m[1],m[2])==3)
    {
        if(flag){
            int top=find(m[0]);
            printf("top=%d \n",top);
            Node[top].lchild=++n;
            strcpy(Node[n].name,m[1]);
            Node[top].rchild=++n;
            strcpy(Node[n].name,m[2]);
            Node[Node[top].lchild].layer=Node[top].layer+1;
            Node[Node[top].rchild].layer=Node[top].layer+1;
        }else{
            int top=n;
            Node[top].layer=1;
            strcpy(Node[top].name,m[0]);
            Node[top].lchild=++n;
            strcpy(Node[n].name,m[1]);
            Node[top].rchild=++n;
            strcpy(Node[n].name,m[2]);
            Node[Node[top].lchild].layer=Node[top].layer+1;
            Node[Node[top].rchild].layer=Node[top].layer+1;
        }
        flag=1;
    }
    for(ii=1;ii<n+1;ii++)
    {
        
        if(dfs(ii,m[0])!=-1 &&dfs(ii,m[1])!=-1)
        {
            if(Node[father].layer<Node[ii].layer)
                father=ii;
        }
    }
    layer1=Node[dfs(1,m[0])].layer;
    layer2=Node[dfs(1,m[1])].layer;
    printf("%s%d",(father==1)?"None":Node[father].name,abs(layer1-layer2));
}

并存集

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#define maxn 1000
int root[maxn]={0};
int father[maxn]={0};
int k=0;
struct course{
    int id[maxn];
    int num;
}c[maxn];
int findfather(int n)
{
    if(n==father[n])
        return n;
    else return findfather(father[n]);
}
void Union(int id1,int id2)
{
    int nn,mm;
    nn=findfather(id1);
    mm=findfather(id2);
    father[nn]=mm;
}
int course[maxn][maxn];
int n;
int main()
{
    int m,id=0,test=0,max=0;
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    scanf("%d",&n);
    for(m=0;m<n;m++)
    {
        int i=0,c_num;
        scanf("%d:",&c_num);
        for(i=0;i<c_num;i++)
        {
            int c_id;
            
            scanf("%d",&c_id);
            max=max>c_id?max:c_id;
            c[c_id].id[c[c_id].num++]=m;
        }
    }
    
    for(m=0;m<n;m++)
    {
        father[m]=m;
    }
    for(test=1;test<=max;test++)
    {
        int i,ii;
        if(c[test].num==0)break;
        ii=findfather(c[test].id[0]);
        for(i=0;i<c[test].num;i++)
        {
             if (findfather(c[test].id[i])!=ii)
             {
                Union(c[test].id[i],c[test].id[0]);
             }

        }
    }
    for(m=0;m<n;m++)
    {
        if(findfather(m)==m)
        {root[m]=1;k++;
        }
        
    }
    printf("%d",k);
}

 

Bellman-Ford 有向图+负边权

#include<stdio.h>
#include <cstdio>
#include <algorithm>
#include<stdlib.h>
#include<string.h>
#include<vector>
#define INF 1000000000
#include<set>
#define maxn 100

using namespace std;
#pragma warning(disable : 4786)
set<int> Pre[maxn];
struct node{
    int v;
    int dis;
};
vector<node> Node[maxn];
int n,st,m;
int num[maxn];    int dis[maxn];
void Bellman(int s)
{
    fill(dis,dis+maxn,INF);
    //fill (dis,dis+maxn,INF);
    memset(num,0,sizeof(num));
    dis[s]=0;
    for(int v=0;v<n+1;v++)
    {
        for(int u=0;u<n;u++)
        {
            for(int k=0;k<Node[u].size();k++)
            {
                int n_node=Node[u][k].v, n_dis=Node[u][k].dis;
                if(n_dis+dis[u]<dis[n_node])
                {
                    
                    dis[n_node]=n_dis+dis[u];
                    Pre[n_node].clear();
                    Pre[n_node].insert(u);
                    num[n_node]=num[u];
                }else if(n_dis+dis[u]==dis[n_node])
                {
                    Pre[n_node].insert(u);
                    for(set<int >:: iterator it=Pre[n_node].begin();it!=Pre[n_node].end();it++){
                    num[n_node]+=num[*it];
                    }

                    
                }
            }

        }
    }

}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    node Point;
    scanf("%d %d %d",&n,&m,&st);
    for(int i=0;i<m;i++)
    {
        int n1,n2,n3;
        scanf("%d %d %d",&n1,&n2,&n3);
        Point.v=n2;
        Point.dis=n3;
        Node[n1].push_back(Point);
        //Point.v=n1;
        //Node[n2].push_back(Point);
    }
    
    Bellman(st);
    /*for(i=0;i<n;i++)
    {
        printf("原点：");
        for(int ii=0;ii<Node[i].size();ii++)
        {
            printf("(%d,%d)=%d  ",i,Node[i][ii].v,Node[i][ii].dis);
        }
        printf("\n");
    }*/
    for( i=0;i<n;i++)
    {
        printf("%d:dis=%d  Pre=",i,dis[i]);
        for(set<int> :: iterator it=Pre[i].begin();it!=Pre[i].end();it++)
        {
            printf("%d ",*it);
        }
        printf("\n");
    }
}

有向图+负权Flory算法

#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
#define maxn 100
#define INF 100000000
using namespace std;
//int G[maxn][maxn];
int dis[maxn][maxn];
int n,m;
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //fill(G[0],G[0]+maxn*maxn,INF);
    fill(dis[0],dis[0]+maxn*maxn,INF);
    scanf("%d %d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int n1,n2,n3;
        scanf("%d %d %d",&n1,&n2,&n3);
        dis[n1][n2]=n3;
        //dis[n2][n1]=n3;
    }
    for(i=0;i<n;i++)
    {
        
        dis[i][i]=0;
    }
    
    for(int u=0;u<n;u++)
    {
        for(int v=0;v<n;v++)
        {
            for(int k=0;k<n;k++)
            {
                if(dis[u][k]!=INF && dis[k][v]!=INF && dis[u][k]+dis[k][v]<dis[u][v])
                {
                    dis[u][v]=dis[u][k]+dis[k][v];
                }
            }

        }
    }
    for(i=0;i<n;i++)
    {
        for(u=0;u<i+1;u++)
        {
            printf("(%d,%d) dis=%d ",i,u,dis[u][i]);
        }
        printf("\n");
    }
}


 

Prim 

#include<stdio.h>
#include<stdlib.h>
#include<set>
#include<algorithm>
#define maxn 1000
#define INF 100000000
using namespace std;
//int G[maxn][maxn];
int G[maxn][maxn];
int dis[maxn];
bool vis[maxn]={false};
set<int >Pre[maxn];
int n,m,st;
void Prim(int s)
{
    fill(dis,dis+maxn,INF);
    dis[s]=0;
    for(int i=0;i<n;i++)
    {    int mm=-1,MIN=INF;
        for(int u=0;u<n;u++)
        {
            
            if(!vis[u]&& dis[u]<MIN)
            {
                mm=u;
                MIN=dis[u];
            }
        }
        if(mm==-1) return;
        printf("m=%d\n",mm);
        vis[mm]=true;
        for(u=0;u<n;u++)
        {
            if(!vis[u] && G[mm][u]!=INF )
            {  
                if( G[mm][u]<dis[u])
                {    
                    dis[u]=G[mm][u];
                    Pre[u].clear();
                    Pre[u].insert(mm);
                }else if(G[mm][u]==dis[u])
                {
                    Pre[u].insert(mm);
                }
            
            }

        }
    }
}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    fill(G[0],G[0]+maxn*maxn,INF);
    scanf("%d %d %d",&n,&m,&st);
    for(int i=0;i<m;i++)
    {
        int n1,n2,n3;
        scanf("%d %d %d",&n1,&n2,&n3);
        G[n1][n2]=n3;
        G[n2][n1]=n3;
    }
    Prim(st);
    for( i=0;i<n;i++)
    {
        printf("%d点:dis=%d Pre=",i,dis[i]);
        for(set<int> :: iterator it=Pre[i].begin();it!=Pre[i].end();it++)
        {
            printf("%d ",*it);
        }
        printf("\n");
    }

}


 

KMP

void getNext (char c[] ,len)
{
    int j=-1;
    next[0]=-1
    for(int i=1;i<len;i++)
    {
        if(j!=-1 && c[i]!=c[j+1])
        {
            j=next[j];
        }
        if(c[i]==c[j+1])
        {
            j++;
        }
        next[i]=j;
    }
}
int KMP (char c[],char pattern[])
{
	int j=-1;
	int n=strlen(c),m=strlen(m);
	getNext(pattern,)
	for(int i=0;i<n;i++)
	{
		if(j!=-1 && c[i]!=pattern[j+1]) j=next[j];
		if(c[i]==pattern[j+1]) j++;
		if(j==m-1)
		{
			ans++;
			j=next[j];
		}
	}
	return ans;
}

最长回文串问题：

#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
using namespace std;
#define maxn 1000
int dis[maxn][maxn];
string str;
int n;
int MAX;
int ll,rr;
int main()
{
    getline(cin,str);
    memset(dis,0,sizeof(dis));
    int n=str.length();
    for(int i=0;i<n;i++)
    {
        dis[i][i]=1;
        if(i<n-1)
        {
            if(str[i]==str[i+1])
            {
                dis[i][i+1]=1;
                MAX=2;
                ll=i;
				rr=i+1;
            }    
        }
    }
    for(int L=3;L<=n;L++)
    {
        for(int i=0;i+L-1<n;i++)
        {
            int j=i+L-1;
            if(str[i]==str[j] && dis[i+1][j-1]==1)
            {
                dis[i][j]=1;
                if(L>MAX)
                {
                    MAX=L;
                    ll=i;
                    rr=i+L-1;
                }
            }    
        }
    }
    for(i=ll;i<=rr;i++)
    {
        cout<<str[i];    
    }
    
}

 

保研考研机试攻略：第二章——入门经典（1）
qq_63349644的博客
08-08 1742
保研考研机试攻略：第二章——入门经典（1）2.1简单模拟+2.2进制转换类问题+2.3排版类问题
【算法题】机试指南-基础篇
最新发布
专注大前端
05-09 1105
STL定义了强大的、基于模板的、可复用的组件，实现了许多通用的数据结构及处理这些数据结构的算法。其中包含三个关键组件——容器（container，流行的模板数据结构）、迭代器（iterator）和算法（algorithm）。容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。评判结果就是提交代码后系统返回的结果，这个不仅仅只是一个结果，还可以是一个debug的提示。迭代器 用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。
北航数据结构、组成原理、操作系统、计算机网络课件
03-05
北航数据结构、组成原理、操作系统、计算机网络课件
范神北航机试复习指南20201
08-08
输入的n行中第一行第一个节点为根节点，作为起点。保证输入的结点至多有一个父节点。然后输入m（m < n），接下来输入m个客户，每行输入他的目标（叶节点）和优先级
北航机试复习指南20201
08-08
输入的n行中第一行第一个节点为根节点，作为起点。保证输入的结点至多有一个父节点。然后输入m（m < n），接下来输入m个客户，每行输入他的目标（叶节点）和优先级
我是如何在一周内准备完所有保研材料并成功保送北航的
sinyusin的博客
10-08 8238
本科某985分校软件工程专业，排名13/131，算是一个边缘保研生了，大学学习成绩不是特别突出，奖项数量还算比较多，但是普遍都只是徘徊在省二省三的水平，项目经历比较丰富，平时也是养成了遇到问题刨根问底的习惯，虽然过程中花费了很多时间，但通过这一过程真的学到了很多，而且从最后面试的情况来看，认真做好每一个项目，认真看待每一个问题，是值得的，最后自己有幸通过了北京航空航天大学的网络空间安全学院的九推面...
北航面试之数据结构知识要点
说到做到_我的忍道
06-03 5656
数据结构复习重点归纳 一、 数据结构的章节结构及重点构成 数据结构学科的章节划分基本上为：概论，线性表，栈和队列，串，多维数组和广义表，树和二叉树，图，查找，内排，外排，文件，动态存储分配。 对于绝大多数的学校而言，“外排，文件，动态存储分配”三章基本上是不考的，在大多数高校的计算机本科教学过程中，这三章也是基本上不作讲授的。所以，大家在这三章上可以不必花费过多的精力，只要知道基本的
北航机试
qq_30983445的博客
04-14 572
1301 题目描述：给一个真分数的分子分母，输出约分后的分子分母。 输入 输出 3 6 1/2 15 25 3/5 #include&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;
北航数据结构PPT
05-31
北航数据结构PPT，考研的可以看看啦。基于严蔚敏版的书。
北京航空航天大学数据结构
11-06
北京航空航天大学数据结构课本课后题详细解析
2014北航机试
qq_36614721的博客
05-28 242
代码均为自做 题目一 阶乘数。输入一个正整数，输出时，先输出这个数本身，跟着一个逗号，再输出这个数的各位数字的阶乘和，等号，阶乘和的计算结果，并判断阶乘和是否等于原数，如果相等输出Yes，否则输出No。各数字均不会超出INT的范围 输入： 145 输出： 145,1!+4!+5！=145 Yes 输入： 1400 输出： 1400,1!+4!+0!+0!=27 No #include <iostream> using namespace std; int factirial(int x
北航计算机学院数据结构与算法 老师ppt
12-24
数据结构 北航计算机学院数据结构与算法- 老师ppt
北航计算机考研复试 机试 试题
03-29
北航计算机考研 复试 机试（c语言） 试题
2020北航计算机复试经验,2020三跨考生复试经验贴，附上机复习指南（希望大家可以一起维护）...
weixin_39713686的博客
07-26 1745
本帖最后由 慕弋云子 于 2020-7-6 15:29 编辑大家好，我是之前写万字攻略的那位慕弋云子2020三跨考生五个月一战高效上岸北航CS学硕的万字长文攻略现在我来补上复试经验和这个非常awesome的上机指南了！我准备了三个月的复试上机，就这么突然不考了 不过还好最后一周多把握住火速刷完了离散数学。。下面进入正文：一、综述关于复试的具体细节，大家可以参见其他经验贴和计算机学院官网往年的复试安...
2019年北理工计算机&北航计算机&中山大学计算机&北邮网研院保研夏令营
larry1648637120的博客
07-26 1万+
目录 1.个人情况 2.夏令营入营情况 3.报名准备建议 3.1 准备一个txt 文本，上面有个人信息，方便填写每个大学的报名申请，包括以下信息： 3.2 电脑上新建一个文件夹和一个网页收藏夹 3.3 一些可能需要使用的工具和软件： 3.4 提前联系导师（如果你特别想去这个学校/老师团队的话） 3.5 其他重要建议 4.夏令营经历 4.1 概述 4.2 北理工计算机夏令营 7...
2022年（2023届）计算机保研经历分享（清深、自所、计算所、浙科南、北航、哈工等）
热门推荐
Polaris的博客
10-02 1万+
西电计算机保研经历
2012北航机试
qq_36614721的博客
05-28 248
代码均为自做 题目一 某些整数能分解成若干个连续整数的和的形式，例如 15 = 1 + 2＋3＋4＋5　 15 = 4 + 5 + 6 15 = 7 + 8 某些整数不能分解为连续整数的和，例如：16 输入：一个整数N（N <= 10000） 输出：整数N对应的所有分解组合，按照每个分解中的最小整数从小到大输出，每个分解占一行，每个数字之间有一个空格（每行最后保留一个空格）；如果没有任何分解组合，则输出NONE。 #include <iostream> using namespace
北航2017年机试
我在浪里
01-29 863
1.从一个无序不重复数组中，输出中间的数和它在数组中的次序（从1开始）如果是偶数个元素，则输出两个，奇数则输出中间一个 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cmath&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; #include&lt;string&g...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值