2023年中国海洋大学计算机及电子信息考研分析

Posted 2023-04-08 中国海洋大学海之子考研

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了2023年中国海洋大学计算机及电子信息考研分析相关的知识，希望对你有一定的参考价值。

考研时间跨度：

初试时间：
2022年8月23 海大推免及创新人才计划接收通知。
2022年9月13 海大专业目录及人数，包含推免。
2022年10月18 2022年硕士研究生计划，不含推免。
海大2022年硕士研究生计划
网上第一次时间为2022年9月24日至27日，每天9∶00-22∶00。
网上第二次时间为 2022年10月5日至25日，每天9∶00-22∶00。
初试时间：2023年全国硕士研究生初试时间为2022年12月24日至25日（每天上午8:30—11:30，下午14:00—17:00）
考研初试各科目时间安排：
12月24日上午思想政治理论、管理类联考综合能力
12月24日下午外国语
12月25日上午业务课一（数学一、二、三等）
12月25日下午业务课二（专业课）
复试时间：

初试成绩查询：2023年2月21日14：00。
初试成绩排名查询时间：2022-2-27（根据统考人数专硕乘1.3，学硕乘1.2可算出是否进复试）
国家线公布时间：2022-03-14
研招网国家线

进入中国海洋大学复试资格线：2022-03-17
中国海洋大学研招网

2022届考研国家调剂系统开放时间：2022年4月6日
海大接受调剂专业名单：链接

中国海洋大学2022年硕士研究生复试工作方案：2022-03-17
各单位2022年硕士复试实施细则及复试安排：2022-03-18

信息科学与工程学院计算机系复试时间：2022-3-25至3-26。3.24-测试设备及思想政治考核
信息学部硕士研究生复试工作安排
 信息学部硕士研究生复试工作实施细则
信息学部各专业初试计划：（各专业适度扩招名额）

复试比例严格按照上述计划专硕×1.3，学硕×1.2进入复试。如408计算机科学与与技术：23×1.2=28人

3.29上午9:00结果发布：

拟正式人数及名单公布时间：待更新

中国**大学考研专业课

中国**大学硕士研究生招生考试初试科目《数据结构》考试大纲

一、考试目的及要求本科目主要考查：

1.掌握数据结构的基本概念、基本原理和基本方法。 
2.掌握数据的逻辑结构、存储结构及基本操作的实现，能够对算法进行基本的时间复杂度与空间复杂度的分析。 
3.能够运用数据结构基本原理和方法进行问题的分析与求解，具备采用C或C++语言设计与实现算法的能力。

二、考试内容第一部分线性表

1.线性表的定义和基本操作
2.线性表的实现
（1）顺序存储
（2）链式存储
(3）线性表的应用
第二部分栈、队列和数组
1.栈和队列的基本概念
2.栈和队列的顺序存储结构
3.栈和队列的链式存储结构
4.栈和队列的应用
5.特殊矩阵的压缩存储
第三部分树与二叉树
1.树的概念
2.二叉树（1）二叉树的定义及其主要特征（2）二叉树的顺序存储结构和链式存储结构（3）二叉树的遍历（4）线索二叉树的基本概念和构造
3.树、森林（1）树的存储结构（2）森林与二叉树的转换（3）树和森林的遍历
4.树与二叉树的应用（1）二叉排序树（2）平衡二叉树（3）哈夫曼（Huffman）树和哈夫曼编码
第四部分图
1.图的基本概念
2.图的存储及基本操作（1）邻接矩阵法（2）邻接表法（3）邻接多重表、十字链表
3.图的遍历（1）深度优先搜索（2）广度优先搜索
4.图的基本应用（1）最小（代价）生成树（2）最短路径（3）拓扑排序（4）关键路径
第五部分查找
1.查找的基本概念
2.顺序查找法
3.分块查找法
4.折半查找法
5.B树及其基本操作、B+树的基本概念
6.散列（Hash）表
7.字符串模式匹配
8.查找算法的分析及应用
第六部分排序
1.排序的基本概念
2.插入排序（1）直接插入排序（2）折半插入排序
3.起泡排序（bubble sort）
4.简单选择排序
5.希尔排序（shell sort）
6.快速排序
7.堆排序
8.二路归并排序（merge sort）
9.基数排序
10.外部排序
11.各种内部排序算法的比较
12.排序算法的应用

三、试题类型

选择题、应用题、算法设计题等。

四、考试形式及时长

1.闭卷，笔试。 
2.满分为150分，考试时长为三个小时。

五、参考书目

《数据结构》（C语言版） 严蔚敏、吴伟民著，清华大学出版社。

第一部分线性表

线性表定义

线性表：线性表是零个或者多个数据元素的有限序列，是最常用且最简单的一种数据结构。特点： (1)存在惟一的一个被称做“第一个”的数据元素。
(2)存在惟一的一个被称做“最后一个”的数据元素。 (3)除第一之外，集合中每个元素均只有一个前驱。
(4)除最后一个之外，集合中每个数据元素均只有一个后继。


/*
ElemType ：线性表数据元素数据类型
LIST_INIT_SIZE : 线性表初始数据元素容量
Status ：函数返回值（一般替换int型）
error ：1
INFEASIBLE ：1
OK ：0
*/  

//顺序存储
#define LIST_MAX_LENGTH  XXX         //线性表中可以存储的最大元素个数
 
typedef int ElemType;                //元素类型
 
typedef struct {
    ElemType data[LIST_MAX_LENGTH];  //定义一个固定长度的数据
    int length;                      //记录当前线性表中元素个数
}sqList;

/*  线性表之链式存储*/
 
typedef struct 
{
   ElemType *elem;      //存储空间基址
   int      length;     //当前数据元素个数
   int      listsize;   //当前分配的最大数据元素容量
}SqList;

基本操作：

//建立线性表
Status InitList(SqList &L)
{
    L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    //申请存储空间
    if(!L.elem)
    exit(0);
    L.length=0;//空表的长度为0
    L.list=LIST_INT_SIZE;//初始数据元素存储容量
    return OK;
 }
//清空线性表
Status ClearList(SqList &L)
{
    L.length=0;
    return Ok;
}
//销毁线性表
Status Destroy(SqList &L)
{
    free(L.elem);
    L.elem=NULL;
    L.length=0;
    L.listsize=0;
    return OK;
}
//判空线性表
bool ListEmpty(SqList L)//不需要对线性表的成员变量进行改变，所以不使用引用
{
    return (L.length==0)?true:false;
}
//判满线性表
bool ListFull(SqList L)
{
    return (L.length==L.listsize)?true:false;
}
//获取线性表中个数
int ListLength(SqList L)
{
    return L.length;
 }
//获取指定位置数据
Status GetElem(SqList L,int i, ElemType &e)
{
    if(i<1||i>L.length)
    exit(error);
    e=*(L.elem+i-1);//（基址+i-1）即为第i个元素的地址
    return OK;
}
//定位元素
int LocateElem(SqList L,ElemType e,status(*compare)(ElemType,ElemType))
{
    Elem *p=L.elem; //P的初值为第一个元素的存储位置
    int i=1;//i的初值为第一个元素的位序
    while(i<=L.length&&!compare(*p++,e))//越界或已找到满足条件的元素
    //i的最大可能值为L.length+1
    {
        if(i<=L.length)
        return i;
        else
        return 0;
    }
//返回前驱
//返回前驱,equal要提前声明 
Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e)
{
   int a;
   a=LocateElem(L,cur_e,equal);
   if(!a||a==1)
   {
   	cout<<"查找失败"<<endl;
   	return error;
   }
   pre_e=*(L.elem+a-2);
   return OK;
 }
//返回后继
Status NextElem(SqList L,ElemType cur_e,ElemType &next_e)
{
    int a;
    a=LocateElem(L,cur_e,equal);
    if(!a||a==L.length)
    {
   	  cout<<"查找失败"<<endl;
      return error;
    }
    next_e=*(L.elem+a);
    return OK;
    
 }
//插入新元素
Status ListInsert(SqList &L,int i,ElemType e)
{
    ElemType *newbase,*q,*p;
    if(i<1||i>L.length+1)//i值不合法
    return error;
    if(L.length>=L.listsize) //当前存储空间已满，增加分配
    {
        if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType))))
        exit(0);//分配存储空间失败
        L.elem=newbase;//新基址
        L.listsize+=LISTINREMENT;//增加存储容量
    }
        q=L.elem+i-1;//q为插入位置
        for(p=L.elem+L.length-1;p>=q;--p)
        { *(p+1)=*p;//给插入位置之后的元素赋值达到之后元素后移一位的效果
        }
        *q=e;//插入e
        ++L.length;
        return OK;
 }

//删除元素
Status ListDelete(SqList &L,int i,ElemType &e)
{
    ElemType *p,*q;
    if(i<1||i>L.length)//i值不合法
    return error;
    p=L.elem+i-1;//p为被删除元素的位置
    e=*p;//被删除元素的值赋给e
    q=L.elem+L.length-1;//表尾元素的位置
    for(++p;p<=q;++p)
    *(p-1)=*p;
    L.length--;
    return OK;
}    

//遍历线性表
Status ListTraverse(SqList L, void(*f)(ElemType&))
{
    ElemType *p=L.elem;
    int i;
    for(i=1;i<=L.length;i++)
    f(*p++);
    cout<<endl;
    return OK;
  }

第二部分栈、队列和数组

1.栈和队列的基本概念

1.栈的定义
栈是限定只能在一端进行插入和删除的线性表。允许进行插入和删除操作的一端称为栈顶，另一端为栈底。当栈中没有元素时，称为空栈。
栈的特点是“后进先出”（Last In First Out，LIFO），即后入栈的元素先出栈。
2.队列定义
队列是限定在一端进行插入，在另一端进行删除的线性表。队列中允许插入一端称为队尾，允许删除的一端称为队头。
在队尾插入元素的操作称为入队。在队头删除元素的操作称为出队。入队时只涉及队尾指针的变化；出队时，只涉及队头指针的变化。当队列中没有元素时，称为空队。
队列的特点是“先进先出”（First In First Out，FIFO），即先入队的元素先出队。

2.栈和队列的顺序存储结构

/*栈的顺序存储*/
typedef struct
{
	SElem data[MAXSIZE];
	int top;
}SqStack;

/*栈的链式存储*/
//链栈的结点
typedef struct stackNode
{
    SElem data;
    struct stackNode *next;
}stackNode,*LinkStackPtr;   //指向结点指针
//链栈的结构
typedef struct LinkStack
{
    LinkStackPtr top;     //头指针为栈顶指针
    int count;
}LinkStack;


/*队列的顺序存储*/
typedef int QElem;
typedef struct
{
    QElem data[MAXSIZE];
    int front;      //队头的位置
    int rear;       //队尾的下一位置
}SqQueue;


/*队列的链式存储*/
typedef struct QNode
{
    QElem data;
    struct QNode *next;
}QNode, *QueuePtr;
//队头指针指向头结点，对尾指针指向终端结点
typedef struct
{
    QueuePtr front,rear;   //队头、队尾指针
}LinkQueue;

4.栈和队列的应用

栈的基操
#include <iostream>  
using namespace std;

class StackNode
{
    friend class ListStack;
public:
    StackNode(int value)
        :data(value)
        ,next(NULL) 
    {}
private:
    int data;
    StackNode *next;
};

class ListStack
{
    typedef StackNode Node;
public:
    ListStack() //默认构造函数  
        :top(NULL) 
    {}  
    ListStack(const ListStack&);  //拷贝构造函数  
    ~ListStack();  //析构函数  
    ListStack& operator=(const ListStack&);  //赋值运算符重载
    bool isempty()const;  //判空  
    void push(int);  //入栈  
    bool pop();  //出栈  
    bool get_top(int&)const;  //取栈顶元素  
protected:
private:
    Node *top;
    void copy(const ListStack&);  //拷贝功能函数  
    void clear();  //清空函数，实现析构  
};

void ListStack::copy(const ListStack& other) //拷贝构造
{
    top = 0;
    Node *tmp = other.top;
    Node *prenode = top;
    while (tmp)
    {
        Node *newnode = new Node(tmp->data);
        if (top == 0)
        {
            top = newnode;
        }
        else
        {
            prenode->next = newnode;
        }
        prenode = newnode;
        tmp = tmp->next;
    }
}

void ListStack::clear() //清空栈
{
    while (top)
    {
        Node *delnode = top;
        top = top->next;
        delete delnode;
    }
}

ListStack::ListStack(const ListStack& other) //拷贝构造函数  
{
    copy(other);
}

ListStack::~ListStack() //析构函数 
{
    clear();
}

ListStack& ListStack::operator=(const ListStack& other) //赋值运算符重载 
{
    if (this != &other)
    {
        clear();
        copy(other);
    }
    return *this;
}

bool ListStack::isempty() const //判栈空
{
    return top == 0;
}

void ListStack::push(int value) //入栈
{
    Node *newnode = new Node(value);
    newnode->next = top;
    top = newnode;
}

bool ListStack::pop()//出栈 
{
    if (isempty())
    {
        return false;
    }
    Node *delnode = top;
    top = top->next;
    delete delnode;
    return true;
}

bool ListStack::get_top(int &value)const //取栈顶元素  
{
    if (isempty())
    {
        return false;
    }
    value = top->data;
    return true;
}

void test()
{
    ListStack s1;
    for (int i = 1; i <= 6; ++i)
    {
        s1.push(i);
    }
    ListStack s2(s1);
    ListStack s3;
    s3 = s1;
    int value; 
    while (s1.get_top(value))
    {
        s1.pop();
        cout << value << " ";
    }
    cout << endl << "s1 已经清空" << endl;

    while (s2.get_top(value))
    {
        s2.pop();
        cout << value << " ";
    }
    cout << endl << "s2已经清空" << endl;
    while (s3.get_top(value))
    {
        s3.pop();
        cout << value << " ";
    }
    cout << endl << "s3已经清空" << endl;
}

int main()
{
    test();
    system("pause");
    return 0;
}


队列的基操
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;


struct Qnode  //结点的结构
{
    int data;
    Qnode *next;
    Qnode(int x)
        :data(x)
        ,next(NULL)
    {}
};

class Queuet   //队列的结构
{
public:
    typedef Qnode Node;
    Queuet() //构造函数
        :front(NULL)
        , rear(NULL)
    {}

    Queuet(const Queuet& other)  //拷贝构造函数 
    {
        Copy(other);
    }

    Queuet& operator=(const Queuet& other) //赋值运算符重载 
    {
        if (this != &other)
        {
            ClearQueue(this);
            Copy(other);
        }
        return *this;
    }

    ~Queuet() //析构函数
    {}

    void Copy(const Queuet &other) 
    {
        Node *tmp = other.front;
        Node* prev = rear;
        while (tmp != NULL)
        {
            Node *newnode = new Node(tmp->data);
            if (rear == NULL)
                rear = newnode;
            else
            { 
                prev = rear;
                rear = rear->next;
                rear = newnode;
                prev->next = newnode; 
            }
            tmp = tmp->next;
            if (front == NULL)
            {
                front = newnode;
            }
        }
    }
    Queuet *InsertQueue(Queuet *Q,int x)//队列的入队操作
    {
        Node *s;
        s = (Node *)malloc(sizeof以上是关于2023年中国海洋大学计算机及电子信息考研分析的主要内容，如果未能解决你的问题，请参考以下文章 
 中国科学院大学2014年数学分析高等代数考研试题
 中国科学院大学2012年数学分析高等代数考研试题
 中国科学院大学2011年数学分析高等代数考研试题
 中国科学院大学2013年数学分析高等代数考研试题
 湖南师范大学计算机考研分数线2022
 电子信息研究生3年期间学啥

2023年中国海洋大学计算机及电子信息考研分析

考研时间跨度：

中国**大学考研专业课

中国**大学硕士研究生招生考试初试科目《数据结构》考试大纲

一、 考试目的及要求 本科目主要考查：

二、 考试内容 第一部分 线性表

三、 试题类型

四、 考试形式及时长

五、 参考书目

第一部分 线性表