数据结构考研重难点汇总

定义一个结构的一般形式为：

struct 结构名
{
//成员表列
};

例如

struct stu
{
    int num;
    char name[20];
    char sex;
    float score;
};

向上取整：比自己大的最小整数；
向下取整：比自己小的最大整数；
一、
1、基本数据类型
int char long float double
2、结构型(系统提供给程序员制作新的数据类型的一种机制，即可以用已经有的不同的基本数据类型或用户定义的结构型，组合成用户需要的负责数据类型)

typedef struct{
	int a;
	char b;
	float c;
}TypeA;//定义了一个新的数据类型，TypeA型

TypeA a[3] int a[3]
取数据时:用“.”引用：a[0].a 对比 a[0]
2、指针型
int *a //定义了一个指向整型变量的指针 类比 int a
（假设a中存放了b的地址，a指向b）*a代表取b的内容
则x=*a == x=b a=&b
3、结点构造
链表结点定义

typedef struct Node{
	int data;
	struct Node *next;
}node;

二叉树结点定义

typedef struct BTNode
{
	int data;
	struct BTNode *rhild;
	struct BTNode *lchild;
}BTNode; *btnode (BTNode类型指针的别名 BTNode *p=btnode p)

制作新结点：BTNode BT;

BTNode *BT;
BT=(BTNode*)malloc(sizeof(BTNode));//申请结点

动态申请数组空间：

int *p
p=(int *)malloc(n*sizeof(int));(P指向数组中第一个元素的地址)

4、函数
++x //先加再用

串定义：char str[]=”abcdef”; 以’\0’作为结束标志，数组长度=7，串长度=6。
串存储结构：顺序存储和链式存储
定长顺序存储结构体定义：
typedef struct{
char str[maxSize+1];//maxSize表示串的最大长度，数组长度定义为maxSize+1，多了一个‘\0’为结束标志
int length;
}Str;
变长存储分配表示
typedef struct{
char *ch; //指向动态分配存储区首地址的字符指针
int length;
}Str;
串操作：
1)StrAssign(&s,chars):将一个字符串常量赋给串s,即生成一个其值等于chars的串s。
(2) StrCopy(&s,t):串复制:将串t赋给串s。
(3) StrEqual(s,t):判串相等:若两个串s与t相等则返回真；否则返回假。
(4) StrLength(s):求串长:返回串s中字符个数。
(5)Concat(s,t):串连接:返回由两个串s和t连接在一起形成的新串。
(6)SubStr(s,i,j):求子串:返回串s中从第i(1≤i≤StrLength(s))个字符开始的、由连续j个字符组成的子串。
(7)InsStr(s1,i,s2):将串s2插入到串s1的第i(1≤i≤StrLength(s)+1)个字符中,即将s2的第一个字符作为s1的第i个字符,并返回产生的新串。
(8)DelStr(s,i,j):从串s中删去从第i(1≤i≤StrLength(s))个字符开始的长度为j的子串,并返回产生的新串。
(9)RepStr(s,i,j,t):替换:在串s中,将第i(1≤i≤StrLength(s))个字符开始的j个字符构成的子串用串t替换,并返回产生的新串。
(10) DispStr(s):串输出:输出串s的所有元素值。
1、赋值操作:
2、求串长度操作
3、串比较操作
4、串连接
5、求子串
6、串清空

数组和广义表
数组：存储：行优先、列优先
一维数组A[0…n-1]存储结构关系式：LOC(ai)=LOC(a0)+(i)L（0=<i<n）(L为每个数组元素所占存储单元)
二维数组A[a,b]行下标、列下标范围分别为[l1,h1][l2,h2]，存储关系式为：
LOC(Aij)=LOC(Al1,l2)+[(i-l1)(h2-l2+1)+(j-l2)]*L//行优先存储

假设l1和l2的值均为0，则上式变为:LOC(Aij)=LOC(A0,0)+[i*(h2+1)+j]L
LOC(Aij)=LOC(Al1,l2)+[(j-l2)(h1-l1+1)+(i-l1)]*L//列优先存储

三维数组：LOC(Aijk)=LOC(Ac1c2c3)+[(i-c1)V2V3+(j-c2)V3+(k-c3)]*L+1
其中ci,di是各维的下界和上界，Vi=di-ci+1是各维元素个数，L是一个元素所占的存储单元数。
矩阵：
矩阵的压缩存储：指为多个值相同的元素值分配一个存储空间，对零元素不分配存储空间。其目的是为了节省空间。
特殊矩阵：（对称矩阵、三角阵、对角矩阵）
对称矩阵;A[1…n][1…n] 存放在一维数组B[n(n+1)/2]
故元素aij在数组B中的下标k=1+2+…+（i-1）+j-1=i(i-1)/2+j-1(数组下标从0开始)
k=i(i-1)/2+j-1（当i>=j 下三角区和主对角线区）
j(j-1)/2+i-1 (当i<j 上三角区元素)

稀疏矩阵：顺序存储：三元组表示法
typedef struct{
int val;
int i,j;
}Trimat;
Trimat trimat[maxterms+1];//maxterms是已经定义的常量，定义了一个含有maxterms元素的稀疏矩阵
取值：trimat[k].val;表示取第k个元素的值
简便写法定义三元组
int trimat[maxterms+1][3];
trimat[k][0]表示矩阵中的元素按行优先顺序的第k个非零元素的值
float trimat[maxterms+1][3];
取非零元素位置：(int)trimat[k][1];强制转换实现取位置
链式存储：邻接表表示法和十字链表表示法
邻接表表示法：将原矩阵的每一行的非零元素串连成一个链表，链表结点中有两个分量：一个表示该结点对应的元素值和列号
十字链表的两种结点定义：
普通结点定义：

typedef struct OLNode{
	int row,col;
	struct OLNode*right,*down;
	float val;
}OLNode;

typedef struct{
	OLNode *rhead,*chead;
	int m,n,k;//矩阵行数、列数以及非零结点总数
}CrossList;

广义表
长度：
深度：括号的最大层数
表头，表尾
存储：头尾链表存储结构 、扩展线性表存储结构
树和二叉树
树：
树的存储结构：1、双亲表示法2、孩子表示法3、孩子兄弟表示法
树的先序遍历 、后序遍历
森林的先序遍历、后序遍历
二叉树的先序遍历、中序遍历
n个结点的树中有n-1条边，n个结点的二叉树中有n+1个空指针
树的性质：
1、树中的结点数等于所有结点数的度数+1
2、度为m的树中第i层上至多有mi-1个结点
3、高度为h的m叉树至多有（mh-1）/(m-1)个结点
4、具有n个结点的m叉树的最小高度为logm(n(m-1)+1)
总结点数=n0+n1+n2+…+nm
总分支数=1n1+2n2+…+m*nm
总结点数=总分支数+1
二叉树：
由二叉树的（后序、中序）（层次、中序）可以唯一确定一棵二叉树（先序、后序无法确定）
对于有N个结点的二叉树，其高度 (log2—N)
二叉树高度最高的情况是每一个层只有一个结点，此时高度为N
最小的情况是完全二叉树，高度是[log2N]+1，以2为底的对数取整后+1
所以高度是[log2N]+1 到 N

链式存储结构：

typedef struct BiTNode{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;(在含有n个结点的二叉链表中含有n+1个空链域)

先序遍历：
递归递归算法遍历

void PreOrder(Bitree T){
	if(T!=NULL){
		visit(T);//访问根结点
		PreOrder(T->lchild);//递归遍历左子树
		PreOrder(T->rchild);//递归遍历右子树
	}
}

中序遍历：

void InOrder(BiTree T){
	if(T!=NULL){
		InOrder(T->lchild);
		visit(T);
		InOrder(T->rchild);
	}
}

中序遍历非递归算法：

void InOrder2(BiTree T){
InitStack(S);BiTree p=T;
	while(p||！IsEmpty(p)){
		if(p){
			Push(S,p);
			p=p->lchild;
		}
		else {
			Pop(S,p);visit(p);
			p=p->rchild;
		}
	}
}

后序遍历

void PostOrder(BiTree T){
	if（T！=NULL）{
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		visit(T);
	}
}

三种算法时间复杂度均为O(n)
最坏情况下空间复杂度为0（n）
层次遍历：

void LevelOrder(BiTree T){//借助队列
InitQueue(Q);//初始化
BiTree p;
EnQueue(Q,T);//入队
while(!IsEmpty(Q)){
	DeQueue(Q,p);
	visit(p);
	if(p->lchild!=NULL)
		EnQueue(Q,p->lchild);
	if(p->rchild!=NULL)
		EnQueue(Q,p->rchild);
}
}

图
度：与顶点v相关的边数称为顶点v的度
有向图：有n个顶点，则最多有n(n-1)条边------有向完全图
无向图：有n个顶点，最多有n(n-1)/2条边-----无向完全图
无向图中的极大连通子图称为连通分量（极大连通子图：是无向图的连通分量，极大要求即要求该连通子图其所有的边，极小连通子图：是既要保持图连通，又要使得边数最少的子图）
有向图中的任何一对顶点都是强连通的，则称此图为强连通图，有向图中的极大强连通子图称为有向图的强连通分量
存储方式：邻接矩阵和邻接表
邻接矩阵：图的顺序存储结构
具有n个顶点的图，顶点序号是0，1，，n-1；n阶方阵A
A[i][j]=1表示顶点i与顶点j邻接
A[i][j]=0表示顶点i与顶点j不邻接
无向图：1的个数为图中总边数的2倍，矩阵中第i列或第i列的元素之和=顶点i的度
有向图：1的个数为图的边数，矩阵中第i行的元素之和=顶点i的出度，第j列元素之和=顶点j的入度
有向有权图：有边存在，则把无权图的1改为权值，若无边存在，则把0改为∞。

#define MaxVertexNum 100;  //顶点数目最大值
typedef char VertexType;//顶点的数据类型
typedef int EdgeType;//带权图中边上权值的数据类型
typedef struct{
	VertexType Vex[MaxVertexNum];//顶点表
	EdgeType Edge[MaxVertexNum][MaxVertexNum];//邻接矩阵，边表
	int vexnum,arcnum;//图的当前顶点数和弧数
}MGraph;

例如：

void f(MGraph G){
	int a=G.n;
	int b=G.e;
}

排序：
插入：直接插入排序、折半插入排序、希尔排序
交换：冒泡排序、快速排序
选择：简单选择排序、堆排序
归并类排序、基数排序
经过一趟排序，能够保证一个关键字到达最终位置，这样的排序是交换类排序（冒泡、快速）和选择（简单选择、堆）
查找：
顺序查找：
折半查找：
分块查找：
二叉排序树
二叉平衡树
散列表:根据给定关键字依照函数h查找关键字key在表中的地址，把key存在这个地址上
散列函数的构造方法：直接定地址法（不会发生冲突）、除留余数法
解决冲突的方法：开放定址法：线性探测法
拉链法