山东师范大学硕士研究生入学考试试题汇总
作者：互联网
山东师范大学2018年硕士研究生入学考试试题
1、设计一个算法，删除单链表L（有头结点）中的一个最小值结点。P48
LinkList Delete_Min(LinkList &L){
//L带头结点的单链表，本算法删除其最小值结点
LNode *pre=L,*p=pre->next; //p为工作指针，pre指向其前驱
LNode *minpre=pre,*minp=p; //保存最小值结点及其前驱
while(p!=NULL){
if(p->data<minp->data){
minp=p; //找到比之前找到的最小值结点更小的结点
minpre=pre;
}
pre=p;
p=p->next; //继续扫描下一个结点
}
minpre->next=minp->next; //删除最小值结点
free(minp);
return L;
}
2、如果在循环队列的两端都可以进行插入和删除操作，写出从队尾出队元素的算法。
Status DeQueue(SqQueue &Q){
//若队列不空，则删除Q的队尾元素，并返回ok
//否则返回ERROR
if(Q.front == Q.rear)
return ERROR;
Q.rear = (Q.rear - 1 + MAXQSIZE) % MAXQSIZE;
return OK;
}
3、假设二叉树采用二叉链表存储结构，设计一个算法，计算一棵给定二叉树的所有叶子结点数。
Status POLeafNodeNum(int &i,BiTree &T){
if(T){
if(!T->lchild && !T->rchild)
i++;
POLeafNodeNum(i,T->lchild);
POLeafNodeNum(i,T->rchild);
}
return OK;
}
4、奇偶交换排序是一种交换排序。它的第一趟对序列中的所有奇数项i扫描，第二趟对序列中的所有偶数项i扫描，若A[i]>A[i+1]，则交换它们。第三趟对序列中的所有奇数项扫描，第四题对序列中的所有偶数项i扫描，…，如此反复，直至整个序列全部排好序为止。写出奇偶交换排序的算法。
此算法是用Java所写，尚未找到C语言版的
private void core(int[] array) {
int arrayLength = array.length;
boolean oddSorted = false;
boolean evenSorted = false;
while(!oddSorted || !evenSorted) {
int base = 0;
oddSorted = true;
evenSorted = true;
for (int i = base; i < arrayLength - 1; i += 2) {
if (array[i] > array[i + 1]) {
ArrayUtils.swap(array, i, i + 1);
oddSorted = false;
}
}
base = 1;
for (int i = base; i < arrayLength - 1; i += 2) {
if (array[i] > array[i + 1]) {
ArrayUtils.swap(array, i, i + 1);
evenSorted = false;
}
}
}
}
#include<iostream>
using namespace std;
int n,flag=0;
int A[100]={0};
int shulu(){
cin>>n;
cout<<"n的值是"<<n<<end1;
for(int i=1;i<=n;i++){
cout<<"第"<<i<<end1;
cin>>A[i];
}
return 0;
}
int paixu()[
flag=0;
for(int i=1;i+1<=n;i+=2){
if(A[i]>A[i+1]){
int p;
p=A[i];
A[i]=A[i+1];
A[i+1]=p;
flag=1;
}
else
continue;
}
for(i=2;i+1<=n;i+=2){
if(A[i]>a[i+1]){
int p;
p=A[i];
A[i]=A[i+1];
A[i+1]=p;
flag=1;
}
else
continue;
}
return 0;
}
int main(){
shulu();
flag=1;
cout<<"开始排序"<<end1;
while(flag!=0){
paixu();
}
cout<<end1;
for(int i=1;i<=n;i++)
cout<<A[i]<<" ";
return 0;
}
山东师范大学2017年硕士研究生入学考试试题
1、有一个递增非空链表，设计一个算法删除值域重复的结点。例如，{1，1，2，3，3，3，4，4，7，7，7，9，9}。
void Del_Same(LinkList &L){
//L是递增有序的单链表，本算法删除表中数值相同的元素
LNode *p=L->nest,*q;
if(p==NULL)
return;
while(p->next!=NULL){
q=p->next; //q指向*p的后继结点
if(p->data==q->data){ //找到重复值的结点
p->next=q->next; //释放*q结点
free(q); //释放相同元素值的结点
}
else
p=p->next;
}
}
2、写一个函数，逆序打印单链表中的数据，假设指针L指向单链表的开始结点（用递归算法）。
void reprintList(LNode *L){
if(L!=NULL){
reprintList(L->next); //递归逆序打印开始结点之后的结点数据
print("%d\t",L->data); //打印结点数据
}
}
3、在二叉树中查找值为x的结点。假设值为x的结点不多于一个，打印出值为x的结点所在的层次。
算法思路 ：结点查找–>>遍历二叉树；要判断当前所在层次，利用函数参数和返回值传递信息的作用实现。
int h=0;
int find_node_level(BTNode *bt, ElemType x,int h){
if(bt == NULL)
return 0;
else if(bt->data == x)
return h;
else{
int l = find_node_level(bt->lchild, x, h+1);
if(l != 0)
return l;
else
return find_node_level(bt->rchild, x, h+1);
}
}
4、写出直接插入排序的算法。
不带“哨兵”， 此方法优于带“哨兵”
void InsertSort(ElemType A[],int n){
int i,j,temp;
for(i=1;i<n;i++) //将各元素插入已排好序的的序列中
if(A[i]<A[i-1]){ //若A[i]关键字小于前驱
temp=A[i]; //用temp暂存A[i]
for(j=i-1;j>=0 && A[j]>temp;--j) //检查所有前面已排好序的元素
A[j+1]=A[j]; //所有大于temp的元素都向后挪位
A[j+1]=temp; //复制到插入位置
}
}
带“哨兵”
void InsertSort(ElemType A[],int n){
int i,j;
for(i=2;i<=n;i++) //依次将A[2]~A[n]插入到前面已排好序序列
if(A[i]<A[i-1]){ //若A[i]关键码小于其前驱，将A[i]插入有序表
A[0]=A[i]; //复制为哨兵，A[0]不存放元素
for(j=i-1;A[0]<A[j];--j) //从后往前查找待插入位置
A[j+1]=A[j]; //向后挪位
A[j+1]=A[0]; //复制到插入位置
}
}
山东师范大学2016年硕士研究生入学考试试题
1、设计一个算法，从一给定的顺序表L中删除下标i到j（i<=j，包括i,j）之间的所有元素，假定i,j都是合法的。
使用单链表存储顺序表L中的所有值，要删除i到j之间的所有元素，因为下标i到j是连续的，故可以将第i个结点的下一个指针next指向下标为j+1的结点。
bool Del_List(SqList &l,ElemType i,ElemType j){
//删除顺序表L中下标在i到j之间（要去i<=j）的所有元素
int m,k=0;
if(i>j || L.length==0)
return false; //顺序表为空或当下标i>j时，返回
for(m=i; m<=j; m++)
k++;
L.data[i]=L.data[j+1]; //当前元素移动到下标为i的结点位置
L.length-=k; //长度减小
return true;
}
2、设有一元素为整数的线性表L，存放在一维数组A[0…n-1]中，设计一个算法，以A[n-1]为参考值，将该数组分为左右两部分，其中左半部分的元素均小于等于A[n-1]，右半部分的元素均大于等于A[n-1]，A[n-1]位于这两部分之间，要求结果扔存放在A数组中。
算法思路：类似于“快速排序”的一趟排序，经过一趟排序后A[n-1]确定了其最终位置。
void Partition(ElemType A[]. int low, int high){
ElemType pivot = A[high]; //将当前表中的第n个（即下标为n-1）的元素设为枢轴，对表进行划分
while(low<high){ //循环跳出的条件
while(low<high && A[low]<=pivot)
++low;
A[high] = A[low]; //将比枢轴大的元素移动到右端
while(low<high && A[high]>=pivot)
--high;
A[low] = A[high]; //将比枢轴小的元素移动到左端
}
A[high] = pivot; //枢轴元素（即下标为n-1的元素）存放的最终位置
}
3、设计一个算法，对给定的一个整型m*n矩阵A，统计这个矩阵中具有下列特征的元素个数并输出它们的坐标及数值：它们既是所有行中的最小值，又是所在列中的最小值。
算法思路：只需要找出某行中的最小值，然后再判断其是否为该列的最小值即可。
void Find_Min(int A[][MAXSIZE], int m, int n){
int rowMin;
int count = 0; //计数器，记录符合条件的元素数目
for(int i=0; i<m; i++){ //遍历行
rowMin = A[i][0]; //将每行的第一个元素赋予为其所在行的最小值
int x = i, y = 0; //记录行最小值的行下标和列下标
for(int j=0; j<n; j++){ //遍历列
if(A[i][j] < rowMin){
rowMin = A[i][j];
x = i;
y = j;
}
}
int temp = rowMin;
for(int q=0; q<m; q++){
if(A[q][y] < rowMin)
rowMin = A[q][y];
}
if(temp == rowMin){
count++;
printf("%d,[%d][%d]\n",temp,x,y);
}
printf("既是所在行又是所在列最小值的元素的个数为：%d\n",count);
}
4、设一棵二叉树以二叉链表为存储结构，结点结构为lchild|data|rchild。设计一个算法，求在前根序列中处于第k个位置的结点。
设置一个全局变量i记录已访问过的结点的序号，其初值是根结点在先序序列中的序号，即1。
int i=1;
ElemType PreNode(BiTree b, int k){
if(b==NULL)
return '#'; //空结点，返回特殊字符
if(i==k)
return b->data; //相等，则当前结点即为第k个结点
i++; //下一个结点
ch = PreNode(b->lchild, k); //左子数中递归寻找
if(ch!=‘#’)
return ch; //在左子树中，则返回该值
ch = PreNode(b->rchild, k);
return ch; //在右子树中递归寻找
}
山东师范大学2015年硕士研究生入学考试试题
1、设计一个算法，将一个头结点为A的单链表（其数据域为整数）分解为两个单链表A和B，使得A链表只含有原来链表中的data域为奇数的结点，而B链表只含有原来data域为偶数的结点，且保持原来相对顺序。
算法思路：根据结点的数据域奇偶性来判断插入哪个链表中，使用尾插法来保持顺序不变。
LinkList DisCreat_l(LinkList &A){
B=(LinkList)malloc(sizeof(LNode)); //创建B表表头
B->next=NULL; //B表初始化
LNode *ra=A, *rb=B; //ra和rb将分别指向将创建的A表和B表的尾结点
p=A->next;
while(p!=NULL){
if(p->data%2==0){
rb->next=p; //在B的表尾插入新结点
rb=p; //rb指向新的尾结点
}
else{
ra->next=p;
ra=p; //在A表尾插入新结点
}
p=p->next; //将p恢复为指向新的待处理结点
}
ra->next=NULL;
rb->next=NULL;
return A;
return B;
}
2、设有浮点型数组A[0···n]，设计求数组A中最大值的递归算法。
int i=0, j=n;
float FindMax(flaot A[], int i, int j){
float max;
if(i==j)
return A[i];
else{
max=FloatMax(A, i+1, j);
if(A[i]>max)
return A[i];
else
return max;
}
}
3、在二叉树中查找值为x的结点。假设值为x的结点不多于一个，打印出值为x的结点的所有祖先。
算法思路：采用非递归后序遍历，最后访问根结点，访问到值为x的结点时，栈中所有元素均为该结点的祖先，依次出栈打印即可。 王道书P163
typedef struct{
BiTree t;
int tag;
}stack; //tag=0表示左子女被访问，tag=1表示右子女被访问
void Search(BiTree bt,ElemType x){
//在二叉树bt中，查找值为x的结点，并打印其左右祖先
stack s[];
top=0;
while(bt!=NULL||top>0){
while(bt!=NULL&&bt->data!=x){
s[++top].t=bt;
s[top].tag=0;
bt=bt->lchild; //沿左分支向下
}
if(bt->data==x){
printt("所查结点的所有祖先结点的值为:\n");
for(i=1;i<=top;i++)
printf("%d",s[i].t->data);
exit(1);
}
while(top!=0 && s[top].tag==1)
top--; //退栈(空遍历)
if(top!=0){
s[top].tag=1;
bt=s[top].t->rchild; //沿右分支向下遍历
}
}
}
4、设有一组初始记录关键字序列（K1，K2，…，Kn），要求设计一个算法能够在O(n)的时间复杂度内将线性表划分成两部分，其中左半部分的每个关键字均小于Ki，右半部分的关键字均大于等于Ki。
void QuickPass(int K[], int s, int t){
int i=s;j=t,x=K[s];
while(i<j){
while(i<j && K[i]>x){
j=j-1;
if(i<j){
K[i]=K[j];
i=i+1;
}
}
while(i<j && K[i]<x){
i=i+1;
if(i<j){
K[j]=K[i];
j=j-1;
}
}
}
K[i]=x;
}
山东师范大学2011年硕士研究生入学考试试题
1、设计在单链表中删除值相同的多余结点的算法。
void DeleteSame(LinkList *L){
LNode *p,*q,*s;
p=(*L)->next;
for(p;p!=NULL;p=p->next){
s=p; //s指向要删除结点的前驱
for(q=p->next;q!=NULL;){
if(q->data==p->data){
s->next=q->next;
free(q);
q=s->next;
}
else{
s=q;
q=q->next;
}
}
}
}
2、设计一个求结点x在二叉树中的双亲结点算法。
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode *BiTree;
BiTNode *parent(BiTree T,ElemType x){
BiTNode *ans;
if(T==NULL)
return NULL;
if(T->lchild==NULL&&T->rchild==NULL)
return NULL;
else{
if(T->lchid->data==x||T->rchild->data==x)
return T;
else{
ans=parent(T->lchid,x);
if(ans)
return ans;
ans=parent(T->rchild,x);
if(ans)
return ans;
return NULL;
}
}
}
3、写一个算法利用折半查找方法在一个有序表中插入元素x，且保持表的有序性。
void InsertSort(int num[],int n,int x){
int mid;
int low=0,high=n-1;
int flag=0; //标记是否发生插入
int pos;
while(low<=high&&flag==0){
mid=(low+high)/2;
if(num[mid]==x)
flag=1; //若关键字等于x，则将flag置为1
else if(num[mid]>x)
high=mid-1;
else
low=mid+1;
}
if(flag==1)
pos=mid;
else
pos=low; //若x最大，且不在原有序表中，则low指向最后一个元素下标的下一个位置
for(int i=n-1;i>pos;i--)
num[i+1]=num[i];
num[pos]=x;
}
4、写出冒泡排序算法。
void swap(int &a,int &b){
int temp=a;
a=b;
b=temp;
}
void BubbleSort(ElemType A[],int n){
for(i=0;i<n-1;i++){
bool flag=false;
for(int j=n-1;j>i;j--)
if(A[j-1]>A[j]){
swap(A[j-1],A[j]);
flag=true;
}
if(flag==false)
return;
}
}
标签：结点,return,试题,int,山东师范大学,next,算法,入学考试,NULL 来源： https://blog.csdn.net/weixin_47574063/article/details/109956164