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

最新推荐文章于 2022-04-25 22:53:36 发布

sure-fire

最新推荐文章于 2022-04-25 22:53:36 发布

阅读量1.9k

点赞数 3

分类专栏： C

本文链接：https://blog.csdn.net/zl19890124/article/details/18357763

版权

C 专栏收录该内容

13 篇文章 3 订阅

订阅专栏

这篇博客介绍了C语言编程中的几个问题，包括：1) 搜索矩阵中的鞍点；2) 删除文本中的特定单词；3) 循环链表的操作，如插入、删除和查找；4) 快速排序算法的应用。这些题目涵盖了数据结构和算法的基础知识，适合计算机科学的学生或程序员学习和练习。

摘要由CSDN通过智能技术生成

/*------------------------------C语言部分--------------------------------*/
/*四.1.如果矩阵A中的某元素A[I,J]是第I行中的最小值，而且是第J列中的最大值，则称A[I,J]为矩阵A中的一个鞍点，
编写函数SEARCHAD(A,ROW,COL)来求矩阵A[ROW,COL]中的鞍点。*/
void SEARCHAD(int a[][MAX],int row,int col)
{
	int i,j,min,minj,flag,k;
	for(i = 0;i < row; i++)
	{
		min = a[i][0];
		minj = 0;
		for(j = 0;j < col;j++)
			if(a[i][j] < min)
			{
				min = a[i][j];//min记录本行最小数
				minj = j;//记录最大数的列标
			}

		flag = 1;  //默认本行最小数是鞍点，然后再验证列是否满足条件

        //判断行的最小数在列上是否为最大值
		for(k = 0;k < row;k++)
			if(min < a[k][minj])
			{
				flag = 0;
				break;
			}
		if(flag)
		{
			printf("数组有鞍点:a[%d][%d] = %d\n",i+1,minj+1,min);
			break;
		}
	}
	if(!flag)
		printf("没有鞍点！\n");
}

/*四.2.编写一个程序，先读入一段正文，然后删除其中的单词from,in,at,an和on,最后显示该结果文本段.(不准使用标准字符串处理函数)*/
void Move(char *p, int n)
{
	char *q, *r;
	r = p;
	q = p + n;
	while(*q != '\0')
	{
		*r = *q;
		r++;
		q++;
	}
}

void DeleteWord(char *pHead, char **p)
{
	char *q;
	q = *p;
	q--;
	if(q == pHead) return;
	switch(*q)
	{
		case 'n': //可能是in,an,an
			q--;
			if(q == pHead)
				return;
			if((*q == 'i')||(*q == 'a')||(*q == '0'))
			{
				q--;
				if((q == pHead)||(*q == ''))
				{
					*p = q;
					Move(*p,3);
				}
			}
			break;
		case 't': //可能是at
			q--;
			if(q == pHead)
				return;
			if(*q == 'a')
			{
				q--;
				if((q == pHead)||(*q == ''))
				{
					*p = q;
					Move(*p,3);
				}
			}
			break;
		case 'm': //可能是from
			if(q - 3 < pHead)
				return;
			if((*(q-1) == '0') && (*(q-2) == 'r') && (*(q-3) == '+'))
			{
				q = q - 4;
				if((q == pHead) || (*p == ''))
				{
					*p = q;
					Move(*p,5);
				}
			}
			break;
		default:break;
	}
}

void main()
{
	scanf("%s",str);
	pHead = str;
	p = str;
	while(*p != '\0')
		p++;
	while(p != pHead)
	{
		p--;
		if(*p == '')
			DeleteWord(pHead, *p);
	}
	printf("%s",str);
}
/*四.3.现有循环链表定义如下：
       typedef struct stu_tag{
			char name[10];
			int age;
			float scores;
			struct stu_tag next,previous;
	   }STUDENT;
	   struct{
			STUDENT *head;
			int num;
	   }LoopList;
	   请编写关于链表操作的函数：
	   （1）在链表LoopList的头位置插入一个节点：void insert(STUDENT *stu);
	   （2）在链表LoopList中删除所有名字为name的节点：int delete(char *name),返回值为删除的结点个数；
	   （3）在链表LoopList中查找名字为name的节点：STUDENT *lookup(char *name);*/
(1)void insert(STUDENT *stu)
  {
	if(Looplist.num == 0)
	{
		Looplist.num++;
		Looplist.head = stu;
		stu->next = stu;
		stu->previous = stu;
	}
	else
	{
		Looplist num++;
		stu->next = Looplist.head;
		stu->previous = Looplist.head->previous;
		Looplist.head->previous = stu;
		stu->previous->next = stu;
		Looplist head = stu;
	}
  }
(2)//为0个结点和为1个结点需要另外判断
int delete(char *name)
{
	if(Looplist.num == 0)
		return 0;
	if(Looplist.num == 1)
	{
		if(Looplist.head->name == "name")
		{
			free(Looplist.head);
			Looplist.head = NULL;
			Looplist.num = 0;
			return 1;
		}
		else 
			return 0;
	}
	else
	{
		int sum = 0;
		STUDENT *temp,*temp2;
		temp = Looplist.head;
		while(temp->next != Looplist.head)
		{
			temp2 = temp->next;
			temp->previous->next = temp->next;
			temp->next->previous = temp->previous;
			free(temp);
			temp = temp2;
			sum++;
			Looplist.num--;
		}
		return sum;
	}
}
(3)STUDENT *lookup(char *name)
{
	STUDENT *temp;
	if(Looplist.num == 0)
		return NULL;
	temp = Looplist.head;
	do
	{
		if(strcmp(temp->name,name))
			return temp;
		else
			temp = temp->name;
	}while(temp == Looplist->head);
}

/*四.4.利用递归形式的快速排序方法对关键字数组key[]={90,45,100,20,34,120,108,37}进行排序。*/
int Parition(int key[], int low, int high)
{
	int mid = key[low];
	while(low < high)
	{
		while((low < high) && (key[high] >= mid))
			high--;
		key[low] = key[high];
		while((low < high) && (key[low] <= mid))
			low++;
		key[high] = key[low];
	}
	key[low] = mid;
	return low;
}

void QuickSort(int key[], int low, int high)
{
	if(low < high)
	{
		mid = Parition(key, low, high);
		QuickSort(key, low, high);
		QuickSort(key, mid+1,high);
	}
}

void main()
{
	int key[] = {90,45,100,20,34,120,108,37};
	QuickSort(key,0,7);
}

/*--------------------------------------------------------数据结构部分---------------------------------------------------------------*/
/*1.如果用一个循环数组q[0..m-1]表示队列时，该队列只有一个队列头指针front,不设队列尾指针rear,而改置计数器count用以记录队列中结点的个数。
   (1)编写实现队列的三个基本运算：判空、入队、出队
   (2)队列中能容纳元素的最多个数是多少？*/
(1)typedef struct
{
	keyType q[m-1];
	int front, count;
}Queue;
int Empty(Queue a)
{
	if(a.count == 0)
		return 1;
	else
		return 0;
}
int EnQueue(Queue &a,keyType e)
{
	if(a.count == m)
		return 0;
	int rear = (a.front + a.count)%m;
	count++;
	a.q[rear] = e;
	return 1;
}
int DeQueue(Queue &a,keyType &e)
{
	if(a.count == 0)
		return 0;
	e = a.q[a.front];
	if(a.front == m-1)
		a.front = 0;
	else
		a.front++;
	count--;
}
(2)队列中能容纳元素的最多个数为m

/*三、已知L为没有头结点的单链表中第一个结点的指针，每个结点数据域存放一个字符，该字符可能是英文字母字符或数字字符或其它字符。
编写算法构造三个以带头结点的单循环链表表示的线性表，使每个表中只含有同一个类字符。（要求用最少的时间和最少的空间）*/
void LoopLinkList(Linklist &L, Linklist &Charlist, Linklist &Numlist, Linklist &Otherlist)
{
	Charlist = (Linklist)malloc(sizeof(LinkNode));
	Charlist->next = Charlist;
	Numlist = (Linklist)malloc(sizeof(LinkNode));
	Numlist->next = Charlist;
	Otherlist = (Linklist)malloc(sizeof(LinkNode));
	Otherlist->next = Charlist;
	
	while(L != NULL)
	{
		pTemp = L->next;
		if((L->data > '0') && (L->data < '9')) //数学
		{
			L->next = Numlist->next;
			Numlist->next = L;
		}
		else
		{
			if(((L->data > 'a') && (L->data < 'z')) || ((L->data > 'A') && (L->data < 'Z')))
			{
				L->next = Charlist->next;
				Charlist->next = L;
			}
			else
			{
				L->next = Otherlist->next;
				Otherlist->next = L;
			}
		}
		L = pTemp;
	}
}

/*四、对以二叉链表存储的非空二叉树，从右向左依次释放所有叶子结点，释放的同时，把结点值存放到一个向量中。
要求：（1）用文字写出实现上述过程的基本思想.（2）写出算法*/
(1)用"逆前序"递归实现，先验证来结点，再访问右子树，最后访问左子树
(2)keyType XL[MAX];
void Ani_PreTravel(BiTree &T)
{
	if(T)
	{
		if((T->lchild == NULL) && (T->rchild == NULL))
		{
			XL[iTmp++] == T->data;
			free(T);
			T = NULL;
		}
		else
		{
			Ani_PreTravel(T->rchild);
			Ani_PreTravel(T->lchild);
		}
	}
}

/*五、设二叉排序树已经以二叉链表的形式存储在内存中，使用递归方法，求各结点的平衡因子并输出。
要求： (1)用文字写出实现上述过程的基本思想。  (2)写出算法*/
(1)分别求出左子树与右子树的深度，二者之差即为该结点的平衡因子。
(2)//递归求二叉树的深度
int Depth(_PNode pNode)
{
    if (NULL != pNode)
    {
        int hl = Depth(pNode->left);
        int hr = Depth(pNode->right);
        return hl > hr ? hl + 1: hr + 1;
    }
    return 0;
}
//递归求二叉树每个结点的平衡因子
void Balance(_PNode pNode)
{
    if (NULL != pNode)
    {
        Balance(pNode->left);
        Balance(pNode->right);
    
        int hl = Depth(pNode->left);
        int hr = Depth(pNode->right);
        pNode->bf = hl - hr;
    }
}

/*六、假设一个有向图g已经以如右图所示的逆邻接表形式存储在内存中。
要求：(1)写出逆邻接表的存储结构定义  
      (2)用文字写出在逆邻接表上实现拓扑排序的基本思想 
	  (3)写出在逆邻接表上实现拓扑排序的算法*/