本周总结

本周的学习总结

前言

一、树的相关的知识

(1)结点:树中的一个独立单元。包含一个数据元素及若干指向其子树的分支，如图5.1
(b)中的A、B、C、D等。(下面术语中均以图5.1 (b)为例来说明)
(2)结点的度:结点拥有的子树数称为结点的度。例如，A的度为3，C的度为1, F的度
为0。
(3)树的度:树的度是树内各结点度的最大值。图5.1 (b)所示的树的度为3。
(4)叶子：度为0的结点称为叶子或终端结点。结点K、L、F、G、M、I、J都是树的
叶子。
(5)非终端结点:度不为0的结点称为非终端结点或分支结点。除根结点之外，非终端结点
也称为内部结点。
(6)双亲和孩子:结点的子树的根称为该结点的孩子，相应地，该结点称为孩子的双亲。例
如，B的双亲为A, B的孩子有E和F。
(7)兄弟:同一个双亲的孩子之间互称兄弟。例如，H、I和J互为兄弟。
(8)祖先:从根到该结点所经分支上的所有结点。例如，M的祖先为A、D和H。
和F。
(9)子孙:以 结点为想的子树中的任-结点都称为该结点的子孙。如B的子孙为E、K、L
（10)层次:结点的层次从根开始定义想，根为第一层，根的孩子为第二层。树中任-结点的
层次等于其双亲结点的层次加1。
（11)堂兄弟(双亲在同一层的结点互为堂兄弟。例如，结点G与B、F、H、I、了互为
（12）树的深度：树的结点的 层次称为树的深度或高度。图5.1（b）所示的树的深度为4.

二、二叉树与树的区别及性质

二叉树的性质如下：

三、递归函数的一些知识

递归的三大要素：
1.明确这个函数的作用
2.寻找递归结束条件
3函数的关系式
例如：

以下数列0 1 1 2 3 5 8 13 21 …被称为斐波纳契数列。

这个数列从第3项开始，每一项都等于前两项之和。

输入一个整数N，请你输出这个序列的前N项。

输入格式 一个整数N。

输出格式 在一行中输出斐波那契数列的前N项，数字之间用空格隔开。

数据范围 0<N<46 输入样例： 5 输出样例： 0 1 1 2 3

假设f(n)的功能是求第n的值，代码如下：

int  f(int  n){
}

2,找出递归结束的条件不然递归就会陷入死循环

由例题知递归出口f(1)=f(0)=1.代码如下：int f(int n){ if(n==0||n==1) return 1; }

3.找出函数关系式

本题的函数关系式为f(n)=f(n-1)+f(n-2)

4.递归函数是用栈实现的，是系统帮我们写好的，我们可以直接使用。
5.递归=递推+回溯

五.快速排序

快速排序有两种；一种是手写快排（面试用）
例：

给定你一个长度为n的整数数列。

请你使用快速排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式 输入共两行，第一行包含整数 n。

第二行包含 n 个整数（所有整数均在1~109范围内），表示整个数列。

输出格式 输出共一行，包含 n 个整数，表示排好序的数列。

数据范围 1≤n≤100000

#include<iostream>
using namespace std;

int n;
int q[1000000];
void quick_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

int main()
{
   scanf("%d",&n);
   for(int i=0;i<n;i++)
   {
       scanf("%d",&q[i]);
   }
   quick_sort(q,0,n-1);
   for(int i=0;i<n;i++) printf("%d ",q[i]);
   return 0;
}

一种是c++sort快排：(比赛用）

1、使用sort函数头文件需要#include< algorithm > 2、sort模板含三个参数：

sort (begin，end，cmp)

参数begin：要排序数组的起始地址（第一个数据的地址） 参数end：最后一个数据的下一个数据的地址 参数cmp：若这个参数不写，默认为升序
3、cmp参数不写，默认升序 4、cmp函数里写return a>b，实现降序 5、其实排序完全可以不用自己写cmp函数就可以实现排序

升序：sort(begin,end,less())； 降序：sort(begin,end,greater());
#include
#include using namespace std;

int main() { int a[]={6,5,2,1,3}; sort(a,a+5,greater());//降序
for(int i=0;i<5;i++) cout<<a[i]<<" “; //运行结果 6 5 3 2 1
sort(a,a+5,less());//升序 for(int i=0;i<5;i++) cout<<a[i]<<” ";
//运行结果1 2 3 5 6 }

例：有N个人要参加国际象棋比赛，该比赛要进行K场对弈。每个人最多参加两场对弈，最少参加零场对弈。每个人都有一个与其他人不相同的等级（用一个正整数来表示）。

在对弈中，等级高的人必须用黑色的棋子，等级低的人必须用白色的棋子。每个人最多只能用一次黑色的棋子和一次白色的棋子。为增加比赛的可观度，观众希望K场对弈中双方的等级差的总和最小。

比如有7个选手，他们的等级分别是30，17，26，41，19，38，18，要进行3场比赛。最好的安排是选手2对选手7，选手7对选手5，选手6对选手4。此时等级差的总和等于（18-17）+（19-18）+（41-38）=5达到最小。

输入格式 第一行两个正整数N，K

接下来有N行，第i行表示第i-1个人等级。

[数据规模]

在90%的数据中，1≤N≤3000；

在100%的数据中，1≤N≤100000；

保证所有输入数据中等级的值小于100000000，1≤K≤N-1。

#include<iostream>
#include<algorithm>
using namespace std;
const int N=100010;
int n,k,t=0;
int a[N],b[N];
int main()
{
	
    cin>>n>>k;
    for(int i=1;i<=n;i++)
    {
    	cin>>a[i];
	}
	sort(a+1,a+1+n);
	for(int i=1;i<=n;i++)
	{
		b[i]=a[i+1]-a[i]; 
	}
	sort(b+1,b+n);
	for(int i=1;i<=k;i++)
	t+=b[i];
	cout<<t;
	return 0;
} 

六.归并排序

给定你一个长度为n的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式
输入共两行，第一行包含整数 n。

第二行包含 n 个整数（所有整数均在1~109范围内），表示整个数列。

输出格式
输出共一行，包含 n 个整数，表示排好序的数列。

数据范围
1≤n≤100000
输入样例：
5
3 1 2 4 5
输出样例：
1 2 3 4 5
代码如下：

#include<iostream>
using namespace std;

int n;
int q[1000000],tmp[1000000];
void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int mid = (l + r)/2;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);

    int k = 0, i = l, j = mid + 1;
    while (i <= mid && j <= r)
        if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
        else tmp[k ++ ] = q[j ++ ];

    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&q[i]); 
    }
    merge_sort(q,0,n-1);
     for(int i=0;i<n;i++) printf("%d ",q[i]);
     return 0;
}

七.dfs(深度优先搜索）

dfs是搜索算法的一种。是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节vv的所有边都己被探寻过，搜索将回溯到发现节点vv的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜索

dfs像栈结构一样属于先进后出结构

dfs的应用
dfs一般用于求解全排列的问题

例：

输出自然数 11 到 nn 所有不重复的排列，即 nn 的全排列，要求所产生的任一数字序列中不允许出现重复的数字。

输入格式 一个整数 nn。

输出格式 由 1 \sim n1∼n 组成的所有不重复的数字序列，每行一个序列。

每个数字保留 5个场宽。

代码如下：
#include<iostream>
#include<cstdio>
using namespace std;
const int N = 20;
int a[N];
int st[N];
int n;
void dfs(int k)
{
	if(k==n)
	{
		for(int i=0;i<n;i++)
		printf("%5d",a[i]);
		cout<<endl;
		return;
	}
	for(int i=1;i<=n;i++)
		if(!st[i])
		{
		a[k]=i;
		st[i]=1;
		dfs(k+1);
		st[i]=0;
	}
}
int main()
{
	cin>>n;
	dfs(0);
	return 0;
}

八.bfs（广度优先搜索）

广度优先搜索遍历的过程如下：
bfs一般求最短路径问题：
例如：

给定一个n*m的二维整数数组,用来表示一个迷宫， 数组中只包含0或1，其中0表示可以走的路, 1表示不可通过的
墙壁。

最初，有一个人位于左上角(1, 1)处，已知该人每次可以向上、下左、右任意一个方向移动-一个位置。

请问，该人从左上角移动至右下角(n, m)处,至少需要移动多少次。
数据保证(1, 1)处和(n, m)处的数字为0，且-定至少存在一条通路。

输入格式
第一包含两个整数n和m。

接下来n行，每行包含m个整数(0或1) ，示完整的二维数组迷宫。
输出格式
输出一个整数,表示从左上角移动至右下角的最少移动次数。
数据范围
1 < n,m≤100
输入样例:
55
0 1 0 0 0
0 1 0 1 0
0 θ 0 0 0
0 1 11 0
0 0 0 1 0
输出样例:
8

代码如下：#include<iostream>
#include<queue>
using namespace std;
const int N = 105;

int a[N][N]; 
int dist[N][N]; 
int n,m; 

typedef pair<int,int> PII;
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};

int bfs(int x,int y)
{
    queue<PII> q;
    q.push({x,y}); 
    
    while(q.size())  
    {
        PII t = q.front(); 
        q.pop(); 
        
        for(int i=0; i<4; i++)
        {
            int a = dx[i] + t.first, b = dy[i] + t.second; 
            if(a<0 || a>=n || b<0 || b>=m) continue; 
            if(g[a][b] == 1) continue; 
            if(dist[a][b] != 0) continue; 
            
            dist[a][b] = dist[t.first][t.second] + 1;
            q.push({a,b});
        }
    }
    return dist[n-1][m-1];
}

int main()
{
    cin >> n >> m;
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
            cin >> a[i][j];
    
    cout << bfs(0,0);        
}