删除大文件

.gitattributes

@@ -0,0 +1 @@
+*.pdf filter=lfs diff=lfs merge=lfs -text

408代码汇总.md

@@ -0,0 +1,378 @@
+## **408代码汇总**
+
+1. 2009年
+
+   已知一个带有表头结点的单链表，结点结构为：
+
+   假设该链表只给出了头指针 list。在不改变链表的前ᨀ下，请设计一个尽可能高效的算法，查找链表中倒数第 k 个位置上的结点（k 为正整数）。若查找成功，算法输出该结点的 data 域的值，并返回 1；否则，只返回 0。
+
+   **算法思想：使用p，q两个指针，p指针先移动扫描k个指针，之后q再与p同步移动，当p指向最后一个节点时，q正好指向倒数第k个节点**
+
+   ```c
+   int SearchRearK(LNode *L, int k)
+   {
+       int count=0;//用来计数
+       LNode *q=L->link;
+       while(p!=NULL)
+       ｛
+           if(count<k)
+               count++;
+       	else
+               q=q->link;//当count等于开始，q和p同步向后移动
+       	p=p->link; 
+       ｝
+       if(count<k)
+           return 0;//如果链表节点个数小于k
+       else
+       ｛
+           printf("%d",q->data);
+           return 1;
+       ｝
+   }
+   ```
+
+   ----
+
+2. 2010年
+
+   设将 n（n>1）个整数存放到一维数组 R 中。试设计一个在时间和空间两方面都尽可能高效的算法。将 R 中保存的序列循环左移 p（0<p<n）个位置，即将 R 中的数据由（X0, X1, , Xn-1）变换为（Xp, Xp+1, , Xn-1, X0, X1, , Xp-1）。
+
+   **算法思想：先将R中前p个元素逆置，再将剩下的元素逆置，最后将R中所有的元素再整体做一次逆置即可**
+
+      ```c
+   void Reverse(int R[],int l,int r)
+   {
+      int i,j;
+      int temp;
+      for(i=l,j=r;i<j;++i,--j)
+      {
+          temp=R[i];
+          R[i]=R[j];
+          R[j]=temp
+      }
+   }
+   void RCR(int R[],int n,int p)
+   {
+      if(p<=0||p>=n)
+          cout<<"ERROR"<<endl;
+      else
+      {
+          Reverse(R,0,p-1);
+          Reverse(R,p,n-1);
+          Reverse(R,0,n-1);
+      }
+   }
+      ```
+
+----
+
+3. 2011年
+
+   一个长度为L（L≥1）的升序序列S，处在第¬L/2º个位置的数称为S 的中位数。例如，若序列S1=（11，13，15，17，19），则S1 的中位数是15，两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=（2，4，6，8，20），则S1 和S2 的中位数是11。现在有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数
+
+   **算法思想：（较容易想到）使用二路归并思想，顺序比较S1与S2，当S1小于S2中的值，S1的下标向后移动一位，同理S2小时，S2下标向后移动一位，当比较次数达到n（序列长度）时，返回对应的值，就是中位数了**
+
+   ```c
+   int Search_M(int S1[],int S2[],int n)
+   {
+       int i=j=k=0;
+       while(i<n&&j<n)
+       {
+           k++;
+           if(S1[i]<S2[j])
+           {
+               i++;
+               if(k==n)
+                   return S1[i-1];
+           }
+           else
+           {
+               j++;
+               if(k==n)
+                   return S2[j-1];
+           }
+       }       
+   }
+   ```
+
+   ----
+
+4. 2012年
+
+   假定采用带头结点的单链表保存单词，当两个单词有相同的后缀时，则可共享相同的后缀存储空间，设 str1 和 str2 分别指向两个单词所在单链表的头结点，链表结点结构为 ，请设计一个时间上尽可能高效
+   的算法，找出由 str1 和 str2 所指向两个链表共同后缀的起始位置。
+
+   **算法思想：先将较长的链表先向后移动k个位置，让两个链表之后的扫描长度是一样长的，之后两个链表的扫描指针同步向后移动，返回第一个公共节点，即是两个链表公共后缀的起始位置**
+
+   ```c
+   void FindSameRear(LNode *L1,LNode *L2)
+   {
+       int len1=Length(L1);
+       int len2=Length(L2);
+       LNode *p,*q;
+       for(p=L1;Len1>len2;len1--)
+           p=p->next;
+       for(q=L2;len2>len1;len2--)
+           q=q->next;
+       while(p->next!=NULL&&p->next!=q->next)//判断是否访问到同一节点
+       {
+           p=p->next;
+           q=q->next;
+       }
+       return p-next;//返回共同后缀的起点
+   }
+   ```
+
+   ----
+
+5. 2013年
+
+   已知一个整数序列 A=（a0, a1, …, an+1），其中0≤ai＜n（0≤i＜n）。若存在ap1=ap2=…= apm=x 且 m> n/2 (0≤pk＜n，1≤k≤m)，则称 x 为 A 的主元素。例如 A=（0, 5, 5, 3, 5, 7, 5, 5)，则 5 为主元素；又如 A=（0, 5, 5, 3, 5, 1, 5, 7），则 A 中没有主元素假设 A 中的 n 个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出 A 的主元素。若存在主元素，则输出该元素；否则输出-1。
+
+   **算法思想：（较容易理解）计数排序思想，用一个数组记录，每个值出现次数，用的是使用牺牲空间换取时间的做法**
+
+   ```c
+   int Majority(int A[],int n)
+   {
+       int k,max=0;
+       int *p;
+       p=(int*)malloc(sizeof(int)*n);//为数组申请内存空间
+       for(k=0;k<n;k++)
+           p[k]=0;//将数组初始化都为0
+       for(k=0;k<n;k++)
+       {
+           p[A[k]]++;
+           if(p[A[k]]>p[max])
+               max=a[k];//记录出现次数最多的元素
+       }	
+       if(p[max]>n/2)
+           return max;//如果个数大于n/2，表示找到了
+       else
+           return -1；
+   }
+   ```
+
+----
+
+6. 2014年
+
+   二叉树的带权路径长度（WPL）是二叉树中所有叶结点的带权路径长度之和。给定一棵二叉树 T，采用
+   二叉链表存储，二叉树的带权路径长度（WPL）是二叉树中所有叶结点的带权路径长度之和。给定一棵二叉树 T，采用二叉链表存储
+
+   **算法思想：1.先序遍历：用一个 static 变量记录 wpl，把每个结点的深度作为递归函数的一个参数传递，若该结点是叶子结点，那么变量 wpl 加上该结点的深度与权值之积；若该结点非叶子结点，那么若左子树不为空，对左子树调用递归算法，若右子树不为空，对右子树调用递归算法，深度参数均为本结点的深度参数加 1；最后返回计算出的 wpl 即可。**
+
+   **2.层次遍历使用队列进行层次遍历，并记录当前的层数，当遍历到叶子结点时，累计 wpl；当遍历到非叶子结点时对该结点的把该结点的子树加入队列；当某结点为该层的最后一个结点时，层数自增 1；队列空时遍历结束，返回 wpl。**
+
+   ```c
+   //先序遍历
+   int WPL(BTNode *root){
+   	return PreOrder(root, 0);
+   }
+   int PreOrder(BTNode *root, int deep)
+   {
+   	static int wpl = 0; //定义一个 static 变量存储 wpl
+   	if(root->lchild == NULL && root->rchild == NULL) //若为叶子结点，累积 wpl
+   		wpl += deep*root->weight;
+   	if(root->lchild != NULL) //若左子树不空，对左子树递归遍历
+   		PreOrder(root->lchild, deep+1);
+   	if(root->rchild != NULL) //若右子树不空，对右子树递归遍历
+      		PreOrder(root->rchild, deep+1);
+   	return wpl;
+   }
+   
+   //层次遍历
+   int wpl_LevelOrder(BTNode *root)
+   {
+       BTNode *q[MaxSize]; //声明队列
+   	front = rear = 0; //头指针指向队头元素，尾指针指向队尾的后一个元素
+       int wpl = 0, deep = 0; //初始化 wpl 和深度
+   	BTNode *lastNode; //lastNode 用来记录当前层的最后一个结点
+   	BTNode *newlastNode; //newlastNode 用来记录下一层的最后一个结点
+       lastNode = root; //lastNode 初始化为根节点
+   	newlastNode = NULL; //newlastNode 初始化为空
+       rear=(rear+1)%Maxsize;
+   	q[rear] = root; //根节点入队
+       BTNode *p;
+   	while(front != rear)//层次遍历，若队列不空则循环
+       { 
+   		p = q[end1++]; //拿出队列中的头一个元素
+       	if(p->lchild == NULL & p->rchild == NULL)
+   			wpl += deep*p->weight; //若为叶子结点，统计 wpl
+   		if(p->lchild != NULL)	//若非叶子结点把左结点入队
+           { 
+               rear=(rear+1)%Maxsize;
+   			q[rear] = p->lchild; 
+   			newlastNode = p->lchild;
+   		} //并设下一层的最后一个结点为该结点的左结点
+           if(p->rchild != NULL)//处理叶节点
+           { 
+                rear=(rear+1)%Maxsize;
+   			q[rear] = p->rchild;
+               newlastNode = p->rchild;
+           }
+           if(p == lastNode)//若该结点为本层最后一个结点，更新 lastNode
+           { 
+               lastNode = newlastNode;
+               deep += 1; //层数加 1
+           }
+   	}
+   	return wpl; //返回 wpl
+   }
+   ```
+
+----
+
+7. 2015年
+
+   用单链表保存 m 个整数，结点的结构为：data，且|data|≤n（n 为正整数）。现要求设计一个时 间复杂度尽可能高效的算法，对于链表中 data 的绝对值相等的结点，仅保留第一次出现的结点而删除其余绝对值相等的结点。
+
+   **算法思想：类似前面的，也是计数排序思想，借助一个数组，具体思想参考前面**
+
+   ```c
+   void DeleteABS(LNode *L,int n)
+   {
+       LNode *p=L->link,*q;//p指向L下一节点，q用来指向被删节点
+       int *a,m；
+       a=(int*)malloc(sizeof(int)*n);//为数组申请内存空间
+       for(int k=0;k<n;k++)
+           a[k]=0;//将数组初始化都为0
+       while(p!=NULL)
+       {
+           m=p->data>0?p->data:-p->data;
+           if(a[m]==0)
+           {
+               a[m]=1;//标记，前面以及有这个数了，
+               p=p->link;
+           }
+           else
+           {
+               q=p;
+               p=p->link;
+               free(q);
+           }    
+       }
+       free(a);//释放掉a的空间
+   }
+   ```
+
+----
+
+8. 2016年
+
+   已知由 n（n≥2）个正整数构成的集合 A={ak|0≤k＜n}，将其划分为两个不相交的子集 A1和 A2，元素个数分别是 n1和 n2，A1和 A2中元素之和分别为 S1和 S2。设计一个尽可能高效的划分算法，满足|n1-n2|最小且|S1-S2|最大。(全抄答案的，没有自己写)
+
+   **算法思想：将最小的n/2)个元素放在 A1中，其余的元素放在 A2中，分组结果即可满足题目要求。仿照快速排序的思想，基于枢轴将 n 个整数划分为两个子集。根据划分后枢轴所处的位置 i 分别处理：**
+   **①若 i=n/2)，则分组完成，算法结束；**
+   **②若 i＜n/2)，则枢轴及之前的所有元素均属于 A1，继续对 i 之后的元素进行划分；**
+   **③若 i＞n/2)，则枢轴及之后的所有元素均属于 A2，继续对 i 之前的元素进行划分；**
+
+   ```c
+   int setPartition(int a[], int n)
+   {
+   	int pivotkey, low=0, low0=0, high=n-1, high0=n-1, flag=1, k=n/2, i;
+   	int s1=0, s2=0;
+   	while(flag) 
+       {
+   		piovtkey=a[low]; //选择枢轴
+   		while(low<high)//基于枢轴对数据进行划分
+           { 
+   			while(low<high && a[high]>=pivotkey) –high;
+   			if(low!=high) a[low]=a[high];
+   			while(low<high && a[low]<=pivotkey) ++low;
+   			if(low!=high) a[high]=a[low];
+   		} //end of while(low<high)
+       	a[low]=pivotkey;
+   		if(low==k-1) //如果枢轴是第 n/2 小元素，划分成功
+   			flag=0;
+   		else//是否继续划分
+           { 
+   			if(low<k-1)
+               {
+   				low0=++low;
+   				high=high0;
+   			}
+       		else
+               {
+   				high0=--high;
+   				low=low0;
+   			}
+   		}
+   	}
+   	for(i=0;i<k;i++) s1+=a[i];
+   	for(i=k;i<n;i++) s2+=a[i];
+   	return s2-s1;
+   }
+   ```
+
+----
+
+9. 2017年
+
+   请设计一个算法，将给定的表达式树（二叉树）转换成等价的中缀表达式（通过括号反映次序），并输出
+
+   **算法思想：基于二叉树的中缀遍历，添加适当括号，显然，表达式的最外层（对于根节点）及操作数（对应叶节点）不需要添加括号（这句是答案说的，其实不太懂）**
+
+   ```c
+   void B2E(BTNode *root)
+   {
+       B2E(root,1);
+   }
+   void B2E(BTNode *root,int deep)
+   {
+       if(root==NULL)
+           printf("NULL");
+       else if(root->left==NULL&&root->right==NULL)
+           printf("%s",root->data);//输出操作数
+       else
+       {
+           if(deep>1) printf("(");
+           B2E(root->left,deep+1);
+           printf("%s",root->data);//输出操作符
+           B2E(root->right,deep+1);
+           if(deep>1) printf(")"); 
+       }
+   }
+   ```
+
+   ----
+
+   10. 2018年
+
+   给定一个含n（n>=1）个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组｛-5，3，2，3｝中未出现的最小正整数是1，数组｛1，2，3｝中未出现的最小正整数是4。
+
+   **算法思想：又是计数排序思想，就不再论述了，用一个数组计数，也就是用空间换时间**
+
+   ```c
+   int FindNoMin(int A[],int n)
+   {
+       int *B,i；
+       B=(int*)malloc(sizeof(int)*n);//为数组申请内存空间
+       for(i=0;i<n;i++)
+           B[i]=0;//将数组初始化都为0
+       for(i=0;i<n;i++)
+           if(A[i]>0&&A[i]<=n)//若A属于0~n之间，标记B
+               B[A[i]-1]=1;
+       for(i=0;i<n;i++)//扫描计数数组，找到目标值
+           if(B[i]==0)
+               break;
+       return i+1;
+   }
+   ```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

README.md

@@ -0,0 +1,17 @@
+# aimto408
+<img align="right" src="https://github-readme-stats.vercel.app/api?username=xiaolei565&show_icons=true&icon_color=CE1D2D&text_color=718096&bg_color=ffffff&hide_title=true" />
+这个repo是为了那些准备死磕计算机考研408的考研党准备的，当然你如果4门课中的部分也可以看看，欢迎star
+
+
+
+
+
+#### 21.03.05：添加了天勤与王道2022年pdf,添加了往年真题合集,由于个人网络问题，暂时不传到库中，请使用百度云下载
+
+#### 21.03.27：云盘里添加了2016年和2021年天勤八套卷，增加了2020年408考题，网络依旧太差，编辑这个readme已经费了老大劲，所以库中还是没更新，请及时去云盘下载
+
+#### 21.04.12 更新到仓库，如有需要云盘链接请按下面方法联系
+
+
+
+如有下载不畅，请在issues中说明，或者邮件：xuelei0227@foxmail.com联系

专业课代码稿.md

@@ -0,0 +1,579 @@
+#专业课代码稿
+- - - -
+> 顺序表与链表的定义  
+```c
+//顺序表定义
+typedef struct 
+{
+   int data[maxSize];
+   int length;
+}Sqlist;
+//在考试时直接使用下面定义即可
+int A[maxSize];
+int n;
+
+//单链表定义
+typedef struct LNode
+{
+   int data；
+   struct LNode *next；
+}LNode；
+```
+- - - -
+> 头插法与尾插法关键代码（一般重要，但必须要会）  
+```c
+//头插法
+void headinsert(LNode *&L, int a[], int n)
+{
+	LNode *p;//用于指向插入的节点
+	int i;
+	L=(LNode*)malloc(sizeof(LNode));//申请L的头节点空间
+	L->next=NULL;//L初始化为空
+	for(i=0;i<n;++i)
+	{
+		p=(LNode*)malloc(sizeof(LNode));
+		p->data=a[i];
+		//以下为核心代码
+		p->next=L->next;//p的指针指向那个L的开始节点
+		L->next=p;//L指针指向p
+	}
+}
+
+//尾插法
+void rearinsert(LNode *&L, int a[], int n)
+{
+	LNode *p，*q；//p指向要插入的节点，q指向L的最后一个节点
+	int i;
+	L=(LNode*)malloc(sizeof(LNode));
+	L->next=NULL;//这两句和头插法作用相同
+	q=L;
+	for(i=0;i<n;++i)
+	{
+		p=(LNode*)malloc(sizeof(LNode));
+		p->data=a[i];
+		//以下为核心代码
+		q->next=p;//q的next指针指向新节点
+		q=q->next;//q指向新的最后一个节点
+	}
+	
+}
+//特别注明：头插法与尾插法最后得到的序列正好完全相反，可以用以某些题目：如将递增链表修改成递减链表
+```
+
+> 栈与队列的定义  
+```c
+//顺序栈定义
+typedef struct
+{
+	int data[maxSize];
+	int top;//栈顶指针
+}SqStack;
+//假设元素为int型，可以直接使用下面方法进行定义并初始化
+int stack[maxStack];
+int top=-1;
+//链栈定义———其实就是单链表，这里就不写了
+
+//顺序队列定义
+typedef struct
+{
+	int data[maxSize];
+	int front;
+	int rear;
+}SqQueue;
+
+//链队定义
+//1.队节点定义
+typedef struct QNode
+{
+	int data;//数据域
+	struct QNode *next;//指针域
+}QNode;
+//2.类型定义
+typedef struct
+{
+	QNode *front;//队头指针
+	QNode *rear;//队尾指针
+}LiQueue；
+
+//基本上不会单独出题，应该会结合其他的考查
+```
+- - - -
+> 矩阵与三元组  
+```c
+//给定一个稀疏矩阵A（float型），其尺寸为m*n，1.建立其对应三元组存储，2.并通过三元组打印输出矩阵A。
+
+/*建立三元组*/
+void createtrimat(float A[][maxSize],int m,int n,float B[][3])
+{
+	int k=1;
+	for(int i=0;i<m;++i)
+		for(int j=0;j<n;++j)
+			if(A[i][j]!=0)//如果元素不为零，存入三元组
+			{
+				B[k][0]=A[i][j];//第一位存元素值
+				B[k][1]=i;//第二位存行号
+				B[k][2]=j;//第三位存列号
+				++k;
+			}
+		B[0][0]=k-1;//三元组第一行第一个元素记录：非零元素个数
+		B[0][1]=m;//第一行第二个元素记录：总行数
+		B[0][2]=n;//第一行第三个元素记录：总列数
+}
+
+/*通过三元组输出矩阵A*/
+void outputmatrix(float B[][3])
+{
+	int k=1;
+	for(int i=0;i<B[0][1];++i)
+		for(int j=0;j<B[0][2];++j)
+			if(i==(int)B[k][1] && j==(int)B[k][2])
+			{
+				cout<<B[k][0];
+				++k;
+			}else{
+				cout<<“0 “;	
+			}
+		cout<<endl;
+}
+
+//	不是太重要，考408必须要会
+```
+- - - -
+> 树与二叉树存储结构  
+```c
+//二叉链表存储结构，几乎考树的代码题，都得用到这个，必须要会
+typedef struct BTNode
+{
+	char data;
+	struct BTNode *lchild;
+	struct BTNode *rchild;
+}BTNode;
+```
+```c
+/*树的遍历算法*/
+//先序遍历（递归版）
+void preorder(BTNode *p)
+{
+	if(p!=NULL)
+	{
+		Visit(p);
+		preorder(p->lchild);
+		preorder(p->rchild);
+	}
+}	
+//中序遍历（递归版）
+void midorder(BTNode *p)
+{
+	if(p!=NULL)
+	{
+		midorder(p->lchild);
+		Visit(p);
+		midorder(p->rchild);
+	}
+}
+//后序遍历（递归版）
+void postorder(BTNode *p)
+{
+	if(p!=NULL)
+	{
+		postorder(p->lchild);
+		postorder(p->rchild);
+		Visit(p);
+	}
+}
+//先序遍历（非递归版——借助栈）
+void preorder1(BTNode *p)
+{
+	if(p!=NULL)
+	{
+		BTNode *stack[maxSize];
+		int top=-1;
+		BTNode *q;//指向要出栈元素
+		stack[++top]=p;
+		while(top!=-1)
+		{
+			q=stack[top—-];
+			Visit(q);
+			//注意下面的代码，先入栈右子树，再入栈左子树，切记别写错
+			if(q->rchild!=NULL)
+				stack[++top]=q->rchild;
+			if(q->lchild!=NULL)
+				stack[++top]=q->lchild;
+		}
+	}
+}
+//中序遍历的非递归遍历代码是先入栈左子树，再入栈右子树
+//注意判断当栈空时，遍历不一定结束，所以要while判断时要加上
+while(top!=-1 ||p!=NULL)
+{
+	while(q!=NULL)
+	{
+		Stack[++top]=q;
+		q=q->lchild;//左子树存在则左子树入栈
+	}
+	if(top!=-1)
+	{
+		q=stack[top—-];
+		Visit(q);
+		q=q->rchild;
+	}
+}
+//后序遍历非递归方式，考的最多，由于逆后序遍历序列和先序遍历序列只有左右子树访问次序不同，所以，借助两个即可实现后序遍历的非递归版
+//第一个栈要求先入栈左子树，再入栈右子树，代码就不写了，按照先序遍历来即可
+```
+典型题目有：求二叉树深度，二叉树查找，输出某个值，都可以使用递归求得
+```c
+//写一个算法求一棵二叉树深度，存储方式为二叉链表
+int getDepth(BTNode *p)
+{
+	int LD,RD;//用来接收左右子树深度的
+	if(p==NULL)//如果为空，输出深度为0
+		return 0；
+	else{
+		LD=getDepth(p->lchild);
+		RD=getDepth(p->rchild);
+		return (LD>RD?LD:RD)+1;//递归求法，最后返回左右子树深度的最大值+1
+	}
+}
+//在二叉树p中查找data域值为key的节点是否存在，存储方式为二叉链表，如果存在用q指向它
+void searchkey(BTNode *p,BTNode *&q,int key)
+{
+	if(p!=NULL)
+	{
+		if(p->data==key)
+			q=p;
+		else{
+			searchkey(p->lchild,q,key);
+			if(q==NULL)//剪枝，如果左子树没找到，才去右子树，增加效率
+				searchkey(p->rchild,q,key);
+		}
+	}
+}
+```
+- - - -
+> 层次遍历  
+
+```c
+//层次遍历需要借助一个循环队列，先将二叉树的头节点入队，然后出队访问，如果有左子树则左子树根节点入队，如果有右子树，则右子树根节点入队，然后出队，并进行访问，循环，直至队空为止
+void levelorder(BTNode *p)
+{
+	BTNode *que[maxSize];
+	int front=rear=0;//定义一个队列
+	BTNode *q;//用于指向出队元素
+	if(p!=NULL)
+	{
+		rear=(rear+1)%maxSize;
+		que[rear]=p;//根节点入队
+		while(front!=rear)//队不空循环
+		{
+			front=(front+1)%maxSize;
+			q=que[front];
+			Visit(q);//如果队不为空，开始出队访问
+			if(q->lchild!=NULL)//如果左子树不空，则入队
+			{
+				rear=(rear+1)%maxSize;
+				que[rear]=q->lchild;
+			}	
+			if(q->rchild!=NUll)//如果右子树不空，则入队
+			{
+				rear=(rear+1)%maxSize;
+				que[rear]=q->rchild;
+			}
+		}
+	}
+}
+```
+> 层次遍历最经典的考题，求二叉树宽度  
+```c
+//设计一个算法求二叉树的宽度，用二叉链表存储
+//先定义一个顺序非循环队列，可以存储节点节点所在的层次号
+typedef struct
+{
+	BTNode *b;//节点指针
+	int lno;//节点所在层次号
+}ST；
+
+int maxwidth(BTNode *p)
+{
+	ST que[maxSize];
+	int front=rear=0;//定义一个顺序非循环队列
+	int Lno=0,max=0,n=0;
+	BTNode *q;
+	//下面其实就是层次遍历，但将循环队列改成了非循环队列而已
+	if(p!=NULL)
+	{
+		++rear;
+		que[rear].b=p;//根节点入队
+		que[rear].lno=1;//此时层号为1
+		while(front!=rear)
+		{
+			++front;
+			q=que[front].b;//用q指向出队节点
+			Lno=que[front].lno;//Lno用来存当前节点的层数
+			if(q->lchild!=NULL)
+			{
+				++rear;
+				que[rear].b=q->lchild;
+				que[rear].lno=Lno+1;//关键句，根据当前节点的层号推其孩子节点层号
+			}
+			if(q->rchild!=NULL)
+			{
+				++rear;
+				que[rear].b=q->rchild;
+				que[rear].lno=Lno+1;//关键句，根据当前节点的层号推其孩子节点层号
+			}
+		}
+//下面的代码就是来找节点层中的节点数
+		for(int i=1;i<=Lno;++i)//层号
+		{
+			n=0;
+			for(int j=1,j<=rear;++j)//找队列里面与层号相同的节点，每找到一个，n+1
+				if(que[j].lno==i)
+					++n;
+			if(max<n)
+				max=n;
+		}
+		return max;
+	}
+	else
+		return 0;//如果是空树直接返回0
+}
+```
+- - - -
+> 线索二叉树定义(考的不多，了解即可）  
+```c
+typedef struct TBTNode
+{
+	char data;
+	int ltag,rtag;
+	struct TBTNode *lchild;
+	struct TBTNode *rchild; 
+}TBTNode;
+```
+- - - -
+> 图（重点）  
+```c
+//图的邻接矩阵定义
+typedef struct
+{
+	int no;//顶点编号
+	char info;
+}VertexType；
+typedef struct
+{
+	int edges[maxSize][maxSize];
+	int n,e;//顶点个数和边个数
+	VertexType vex[maxSize];//存放节点信息
+}MGraph;
+//上面的定义如果没记住，也要记住里面的元素，如n，e等含义
+
+//图的邻接表，重点中的重点，考的很多
+typedef struct ArcNode
+{
+	int adjvex;//该边所指向的位置
+	struct ArcNode *nextarc;//指向下一条边的指针
+	int info;
+}ArcNode;//边定义
+typedef struct
+{
+	char data;
+	ArcNode *firstarc;
+}VNode;//顶点定义
+typedef struct
+{
+	int n,e;
+	VNode adjlist[maxSize];
+}AGraph;//邻接表类型定义
+
+//408邻接多重表（无向图）与十字链表（有向图）几乎不考
+```
+> 图的遍历操作  
+```c
+//深度优先搜索遍历,使用邻接表为存储结构(递归)
+int visited[maxSize];//访问标记
+void DFS(AGraph *G,int v)
+{
+	ArcNode *p;
+	visited[v]=1;
+	Visit(v);
+	p=G->adjlist[v].firstarc;//指向第一条边
+	while(p!=NULL)
+	{
+		if(visited[p->adjvex]==0)//若顶点未被访问，则递归
+			DFS(G,p-adjvex);
+		p=p->nextarc;
+	}
+}
+//广度优先搜索遍历，使用邻接表为存储结构,需要借助队列（非递归）
+int visited[maxSize];
+void BFS(AGraph *G,int v)
+{
+	ArcNode *p;
+	int que[maxSize];
+	int front=rear=0;
+	int w;
+	visited[v]=1;
+	Visit(v);
+	rear=(rear+1)%maxSize;
+	que[rear]=v;//入队
+	while(front!=rear)
+	{
+		front=(front+1)%maxSize;
+		w=que[front];//出队
+		p=G->adjlist[w].firstarc;
+		while(p!=NULL)
+		{
+			if(visited[p->adjvex]==0)//当前节点未被访问，则入队
+			{
+				visited[p->adjvex]=1;
+				Visit(p->adjvex);
+				rear=(rear+1)%maxSize;
+				que[rear]=p->adjvex;
+			}
+			p=p->nextarc;//p指向w下条边
+		}
+	}
+}
+```
+> 图的经典例题  
+```c
+//求距离顶点最远的顶点
+//广度优先搜索遍历最后一个顶点一定是距离给定顶点最远的一个顶点，所以在广度优先搜索遍历代码后返回最后一个顶点即可。
+
+//判断无向图是否为一棵树
+//一个无向图是一棵树的条件是有n-1条边的连通图
+int visited[maxSize];
+void DFS2(AGraph *G,int v,int &vn,int &en)
+{
+  //下面的代码基本上就是深度优先遍历，只是多了顶点和边计数
+	ArcNode *p;
+	visited[v]=1;
+	++vn;//访问的顶点数自增1
+	p->G.adjlist[v].firstarc;
+	while(p!=NULL)
+	{
+		++en;//边数自增1
+		if(visited[p->adjvex]==0)
+			DFS2(G,p->adjvex,vn,en);
+		p=p->nextarc;
+	}
+}
+int judgetree(AGraph *G)
+{
+	int vn=0,en=0,i;
+	for(i=0;i<G->n;++i)
+		visited[i]=0//将所有标记初始化为0，表示未被访问
+	DFS2(G,1,vn,en);
+	//如果遍历过程中访问的顶点数和途中的顶点数相等，且边数等于顶点数-1，则为树
+	if(vn==G->n && (G->n-1)==en/2)//无向图边为实际上en计数的一半
+		return 1;
+	else
+		return 0;
+}
+//判断ij两点是否有路径
+//关键代码如下
+for(int i=0;i<G->n;++i)
+	visited[i]=0//初始化为0，表示未被访问
+DFS(G,i);
+if(visited[j]==1)
+	return 1;
+else
+	return 0;
+```
+> 最短路径问题，代码推荐只看Floyd，比较简单易懂  
+```c
+//算法思想：使用邻接矩阵的存储结构，先初始化A与Path数组，之后循环判断A[i][j]>A[i][k]+A[k][j]，如果成立则令A[i][j]=A[i][k]+A[k][j]
+void Floyd(MGraph g, int Path[][maxSize])//采用邻接矩阵存储
+{
+	int i,j,k;
+	int A[maxSize][maxSize];
+	//初始化A与Path数组
+	for(i=0;i<g.n;++i)
+		for(j=0;j<g.n;++j)
+		{
+			A[i][j]=g.edges[i][j];
+			Path[i][j]=-1;
+		}
+	//关键代码
+	for(k=0;k<g.n;++k)
+		for(i=0;i<g.n;++i)
+			for(j=0;j<g.n;++j)
+				if(A[i][j]>A[i][k]+A[k][j])
+				{
+					A[i][j]=A[i][k]+A[k][j];
+					Path[i][j]=k;
+				}
+}
+```
+- - - -
+> 拓扑排序  
+```c
+//算法思想：遍历扫描全部节点，将入度为0的节点入栈，之后栈不空出栈，将输出计数n进行加一，和出栈节点链接的nextarc节点，将入度的count—-，如果count==0时入栈，while一直循环直到栈空，之后判断n是否等于G->n，如果相等return 1，否则return 0.
+
+//改造VNode定义，加上count
+typedef struct 
+{
+	char data;
+	ArcNode *firstarc;
+	int count;//新加，用以计入度为多少
+}VNode;
+int TopSort(AGraph *G)
+{
+	int stack[maxSize];
+	int top=-1;//定义一个栈
+	ArcNode *p;
+	int i,n;//n为访问计数
+	for(i=0;i<G->n;++i)//将入度为0的节点入栈
+		if(G->adjlist[i].count==0)
+			stack[++top]==i;
+	//下面是关键代码
+	while(top!=-1)
+	{
+		i=stack[top—-];//栈不空，出栈
+		++n;//将访问计数n++
+		//output number of i 
+		p=G->adjlist[i].firstarc;
+		while(p!=NULL)
+		{
+			—-(G->adjlist[p->adjvex].count);
+			if(G->adjlist[p->adjvex].count)
+				stack[++top]=p->adjvex;
+			p=p->nextarc;
+		}
+	}
+	if(n==G->n)
+		return 1;
+	else
+		return 0;
+}
+```
+- - - -
+> 排序算法  
+```c
+//代码主要是掌握插入排序，快速排序（分治思想，考的特别多），选择排序，还得了解一下动态规划思想
+void InsertSort(int R[],int n)
+{
+	int i,j,temp;
+	for(i=1;i<n;++i)
+	{
+		temp=R[i];//每次循环第一步先将待排关键字暂存temp中
+		j=i-1;
+		while(j>=0&&temp<R[j];
+		{
+			R[j+1]=R[j];
+			—-j;
+		}
+		R[j+1]=temp;
+	}
+}
+
+
+//下面是重点，快速排序，不敲了，打印后自己写
+
+
+
+
+```
+
+- - - -
+> 总结：主要是线性表，链表，二叉链表，还有图，部分排序算法