中国**大学考研专业课
Posted 狗蛋儿l
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了中国**大学考研专业课相关的知识，希望对你有一定的参考价值。
中国**大学硕士研究生招生考试初试科目《数据结构》考试大纲
一、 考试目的及要求 本科目主要考查：
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以上是关于中国**大学考研专业课的主要内容，如果未能解决你的问题，请参考以下文章