东北大学计算机专业研究生入学考试2004年真题

最新推荐文章于 2021-04-14 21:57:18 发布
最新推荐文章于 2021-04-14 21:57:18 发布
阅读量1.5k 收藏 2
点赞数 1
分类专栏： C 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zl19890124/article/details/18357867
版权 
/*-------------------------------------------------------C语言部分------------------------------------------------------------------*/
/*三.设有算术表达式，其中包含有大括号”{ " " }"  中括号"[" "]" 小括号 "(" ")",试编写一个递归函数，判断表达式中的括号是否匹配*/
typedef char StackEntry;
int Check( )
{
    STACK S;        //定义栈结构S
    char ch;
	InitStack(&S);      //初始化栈S
	while ((ch = getchar()) != '\n')
	{   
		//以字符序列的形式输入表达式
		switch (ch)
		{
			case (ch == '(' || ch == '[' || ch == '{'):
				Push(&S,ch);break;  //遇左括号入栈
			//在遇到右括号时，分别检测匹配情况
			case (ch == ')'):
				if (StackEmpty(S))
					retrun FALSE;     
                else 
				{
					Pop(&S,&ch);
                    if (ch != '(') 
						return FALSE;
				}
                break;
			case (ch == ']'): 
				if (StackEmpty(S))
					retrun FALSE;
                else
				{
					Pop(&S,&ch);
					if (ch != '[')
						return FALSE;
				}
                break;
			case (ch == '}'): 
				if (StackEmpty(S)) 
					retrun FALSE;
                else 
				{
					Pop(&S,&ch);
                    if(ch != '{') 
						return FALSE;
				}
                break;
			default:break;
		}
	}
	if (StackEmpty(S)) 
		return TRUE;
	else 
		return FALSE;
}

/*四.设有一个整数序列，有n个整数（0<n<100）.试编写程序，根据整数的大小，对其从小到大进行连续编号。
 要求:1 不能改变序列的顺序;  2相同的整数只保留一个。
 例如： 输入序列为:5,3,5,7,8,3,5,10,6    输出为： 序列-- 5,3,7,8,10,6   编号-- 2,1,4,5,6,3*/
#include<stdio.h>
void main()
{
	struct n
	{
		int di;  //存放整数
		int k;   //存放di的编号
	}num[100] = {{0,0}}; //全部置零
	
	int i = 0,j = 0,t,m,temp;
	scanf("%d",&temp);

	while( temp != -1)//输入整数序列，输入-1表示结束,整个循环结束后，i的值就是序列中的整数个数
	{  
		while(j <= i) 
		{    
			//从数组开头查询，是否有与temp相等的数字
			if(temp != num[j].di)
				j++;
			else
				break;
		}
		if(j > i)//没有与temp相等的数字，temp加入数组
		{   			
			num[j-1].di = temp;
			i++;
			j = 0;       //j指向数组开头，做下一次判断
			scanf("%d",&temp);        
		}
		else //有与temp相等的数字，j指向数组开头，做下一次判断
		{
			j = 0; 
			scanf("%d",&temp);
		}     
	}

	for(j = 1;j <= i;j++) //开始编号
	{            
		for(t = 0;t < i;t++)        //找到第一个没有编号的数，这个循环结束后，t指向序列中最前面的没有编号的数.
			if(num[t].k != 0)   //如果条件成立，说明此数已经编号，跳过！
			else
				break;
		for(m = 0;m < i;m++)  //在没有编号的数里面寻找最小的，让t指向它
		{
			if((num[m].di < num[t].di) &&num[m].k == 0)
				t = m;
			else 
				continue;
		}
		num[t].k = j;     //编号
	}

	for(j = 0;j < i;j++)   //输出序列
	printf("%d  ",num[j].di);
	printf("\n");

	for(j = 0;j < i;j++)   //输出对应的编号
	printf("%d  ",num[j].k);
	printf("\n");
}

/*五.设有两个有序链表，一为升序，一为降序。试编写程序，将这两个链表合并为一个序链表。*/
//假设升序的链表为链表1，降序的链表为链表2
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h> 
typedef struct list_node
{
	int data;
	struct list_node *next;
}list_node;

list_node *list1 = NULL; //链表1头结点
list_node *list2 = NULL; //链表2头结点

void list_print(const list_node *p)//打印该链表函数
{
	if(p == NULL)
		return;
	while(p != NULL)   
    {
		printf("%d ",p->data);
		p = p->next;
    }
	printf("\n");
}

void list_create(list_node* &head, int data[], int N)//创建链表
{
	if(data == NULL)
		return;
	int i;
	list_node *p;
	p = (list_node*)malloc(sizeof(list_node));
	p->data = data[0];
	p->next = NULL;
	head = p; 
	for(i = 1;i < N; i++) 
	{
		p->next = (list_node*)malloc(sizeof(list_node));
		p->next->data = data;
		p->next->next = NULL;
		p = p->next;
	}
}

void list_reverse(list_node* &head)  //使链表反序
{
	if(head == NULL) //如果head1为空，则返回
		return ;
	list_node *p,*q;
	q = head;
	p = head->next;

    while(p!=NULL)
    {
		head->next=p->next; //将头指针的next指向p的下一个节点
		p->next=q;          //将p的next值反指向它的前一个节点q
		q=p;                //q移向p的位置
		p=head->next;       //p移向它的下一个位置
    }
    head = q;
}

void list_destroy(list_node *head)  //销毁函数
{
	list_node *pmove = NULL,*pdel = NULL;
	pmove = head;

	while(pmove!=head)
    {
		pdel = pmove;
		free(pdel);  
		pmove = pmove->next;
    }
}

list_node* merge_two_list() //合并链表1和链表2
{
	list_reverse(list2);    //反转链表使之与链表1一样升序排列
	list_node *list_merged;  //和并后的链表
	list_node *p1,*p2,*p0;      
	list_merged = (list_node*)malloc(sizeof(list_node));
	list_merged->data = 0;
	list_merged->next = NULL;
	p0 = list_merged;
	p1 = list1;
	p2 = list2;
	while(p1 != NULL && p2 != NULL)
	{
		if(p1->data < p2->data)
		{
		   p0->next = (list_node*)malloc(sizeof(list_node));
		   p0->next->data = p1->data;
		   p0->next->next = NULL;
		   p0 = p0->next;
		   p1 = p1->next;
		}
		else
		{
		   p0->next = (list_node*)malloc(sizeof(list_node));
		   p0->next->data = p2->data;
		   p0->next->next = NULL;
		   p0 = p0->next;
		   p2 = p2->next;
		}
	}
	while(p1!=NULL)
	{
	    p0->next = (list_node*)malloc(sizeof(list_node));
	    p0->next->data = p1->data;
	    p0->next->next = NULL;
	    p0 = p0->next;
	    p1 = p1->next;
	}
	while(p2 != NULL)
	{
		p0->next = (list_node*)malloc(sizeof(list_node));
	    p0->next->data = p2->data;
	    p0->next->next = NULL;
	    p0 = p0->next;
	    p2 = p2->next;
	}
	return list_merged;
}

/*--------------------------------------------------------数据结构部分---------------------------------------------------------------*/
/*二.某商店有一皮手机，按价格从高价到底构成一个单链表，结点包括数量、价格、指针。现新到n台价格不同的手机，编写将新到手机插入到原链表中的算法。*/
//定义此单链表的结点结构：
typedef  struct  Lnode
{
    int  number;  //数量域
    int  value;   //价格域
    struct  Lnode *next;  //指针域
}Lnode,＊Linklist;
void  insert_link(Linklist &L, int n )
{
    //将新到n台价格不同的手机插到有序链表中
　　for(i = 1;i <= n; i++)
	{
        scanf(&price);     //读入每台手机价格
　　　　s = (Linklist)malloc( sifeof(Lnode) );
        s->value = price;
		s->number = 1;
		p = L->next;
		       
		if(p->value < s->value)//插入首部
		{ 
　　　　　　s->next = L->next; 
			L->next = s;
        }
        else
		{
            while(p->next && (p->next->value > s->value))
                p = p->next;
            if(!p->next) //插入表尾
			{
　　　　　　　　s->next = p->next;
				p->next = s;
            } 
            else if(p->next->value = s->value)
                p->next->number++;
			else
			{
				s->next = p->next;
				p->next = s;
			}
		}
	}//for
}

/*三.假设哈希函数为H(key),编写用链地址解决冲突的哈希表的插入和删除算法。*/
(1)//哈希表插入，用链地址解决冲突
void Insert_HS(HashTable &H,keytype key)
{
	i = H(key); //获得哈希地址
	if(H[i] == NULL)
	{
		s = (Linklist)malloc(sizeof(Lnode));
		s->data = key;
		s->next = H[i];
		H[i] = s;
	}//if
	else
	{
		//在链表中查找key
		p = H[i];
		while(p && p->data != key)
			p = p->next;
		if(p->data == key)
			exit(1);
		else
		{
			//插入表头
			s = (Linklist)malloc(sizeof(Lnode));
			s->next = H[i];
			H[i] = s;
		}//else
	}//else
}

(2)//哈希表删除，用链地址解决冲突
void Delete_HS(HashTable &H,keytype key)
{
	i = H(key); //获得哈希地址
	if(H[i] == NULL) 
		exit(1);
	p = H[i];
	q = p; //p为工作指针，q为p前趋
	while(p && p->data != key)
	{
		//查找
		q = p；
		p = p->next;
	}//while
	
	if(!p)  
		exit(1);
	if(q == H[i])
	{
		//key为第一结点
		H[i] = p->next;
		free(p);
	}//if
	else 
	{
		q->next = p->next;
		free(p);
	}//else
}

/*四.设用输入广义表表示的字符串来创建二叉链表结构的二叉树，具体规定如下：广义表的表名作为树的根结点，每个结点的左子树和右子树用逗号分割，
     若仅有右子树，则逗号不能省略，以特殊符号'$'表示广义表的结尾。
     (1)若输入的字符串为A(B(C),D(E(,F),G)),画出所表示的二叉树。
     (2)实现用上述方法创建二叉树的算法。*/
(1)//画图我就不画了，你自己画吧，不难
(2)//用栈来实现
void CreatTree(BiTree &T ,char *str)
{
	// 生成二叉树
	BiTree stack[maxsize],p;
	int k,j = 0,top = -1;//j为str指针，top为栈顶指针
	T = NULL; //初始化
	char ch = str[j];
	while(ch != '$')
	{
		switch(ch)
		{
		    case '(':
				top++;
				stack[top] = p;  //入栈
			    k = 1;  //k=1,为左孩子	
				break;
		    case ')':
				top--;
				break; //出栈	
			case ',':
				k = 2;
				break; //k=2,为右孩子
			default:
				p = (BiTree)malloc(sizeof(BTNode));
				p->data = ch;
				p->lchild = p->rchild = NULL;
				if(T == NULL)
					T = p;//创建根结点
				else 
				{
					switch(k) 
					{
					    case '1':
							stack[top]->lchild = p;
					        break;
					    case '2': 
							stack[top]->rchild = p;
					        break;

				    }
				}
		}//switch
		j++; 
		ch = str[j];
 	}//while
}

sure-fire
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
8
zj的专栏
09-25 1031
问题        1.设有两个有序单链表，一为升序，一为降序。试编写程序，将这两个链表合并成一个有序链表        2.设A为递增有序单链表（长度为n），B为递减有序的单链表（长度为m），编写程序，和用原表的存储空间，将A、B合并成一个递增有序单链表，要求时间复杂度为O（n+m） 分析          这两道题是一道题，将降序的单链表逆序成升序的单链表，然后思路和上一题思路一样。
东北大学计算机专业研究生入学考试2005年真题
sure-fire的专栏
01-16 1913
/*-------------------------------------------------------C语言部分------------------------------------------------------------------*/ /*1.将一个数的数码倒过来所得到的新数叫原数的反序数。如果一个数等于它的反序数，则称它为对称数。计算不超过1993的最大的二进制的对称数
东北大学历年数据结构考研真题.docx
01-25
word版，祝愿大家考研成功 2018年 1 2018年答案 4 2017年 6 2017年答案 10 2016年 20 2016 年答案 23 2015考纲 31 2015年 33 2015 年答案 36 2014年 43 2014 年答案 45 2013年 52 2013年答案 55 2011年 61 2011年答案 64 2010年 74 2010年答案 75 2009年 79 2009 年答案 80 2008年 87 2007年 91 2007 年答案 94 2006年 99 2006年答案 102 2005年 111 2005年答案 114 2004年 125 2004年答案 128 2003年 132 2003年答案 135 2002年 141 2002年答案 146 2001年 160 2001年答案 163 2000年 171 2000年答案 174 1999年 192 1999年答案 195 1998年 201 1998年答案 203 1997年 206 1997 年答案 210 1996年 217 1996年答案 220
东北大学计算机考研842历年考试真题
06-11
东北大学计算机考研的十年真题，本人自用的。好好研究真题，考试没问题 的。
两个链表一升一降，合并为一个升序链表。
fanwu72的专栏
03-30 1507
#include using namespace std; class List { public: List(int num) { this->num = num; next = NULL; } int num; List* next; }; //创建链表 void createList(List* &list) { List* cur;
链表合并：一个升序，一个降序，将两个链表合并成一个升序链表
小马快跑的博客
04-14 2587
题目：两个有序链表，一个升序，一个降序，如何将两个链表合并成一个升序链表。如: 升序链表一：1->2->3->4 降序链表二：6->5->4->3 合并后结果：1->2->3->3->4->4->5->6 思考：分成两步来实现，首先将降序链表二进行反转变成升序链表，然后就可以直接对两个升序链表进行操作了。 实现： public static void main(String[] args) { System.out.p
东北大学计算机专业研究生入学考试2001年真题
sure-fire的专栏
01-16 2805
/*---------------------------------数据结构部分---------------------------------*/ /*二.设有一个正整数序列组成的有序单链表（按递增次序有序，且允许有相等的整数存在），试编写能实现下列功能的算法:(要求用最少的时间和最小的空间) (1)确定在序列中比正整数x大的数有几个(相同的数只计算一次，如序列(20，20，17，16，15
东北大学计算机研究生入学考试试卷1996-2016
04-22
《东北大学计算机研究生入学考试试卷1996-2016》集合了东北大学过去二十一年间的研究生入学考试试题，这些试题涵盖了计算机科学与技术领域的广泛知识点，旨在全面评估考生的专业理论基础、编程能力以及解决实际问题...
东北大学计算机考研真题.zip
06-29
【东北大学计算机考研真题.zip】是一个包含历年东北大学计算机科学与技术专业研究生入学考试试题的压缩包。这个资源对于正在准备东北大学计算机考研的学生来说是极其宝贵的，因为它提供了从2009年至2018年间的多套...
将两个升序链表A、B合并到C，并使C成为降序
09-30
用两种方法完成升序链表A、B的合并，并使C成为降序。 方法一：依次比较A、B的各结点，将较小的赋给C，A、B结点都赋给C后，再将C表逆序，得到降序表； 方法二：依次比较链表A、B，然后将结点赋给C表，在C中表从头结点前面进行插入操作，最后直接得到降序的C表。
东北大学842考研真题（1996-2020年）.zip
05-26
考研，全称“全国硕士研究生统一入学考试”，是中国大陆教育系统中的一项重要考试，旨在选拔优秀学生进入硕士研究生阶段学习。东北大学是中国知名的双一流高校，其842科目的具体考试内容可能因年份不同而有所变化，...
两个链表一个升序一个降序，合并为升序链表
xiangxianghehe的博客
03-29 5247
**题目解析：**其实可以把题目拆解为：翻转链表+两个有序链表的合并。 代码： struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } void print() { printf("%d -> ",this->val); i...
数据结构 - 有两个链表，第一个升序，第二个降序，合并为一个升序链表（C++）
热门推荐
了解➔熟悉➔掌握➔精通
02-25 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net /* * Created by Chimomo */ #include &lt;iostream&gt; #define NULL 0 using namespace std; struct Node { char data;...
编程实现合并两个有序单链表
tianmo2010的专栏
02-29 4118
编程实现合并两个有序(假定为降序)单链表的函数，输入为两个有序链表的头结点，函数返回合并后新的链表的头节点， 要求：不能另外开辟新的内存存放合并的链表。 合并函数声明如下：node *merge_sorted_list( node * head1, node *head2); //重要方法： node merge_sorted_list(const node head1,const n
数据结构与算法（二）合并两个有序链表
帝都码农
09-23 1万+
本系列的第一节概括性地简单介绍了一下数据结构和算法的概念，说实话有点虚，因为谁都知道链表和数组是什么，也都能说出散列和二叉树，但真正有难度的是，在实际开发中如何去用这些数据结构，根据不同的开发需求选择不同的数据结构和算法，才是真正需要并且很难掌握的。以后的章节中，我都会通过一道实际编程题目或者一个场景，针对一种数据结构或者算法来解决问题，只有将数据结构和算法用来解决实际问题，才有意义，这一节我们要解
图---生成树与最小生成树
sure-fire的专栏
11-12 1万+
今天在做题的时候遇到一个问题，如何根据图的邻接表来画出DFS生成树和BFS生成树，有两年的真题中涉及到这个问题，在以前的学习中没注意过此问题，由于严奶奶的书上也只是一带而过，所以对它的理解也不深刻，作为基础的知识应该掌握，因此从网上查阅了一些资料，针对这个问题做如下总结，由于提到生成树自然会想到还有一种最小生成树，顺便把生成最小生成树的方法也总结一下，做出更好的区分，给需要的同学提供一个方便：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值