966，967吉大数据结构笔记

数据结构

辅导书本无非王道数据结构和天勤，如果你把这两本书看了好几遍，可以看一下数据结构1800，这本书非常不错，它长下面这样子，时间充裕的话就看，紧张的话就直接刷真题吧。

由于这本书题量过大，建议只看链表，树，图这三个章节，这三个章节侧重选择题和编码题，一些填空题可以忽略，吉大不考这类题型，如果你时间充裕那上面的请自动忽略。还有最重要的一点就是真题，这个务必要过几遍，达到看到题就会做的水准，差不多就130+的水平，吉大的题目不难，很多都是原题，还有以下的一些题型。

顺便一提，今年树和图的算法大题一个都没考。。。。。全是链表还有千年没命过题的文件操作，只能说吉大命题太诡异了。大家务必要重温一下文件操作，很多东西要复习全面，基于去年没考树图代码题，今年考的可能性很大，请大家务必注意，链表大题也不要丢下，也可能杀个回马枪，总之，复习要全面吧。
以下的代码仅供参考，所以部分代码没有备注，每个人的代码习惯不一样，所以大家重点注意的是命题风格以及题型。

以下的所有题型来源于1800题，王道，天勤以及历年真题。

链表题

这里我只写几种常见的类型，还有更多请把王道课后习题多做几遍

//链表的插入排序
void insert(Linklist &L){
    
    Lnode *p = L->next;  //如果你看了王道或者天勤应该知道我定义的结构体
    Lnode *pre;
    Lnode *r = p->next;
    p->next = NULL;
    p=r;
    while(p!=NULL){
        r = p->next; //记录下一节点
        pre = L;
        while(pre->next != NULL && pre->next->data < p->data)
            pre = pre->next;   //找到插入位置
        p->next = pre->next;   // 这行和下面一行都是插入操作
        pre->next = p;
        p = r;    //向前推进一个节点
    }
}

树变形

1，改进的层序遍历（非递归实现计算树的深度以及宽度）

void level(BTNode *p){

	int front,rear,level = 0,length = 0;
	int count = 0,width = 1,cursor;  //这里width为宽度，level为深度
	BTNode *q;
	if(p != NULL){
		rear = (reat+1)%maxsize;
		que[rear] = p;
		cursor = rear;
		while(front != rear){
			front = (front+1)%maxsize;
			count ++;
			q = que[front];
			if(q->lchild != NULL){
				rear = (rear+1)%maxsize;
				que[rear] = q->lchild;
			}
			if(q->rchild != NULL){
				rear = (rear+1)%maxsize;
				que[rear] = q->rchild;
			}
			if(front == cursor){  //是否扫描完一层
				cursor = rear;  //将下一层的最后一个节点赋值给扫描器
				level ++;    //层数+1
				width = count > width ? count : width;  //取最大宽度
				count = 0;   //重新计算下一层
			}
		}
	
	}
}

图算法

邻接矩阵的图遍历算法

首先，需要我们掌握图的结构体

typedef struct{
	char data;
	char info;
} vertexType;
typedef struct {
	int edges[maxsize][maxsize]
	int vnums,enums;
	vertexType vex[maxsize]
}mGraph

基于邻接矩阵的非递归深度优选遍历

void DFS_Nonrecursion(mGraph *G, int visit[], int stackVT){
	int stack[maxsize];
	int top = -1;
	int i,j,curVT;
	stack[++top] = stackVT;
	while(top != -1){
		curVT = stack[top--];
		cout<<G->vex[curVT].data;
		for( i = G->vnums-1; i>0; i--){
			if(G->edges[curVT][i] == 1 && visit[i] == 0){
				stack[++top] = i;
				visit[i] = 1;
			}
		}
	}
}

基于邻接矩阵的广度优先遍历

void BFS(mGraph *G, int visit[], int startVT){
	int i,queue[maxsize],front=0,rear = 0,vertex;
	queue[++rear] = startVT;
	while(front != rear){
		front = (front+1)%maxsize;
		vertex = queue[front];
		cout<<G->vex[vertex].data;
		for(i = 0; i<G->nums;i++){
			if(G->edges[vertex][i] == 1 && visit[i] == 0){
				rear = (rear+1) % maxsize;
				queue[rear] = i;
				visit[i] = 1;
			}
		}
	}
}

基于邻接矩阵的深度优先遍历（递归）

void DFS(mGraph *G, int visit[], int startVT){
	int j;
	cout<<G->vex[startVT].data;
	for(j = 0; j<G->vnums; j++){
		if(G->edges[starVT][j] == 1 && visit[j] == 0){
			visit[j] = 1;
			DFS(G,visit,j);
		}
	}
}

判断图是否有回路（邻接矩阵，有向图）

int flag = 0;
void IsCircle(int n, int v){
	if(flag == 1)return;   //回路
	for(int i = 0; i<n; i++){
		if(visit[i] == 0 && a[v][i] == 1){
			visit[i] = 1;
			IsCircle(n,i);
			visit[i] = 0;
		}
		else if(a[v][i] == 1 && v!= i) flag = 1;
	}
}

书上有拓扑排序的解决方案，邻接表的实现（有向图）天勤
下面是无向图回路的判断（连通图）

void DFS(AGraph *G, int v, int &flag){
	ArcNode *p;
	if(visit[v] == 1){
		flag = 1;
		return;
	}
	visit[v] = 1;
	p = G->adjlist[v].firstArc;
	while(p!=NULL){
		DFS(G, p->adjvex,flag);
		p = p->nextarc;
	}
}

至此完毕
如果是非连通图
for(i = 0; i<G->n; i++)
	if(visit[i] == 0)
		DFS(G,i,flag);

总结下来：

类型	时间复杂度	空间复杂度
邻接矩阵	o(n^2)	o(n^2)
邻接表	o(n+e)	o(n)

后序非递归模板

为了区分同一节点的两次出栈，设置flag。
flag = 1，表示第一次出栈，只遍历完左子树，该节点不能访问
flag = 0， 表示第二次出栈，遍历完右子树，可以访问

typedef struct element{
	BTNode * ptr;
	int flag;
}element;

void postorder(BTNode *bt){
	int top = -1;
	element *s[maxsize];
	while(bt != NULL || top != -1){
		while(bt != NULL){
			top ++;
			s[top].ptr = bt;
			s[top].flag = 1;
			bt = bt->lchild;
		}
		// 标记一
		while(top != -1 && s[top].flag == 2){
			//标记二
			bt = s[top--].ptr;
			visit[bt->data);
		}
		if(top!=-1){
			s[top].flag = 2;
			bt = s[top].ptr->rchild;
		}
	}
}

以上是后序非递归的模板
后序非递归模板可用于根节点到某一节点的路径（在标记一处写代码），也可以求公共祖先（标记二），也可以交换左右子树

求p,q节点的最近公共祖先

BTNode *CommonAncester(BTNode *bt, BTNode*p, BTNode *q){
	if(bt == NULL || bt == p || bt == q ) return bt;
	BTNode *left = CommonAncester(bt->lchild,p,q);
	BTNode *right = CommonAncester(bt->rchild,p,q);
	if((left == p && right == q) || (left ==q || right == p))
		return bt;
	return (left != NULL} ? left:right;
}
// 如果p,q 分别在左右子树中，则根节点就是最近的公共祖先，分别对左右子树进行递归，
// 如果某一子树返回为空，则证明返回上一层寻找。

n个节点的完全二叉树存放在数组A[n]中，建立一棵用二叉链表表示的二叉树根用tree指向。

BTNode *Create(ElementType a[], int i){
	BTNode * tree;
	if(i <= n){
		tree = (BTNode) malloc(sizeof(BTNode));
		tree->data = A[i];
		if(2*i > n)
			tree->lchild = NULL;
		else
			tree->lchild = Create(A, 2*i);
		if(2*i+1>n)
			tree->rchild = NULL;
		else
			tree->rchild = Create(A, 2*i+1);
	}
	return tree;
}

对上面那棵树进行前序非递归遍历

void preorder(ElemType bt[], int n){
	int i = 1,top = 0,s[];
	while(i<= n || top > 0){
		while(i<n){
			visit(bt[i]);   //访问根节点
			if(2*i+1 <= n)
				s[++top] = 2*i+1;  //柚子树入栈
				i = 2*i;   //不断访问左子树
		}
		if(top>0)
			i = s[top--];   //开始访问柚子树
	}
}

由二叉树的中序遍历和后序遍历建立二叉树

BiTree IntoPost(ElemType in[], post[], int l1, int h1, int l2, int h2){
	//in和post是中序序列和后序序列，l1，h1是第一个和最后一个节点的下标
	BiTree bt = (BiTree)malloc(sizeof(BiNode));
	bt->data = post[h2];  //后序序列最后一个元素是根节点
	for(int i = l1;i<=h1;i++){
		if(in[i] == post[h2])break;   //在中序序列中查找根节点
	}
	if(i == l1)
		bt->lchild = NULL;
	else
		bt->lchild = IntoPost(in,post,l1,i-1,l2,l2+i-l1-1);
	if(i == h1)
		bt->rchild = NULL;
	else
		bt->rchild = IntoPost(in, post, i+1, h1, l2+i-l1,h2-1);
	return bt;
}

已知满二叉树先序遍历序列，求其后序遍历序列

void change(char pre[], int L1, inr R1, char post[], int L2, int R2){
	if(L1 <= R2){
		post[R2] = pre[L1];
		change(pre, L1+1,(L1+1+R1)/2, post, L2, (L2+R2-1)/2);
		change(pre, (L1+1+R1)/2+1, R1, post, (L2+R2-1)/2+1, R2-1);
	}
}

先序遍历的第一个元素为根节点，将除第一个元素之外的元素序列分为前后两个相等的序列，前一半
为左子树的节点，后一半为柚子树的节点。只需将根节点移至序列的末尾，再分别递归处理前一半，后一半。

求有向图中邻接表的入度

void indegree(Adjlist g){
	for(i = 0; i<n; i++){
		num = 0;  //入度
		for(j = 0;j<n;j++)
			if(i!=j){
				p = g[i].firstarc;
				while(p){
					if(p->adjvex == i)
						num++;
					p = p->next;
				}
			}
	}
}

another way:
for(i =0;i<n;i++){
	p = G->adjlist[i].firstarc;
	while(p){
		indegree[p->adjvex]++; 
		p = p->nextarc;
	}
}

下面是出度的算法

int out;
void outdegree(AdjList g){
	for(int i = 0; i< n; i++){
		out = 0;
		p = g[i].firstarc;
		while(p){
			out++;
			p = p->nextarc;
		}
		cout<<"顶点"<<g[i].vexdata<<"的出度为"<<out;
	}
}

邻接矩阵转邻接表

void AdjmatrixToAdjList(AdjMatrix gm, AdjList gl){
	for(i = 0; i<n; i++){
		cin>>gl[i].vertex;
		gl[i].firstarc = NULL;
	}  //初始化
	for(i = 0;i<n;i++){
		for(j = 0;j<n;j++){
			if(gm[i][j] == 1){
				p = (ArcNode*)malloc(sizeof(ArcNode));
				p->adjvex = j;
				p->next = g[i].firstarc;
				g[i].firstarc = p;
			}
		}
	}
}

已知图邻接链表，设计算法生成相应的逆邻接表，时间复杂度为o(n+e)

void InvertAdjList(AdjList gin, AdjList gout){
	for(int i = 0; i<n; i++){
		gin[i].vertex = gout[i].vertex;
		gin[i].firstarc = NULL;
		for(int i = 0; i<n;i++){
			p = gout[i].firstarc;
			while(p!= NULL){
				j = p->adjvex;
				s= (ArcNode*)malloc(sizeof(ArcNode));
				s->adjvex = i;
				s->next = gin[j].firstarc;
				gin[j].firstarc = s;
				p = p->next;
			}
		}
	}
}

二叉树的查找与删除（真题出现过）

bool DeleteBST(BiTree *T, int key){
	if(T == NULL)
		return false;
		else if(key == T->data){
			Delete(T);
			return false;
		}
		else if(key < T->data)
			return DeleteBST(T->lchild, key);
		else
			return DeleteBST(T->rchild, key);
}

void Delete(BiTree *T){
	BiTree L;
	if(T->lchild == NULL && T->rchild == NULL)
		T = NULL;
	else if(T->rchild != NULL && T->lchild == NULL)
		T = T->rchild;
	else if(T->rchild == NULL && T->lchild != NULL)
		T = T->lchild;
	else{
		L = T->lchild;
		while(L->rchild) L = L->rchild;  //标注一
		L->rchild = T->rchild;  // 标注二
		T = T->lchild;   // 标注三
	}
}

这里的标注一是寻找最右子树，标注二是T的柚子树接到左子树的最右孩子的柚子树，
标注三是T的左子树直接作为T父节点的子树

图的深度非递归遍历

void DFS(graph g, int v){
	int i;
	arcnode *p;
	int visited[vnum],top = -1,stack[vnum];
	for(i = 0; i<g.vexnum;i++){
		visited[i] = 0;
	}
	visit(v);
	top++;
	stack[top] = v;
	visited[v] = 1;
	while(top > 0){
		v = stack[top];
		--top;
		p = g.adjlist[v].firstarc;
		while(p!=NULL && visited[p->adjvex] == 1)
			p = p->nextarc;
			if(p == NULL) --top;
			else{
				v = p->adjvex;
				visit(v);
				visited[v] = 1;
				top++;
				stack[top] = v;
			}
	}
}

打印vi到vj所有长度为L的简单路径。这类问题有模板，基本上解题思路大同小异，如果理解了这个问题。

int visited[Vnum],A[Vnum];
void dfs(graph *g, int vi, int vj, int L, int d){
	int v,i;
	arcnode *p;
	visited[vi] = 1;
	d++;
	A[d] = vi;
	if(vi == vj && d == L){
		cout<<"一条路径";   // dfs模板
		for(i = 0; i<=d; i++)
			cout<<A[i];
			return;  // 退出这层递归
	}
	p = g->adjlist[vi].firstarc;
	while(p != NULL){
		v = p->adjlist;
		if(visited[v] == 0)
			dfs(g,v,vj,L,d);
		p = p->nextarc;
	}
	visited[vi] = 0;
	--d;  //擦除访问标记，使顶点可以重用
}

hash 函数的构造方法

• 直接定址法
• 数字分析法
• 平方取中法
• 除留余数法

处理冲突的方法

• 开放定址法
• 链地址法

开放定址法包括 线性探查法（容易堆积），平方探查法（不能探查表上的所有单元）

a = 装填因子 = {关键字个数 n} / {表的长度 m} a越大，发生冲突的可能性越大，反之则反
散列表的平均查找长度依赖于a，不直接依赖于n 或 m

关于一些方法的总结：
数组的去重，可以先排序后用插入排序的思想，还可以用一个数组来计算元素的个数，计数排序的思想。

用dfs来拓扑排序

void DFS(Graph G, int v){
	visited[v] = 1;
	visit(v);
	p = G->adjlist[v].firstarc;
	while(p){
		if(visited[p->adjvex] == 0)
			DFS(G, p->adjvex);
		p = p->nextarc;
	}
	time = time+1;
	finishTime[v] = time;
}

for(v = 0;v<G.n;v++)
	if(!visited[v])
		DFS(G,v);


finishTime数组中结束的时间从小到大排列，既为TOPSort

总结图时间复杂度：

类型	时间复杂度	空间复杂度
广+表	o(n+e)	o(n)
深+表	o(n+e)	o(n)
广+矩阵	o(n^2)	o(n)
深+矩阵	o(o^2)	o(n)

非递归的快排：

void quickSort_Nonrecursion(int a[], int n){
	int stack[maxsize];
	int top = -1;
	stack[++top] = n-1;
	while(top >= 0){
		int high = stack[top--];
		int low = stack[top--];
		int m = partition(a,low,high);
		if(m+1 < high){
			stack[++top] = m+1;
			stack[++top] = high;
		}
		if(low < middle -1){
			stack[++top] = low;
			stack[++top] = middle-1;
		}
	}
}

partion函数在王道292页

MST专题

prim函数和kruskal函数都是针对无向图

prim

时间复杂度o(v^2)，不依赖|E|，因此适用于稠密图

kruskal

时间复杂度o(log(E))，其实它的时间复杂度由排序算法决定的，而排序规模是由边数e决定的，因此适用于稀疏图

Dijkstra

见天勤，内容太多了。。。。

Floyd

它的核心思想，对每个中间点进行更新一次距离，中间点为两个顶点的必经点。

还有一些需要注意的是归并排序的比较次数，这个笔记有点多，就不一一写了。需要的可以私聊我拍笔记照片给你。

还有Dijkstra图的画法，这个今年考到了，下面给个例子。

顶点	第一趟	第二趟
a	(a,b)2	…
b	无穷	…
c	…	(a,b,d)5
集合	a,b	{a,b,c}

这个好像王道还是天勤上有一个例子，和上面的差不多。

基本总结的差不多，最后祝大家考上理想的大学

传送门 吉大高级程序设计笔记