Matlab





```
clear
% creat all input variable
disp('（1）中为A1   （2）中为A2');
A1 = [3.01,6.03,1.99;
        1.27,4.16,-1.23;
        0.987,-4.81,9.34];
A2 = A1;
A2(1,1) = 3.00;
A2(3,1) = 0.990;
b = [1,1,1]';
% display
disp('MAT A1 is ');
disp(A1);
disp('MAT A2 is ');
disp(A2);
disp('MAT b is ');
disp(b);
disp('detA1 is ');
disp(det(A1));
disp('detA2 is ');
disp(det(A2));
disp('cond(A1,1) is ');
disp(cond(A1,1));
disp('cond(A1,2) is ');
disp(cond(A1,2));
disp('cond(A1,inf) is ');
disp(cond(A1,inf));
%列主元消去法          
disp('在（1）中的情况：');
A = A1;
B = [A,b];
n = length(b);
rankA=rank(A);
rankB=rank(B);
if rankB-rankA>0
    disp('此方程组无解.\n')
end
if rankA==rankB
    if rankA==n
        fprintf('rankA=rankB=%d,有唯一解.\n',n)
        X=zeros(n,1);
        for p=1:n-1
              t=find(abs(B(p:end,p))==max(abs(B(p:end,p))))+p-1;
              if abs(B(t,p))~=abs(B(p,p))
                    l=B(t,:);
                    B(t,:)=B(p,:);
                    B(p,:)=l;
              end  %列主元判断
              for k=p+1:n     
                    m= B(k,p)/ B(p,p);
                    B(k,p:n+1)= B(k,p:n+1)-m* B(p,p:n+1);
              end
        end
        %把方程组系数矩阵A化为同解的上三角矩阵
        b=B(1:n,n+1);
        A=B(1:n,1:n); 
        X(n)=b(n)/A(n,n);
        for q=n-1:-1:1
            X(q)=(b(q)-sum(A(q,q+1:n)*X(q+1:n)))/A(q,q);
        end
        %从xn至x1逐个求解上三角方程组
    else
        disp('rankA=rankB<n，有无穷多解.')
        return
    end
end
disp('方程组的解为：');
disp(X)
%列主元消去法          
disp('在（2）中的情况：');
A = A2;
B = [A,b];
n = length(b);
rankA=rank(A);
rankB=rank(B);
if rankB-rankA>0
    disp('此方程组无解.\n')
end
if rankA==rankB
    if rankA==n
        fprintf('rankA=rankB=%d,有唯一解.\n',n)
        X=zeros(n,1);
        for p=1:n-1
              t=find(abs(B(p:end,p))==max(abs(B(p:end,p))))+p-1;
              if abs(B(t,p))~=abs(B(p,p))
                    l=B(t,:);
                    B(t,:)=B(p,:);
                    B(p,:)=l;
              end  %列主元判断
              for k=p+1:n     
                    m= B(k,p)/ B(p,p);
                    B(k,p:n+1)= B(k,p:n+1)-m* B(p,p:n+1);
              end
        end
        %把方程组系数矩阵A化为同解的上三角矩阵
        b=B(1:n,n+1);
        A=B(1:n,1:n); 
        X(n)=b(n)/A(n,n);
        for q=n-1:-1:1
            X(q)=(b(q)-sum(A(q,q+1:n)*X(q+1:n)))/A(q,q);
        end
        %从xn至x1逐个求解上三角方程组
    else
        disp('rankA=rankB<n，有无穷多解.')
        return
    end
end
disp('方程组的解为：');
disp(X)
%use matlib 
%disp('使用matlib直接求解');
%disp(A2\b);
```



结果

```
>> Untitled
（1）中为A1   （2）中为A2
MAT A1 is 
    3.0100    6.0300    1.9900
    1.2700    4.1600   -1.2300
    0.9870   -4.8100    9.3400
MAT A2 is 
    3.0000    6.0300    1.9900
    1.2700    4.1600   -1.2300
    0.9900   -4.8100    9.3400
MAT b is 
     1
     1
     1
detA1 is 
   -0.0305
detA2 is 
   -0.4070
cond(A1,1) is 
   5.5228e+04
cond(A1,2) is 
   3.0697e+04
cond(A1,inf) is 
   5.6751e+04
在（1）中的情况：
rankA=rankB=3,有唯一解.
方程组的解为：
   1.0e+03 *
    1.5926
   -0.6319
   -0.4936
在（2）中的情况：
rankA=rankB=3,有唯一解.
方程组的解为：
   56.3415
  -22.1547
  -17.3024
```

MATLAB 列主元消去法 解方程组

Matlab





```
clc
clear
n=input('请输入矩阵的阶数n：');
A=zeros(n);
%构造矩阵A
for m=1:n
    A(m,m)=20;
end
for m=1:n-1
    A(m,m+1)=-8;
    A(m+1,m)=-8;
end
for m=1:n-2
    A(m,m+2)=1;
    A(m+2,m)=1;
end
disp(A)
%%%%%%%%%%%%%%Jacobi迭代法求解
%用矩阵X的行向量来存放每一次迭代的解
for m=1:n
    X(1,m)=1;
    Y(1,m)=0;
end
fs=1;  %设置初始值，以便开始下方的循环
t=1;
while fs >10^(-6)
    for p=1:n
        Y(t,:)=X(t,:);   %第t次迭代
        Y(t,p)=0;   %与解有关，与第几次迭代无关
        X(t+1,p)=-Y(t,:)*A(p,:)'/A(p,p);   %第t次迭代的第p个解
    end
    C=zeros(1,n);
    for u=1:n
        C(u)=abs(X(t+1,u));
    end
    fs=max(C);
    t=t+1;
end
t-1      %显示迭代次数
```

MATLAB Jacobi迭代法求解

Matlab





```
% -----------------------------------------------------------------------------------------------
% Written by QQ742971636
% -----------------------------------------------------------------------------------------------
% f(x)=(10/x)^2*sin(10/x);
% 10个子区间 每个子区间n=4 复合高斯勒让德求积分
% ------------------------------------------------------------------------------------------------
XX=[-0.9061798459,-0.5384693101,0,0.5384693101,0.9061798459]; %查表得到的取点
AA=[0.2369268851,0.4786286705,0.5688888889,0.4786286705,0.2369268851];%查表得到的系数
x=linspace(1,3,11); %取10个子区间 也就是11个x坐标点
integral_zi=zeros(1,10); %记录每个子区间的积分结果
for cycles=1:10    %计算10个子区间积分
    a=x(cycles);   %每个子区间的左端点
    b=x(cycles+1);%每个子区间的右端点
    S=0;  %结果暂时存
    for k=1:5  %迭代算高斯勒让德公式的每一项
        tt=(b-a)/2*XX(k)+(a+b)/2; %变换积分区间为-1为1
        S=S+AA(k)*(10/tt)^2*sin(10/tt);  %算出-1到1上的高斯勒让德积分
    end
    integral_zi(cycles)=(b-a)/2*S;  %补上系数(b-a)/2 得到子区间积分结果
end
integral=sum(integral_zi);  %10个子区间的积分结果相加 
fprintf("积分结果是    %f\r\n",integral); %打印积分结果
```

结果
```
积分结果是    -1.426025
```

matlab 10个子区间 每个子区间n=4 复合高斯勒让德 求积分

Matlab





```
% -----------------------------------------------------------------------------------------------
% Written by QQ742971636
% -----------------------------------------------------------------------------------------------
% 计算实习题1    使用各种迭代法解分线性方程x^3+2*x^2+10*x-20=0.
% ------------------------------------------------------------------------------------------------
clc,clear
leonardo_x=1.368808107;                                    %勒让德得到的解
initx=1.0;                                                              %迭代值的初始值
% -----------------------------------------------------------------------------------------------
%  分析第 1 种迭代法是否收敛x=20/(x^2+2*x+10)
% ------------------------------------------------------------------------------------------------
syms x
fai=20/(x^2+2*x+10);                                            %x=fai(x)
y=diff(fai);                                                            %计算导函数
y1 = subs(y,x,1.368808107);                                %求在x0处的导数值
y1=abs(y1);                                                         %绝对值
fprintf('第 1 种方法，x=20/(x^2+2*x+10)，|fai`(x*)| =%.10f\r\n',double(y1));
if(y1<1)                                                                %有y=|fai`(x*)|<1收敛
    x=initx;                                                             %赋解的初值
    n=0;                                                                 %迭代次数
    while(abs(x-leonardo_x)>1e-9)                         %一直计算到勒让德解的精度
        x=20/(x^2+2*x+10);                                      %迭代公式计算
        n=n+1;                                                        %迭代次数增加一次
    end
    fprintf(" 该方法|fai`(x*)| <1，收敛，最后解是 %.10f，迭代了%d次\r\n",x,n);
else                                                                     %有y=|fai`(x*)|>1不收敛
    fprintf(" 该方法|fai`(x*)| 大于1，不收敛\r\n");
end
% -----------------------------------------------------------------------------------------------
%  第 1 种方法收敛，使用Steffensen法加速收敛速度
% ------------------------------------------------------------------------------------------------
x=initx;                                                                 %赋解的初值
n=0;                                                                     %迭代次数
while(abs(x-leonardo_x)>1e-9)                             %一直计算到勒让德解的精度
    y=20/(x^2+2*x+10);                                          %迭代公式计算
    z=20/(y^2+2*y+10);                                          %迭代公式计算
    x=x-(y-x)^2/(z-2*y+x);                                       %迭代公式计算
    n=n+1;                                                            %迭代次数增加一次
end
fprintf(" 使用Steffensen法加速，最后解是 %.10f，迭代了%d次\r\n",x,n);
fprintf("\r\n");
% -----------------------------------------------------------------------------------------------
%  分析第 2  种迭代法是否收敛 x=(20-2*x^2-x^3)/10.0
% ------------------------------------------------------------------------------------------------
syms x
fai=(20-2*x^2-x^3)/10.0;                                       %x=fai(x)
y=diff(fai);                                                            %计算导函数
y1 = subs(y,x,1.368808107);                                %求在x0处的导数值
y1=abs(y1);                                                         %绝对值
fprintf('第 2 种方法，x=(20-2*x^2-x^3)/10.0，|fai`(x*)| =%.10f\r\n',double(y1));
if(y1<1)                                                                %有y=|fai`(x*)|<1收敛
    x=initx;                                                             %赋解的初值
    n=0;                                                                 %迭代次数
    while(abs(x-leonardo_x)>1e-9)                         %一直计算到勒让德解的精度
        x=(20-2*x^2-x^3)/10.0;                                  %迭代公式计算
        n=n+1;                                                         %迭代次数增加一次
    end
    fprintf(" 该方法收敛，最后解是 %.10f，迭代了%d次\r\n",x,n);
else                                                                     %有y=|fai`(x*)|>1不收敛
    fprintf(" 该方法|fai`(x*)| >1，不收敛\r\n");
end
fprintf("\r\n");
% -----------------------------------------------------------------------------------------------
%  分析Newton迭代法是否收敛
% ------------------------------------------------------------------------------------------------
syms x
y1=x^3+2*x^2+10*x-20;                                       %迭代公式一部分
y2=diff(y1);                                                          %计算导函数
fai=x-y1/y2;                                                          %x=fai(x)
y=diff(fai);                                                            %计算导函数
y3 = subs(y,x,1.368808107);                                %求在x0处的导数值
y3=abs(y3);                                                         %绝对值
fprintf('第 3 种方法，Newton法，|fai`(x*)| =%.10f\r\n',double(y3));
if(y3<1)                                                               %有y=|fai`(x*)|<1收敛
    xk=initx;                                                           %赋解的初值
    n=0;                                                                %迭代次数
    while(abs(xk-leonardo_x)>1e-9)                       %一直计算到勒让德解的精度
        xk=double(subs(fai,x,xk));                            %迭代公式计算
        n=n+1;                                                        %迭代次数增加一次
    end
    fprintf(" 该方法|fai`(x*)| <1，收敛，最后解是 %.10f，迭代了%d次\r\n",xk,n);
else                                                                     %有y=|fai`(x*)|>1不收敛
    fprintf(" 该方法|fai`(x*)| 大于1，不收敛\r\n");
end
```


结果

```
第 1 种方法，x=20/(x^2+2*x+10)，|fai`(x*)| =0.4438283287
 该方法|fai`(x*)| <1，收敛，最后解是 1.3688081065，迭代了24次
 使用Steffensen法加速，最后解是 1.3688081078，迭代了3次
第 2 种方法，x=(20-2*x^2-x^3)/10.0，|fai`(x*)| =1.1096139329
 该方法|fai`(x*)| >1，不收敛
第 3 种方法，Newton法，|fai`(x*)| =0.0000000005
 该方法|fai`(x*)| <1，收敛，最后解是 1.3688081078，迭代了4次
```

matlab 使用各种迭代法解分线性方程x^3+2*x^2+10*x-20=0

Matlab





```
clc,clear
syms x
nd=1e21*erfc(x/2/sqrt(4.85*(1e-14)*360000));
q=1.6*1e-19;
xi=1e-4;
nx=nd+1e16;
u=65+1265/(1+(nd/8.5/1e16)^0.72);
f=int(u*q*nx,x,0,xi);
rs=1/f;
rs=vpa(rs);
disp(rs);
clear;
syms x
dudu=int(1e21*erfc(x/2/sqrt(4.85*(1e-14)*3600)),x,0,1e-4);
dudu=double(dudu);
disp(dudu);
x=linspace(0,7.1*10^(-4),300);
t=1*3600.0;
temp=exp(-x.^2/4/4.85/(1e-14)/t);
y1=temp*dudu/sqrt(pi*4.85*(1e-14)*t);
plot(x,y1,':r+')
hold on
t=10*3600.0;
temp=exp(-x.^2/4/4.85/(1e-14)/t);
y1=temp*dudu/sqrt(pi*4.85*(1e-14)*t);
plot(x,y1,'-.g.')
t=100*3600.0;
temp=exp(-x.^2/4/4.85/(1e-14)/t);
y1=temp*dudu/sqrt(pi*4.85*(1e-14)*t);
plot(x,y1,'--b+')
legend("t= 1*3600 s","t=10*3600 s","t=100*3600 s")
xlabel("thickness   unit:cm")%x轴标记
ylabel("concentration C(c,t)  unit:cm\^(-3)")%y轴标记
title("concentration")%标题
```

最后效果图：

![在这里插入图片描述](/static/img/images/02783.png)

MATLAB 画曲线

**MATLAB 对实验数据的离散点进行n次的曲线拟合**





```
clc,clear
% -----------------------------------------------------------------------------------------------
% Written by QQ742971636
% -----------------------------------------------------------------------------------------------
% 习题  对实验数据进行3次和4次拟合，画出图
%          然后根据曲线自己求几个拟合，画出图
%          画出原始数据折线图
% ------------------------------------------------------------------------------------------------
% --------------------------------------------------------------------------------------------
% 实验数据 x y 初始赋值，画出原始数据折线图
% --------------------------------------------------------------------------------------------
x=[0.0 0.1 0.2 0.3 0.5 0.8 1.0];
y=[1.0 0.41 0.5 0.61 0.91 2.02 2.46];
plot(x,y,'b');                                                         %画出原始数据折线图
hold on
% --------------------------------------------------------------------------------------------
% 自编拟合函数，传入x,y和n，画出n次拟合曲线
% --------------------------------------------------------------------------------------------
for cishu=2:5
    c=colormap(lines(5));
    xishu=quxiannihe(x,y,cishu);                            % 传入x,y和n，得到多项式系数
    xx=linspace(0,1,500);                                       %画出n次拟合曲线
    yy=polyval(xishu,xx);                                        %画出n次拟合曲线
    plot(xx,yy,'color',c(cishu,:));                              %画出n次拟合曲线
    hold on 
end
legend("n=2","n=3","n=4","n=5");
title("n次拟合曲线图")%标题
% --------------------------------------------------------------------------------------------
% 曲线拟合函数quxiannihe()
% 传入参数：x,y为二维坐标实验数据
%                  n 为进行n次拟合
% 传出参数：a  最后拟合结果多项式系数，降幂排列，形状（1,n+1）
% --------------------------------------------------------------------------------------------
function [a]=quxiannihe(x,y,n)
m=length(x)-1;                                                     %实验数据多少，从0到（个数+1）
A=zeros(n+1,n+1);                                               %初始化法方程A*a=b中的参数A
for row=1:n+1                                                      %计算每一行元素row
    for i=1:n+1                                                       %计算每一列i
        Sum=0;                                                       %计算某一行某一列值
        for count=1:m+1
            Sum=Sum+x(count)^(row-1)*x(count)^(i-1); %计算内积累加值
        end
        A(row,i)=Sum;                                              %赋值到A对应元素
    end
end
b=zeros(n+1,1);                                                   %初始化法方程中A*a=b的参数b
for i=1:n+1                                                           %计算每一个元素
    Sum=0;
    for count=1:m+1
        Sum=Sum+x(count)^(i-1)*y(count);              %计算内积累加值
    end
    b(i,1)=Sum;                                                     %赋值到b对应元素
end
a=A\b;                                                                 %求法方程A*a=b中的参数a
a=fliplr(reshape(a,1,n+1));                                   %整理a的形状，降幂排序
fprintf("%d次拟合的结果多项式系数：",n);
disp(a);                                                                %打印
end
```

**最终得到的拟合图像：**

![在这里插入图片描述](/static/img/images/02784.png)

MATLAB 对实验数据的离散点进行n次的曲线拟合

不想动手调程序的可以试试这个任意大小屏幕录制成gif图的软件。





![在这里插入图片描述](/static/img/images/02790.png)


MATLAB 用很多图片 生成gif动图

1、生成很多图

我这里画了cos曲线和一个圆， (x0,y0)是切点，x0取值t = linspace(0.1,0.9,10); 

 (xc,yc)是圆心。计算好之后，使用plot(xxxx1,y1,'r',xxxx2,y2,'b');%画出函数1和函数2的图形，然后saveas(gcf, num2str(count_num_single), 'jpg');保存这张图，图名生成的。x0有10个点，循环10次，这样就能得到10张图。

 
```
clc
clear all
pi=3.1415926;
%目的就是根据切点画图
t = linspace(0.1,0.9,10);  % 手定
count_num_single=1;
w=1; % 改变胖瘦
for x0=t
    y0 = cos(w*x0+pi) ; % (x0,y0)是切点 根据函数公式和已经的x0得到y0
    y0i=(-w) * sin(w*x0+pi);%导数
    yc = -2.8;  % (xc,yc)是圆心  最后要满足条件 -yc<R 才能让圆的最高点在第四象限
    syms xc R    % R是圆半径  xc是圆心的横坐标
    % enqs变量就是2个方程式 就是联立1和2的式子
    eqns = [(x0 - xc)^2 + (y0 - yc)^2 - R^2==0, (y0 - yc) / (x0 - xc) * y0i + 1==0];
    vars = [xc R];
    [xc, R] = solve(eqns, vars);
    xc=vpa(xc,4);
    R=vpa(R,4);
    xc=double(xc);
    R=double(R);
    xc=max(xc);
    R=max(R);
    %下面几句是画图形
    xxxx1=linspace(-pi,2*pi,2000);%给出范围
    xxxx2=linspace(xc-R,xc+R,2000);%给出范围
    y1=cos(w*xxxx1+pi);%范围内的函数1
    y2=sqrt(R^2-(xxxx2 - xc).^2)+yc;%范围内的函数2
    plot(xxxx1,y1,'r',xxxx2,y2,'b');%画出函数1和函数2
    grid on;
    axis equal;
    saveas(gcf, num2str(count_num_single), 'jpg');
    count_num_single=count_num_single+1;
end
```


2、生成gif图

刚才生成的图，读出来，写入到gif图，最终成动图。
```
num=count_num_single-1;
for i=1:num
    str = strcat(num2str(i), '.jpg');
    A=imread(str);
    [I,map]=rgb2ind(A,256);
    if(i==1)
        imwrite(I,map,'movefig.gif','DelayTime',0.1,'LoopCount',Inf)
    else
        imwrite(I,map,'movefig.gif','WriteMode','append','DelayTime',0.1)
    end
end
```

效果图：

![在这里插入图片描述](/static/img/images/02791.gif)

MATLAB 用很多图片 生成gif动图

![在这里插入图片描述](/static/img/images/00424.png)






```csharp
from typing import List
class Solution:
    def dfs(self, grid, cur_i, cur_j) -> int:
        # 超出边界 or 不是陆地  程序靠此结束
        if cur_i < 0 or cur_j < 0 or cur_i == len(grid) or cur_j == len(grid[0]) or grid[cur_i][cur_j] != 1:
            return 0
        grid[cur_i][cur_j] = 0  # 访问过的设置为0,全局的
        ans = 1  # 访问过的陆地，1块
        for di, dj in [[0, 1], [0, -1], [1, 0], [-1, 0]]: # 四个方向
            next_i, next_j = cur_i + di, cur_j + dj
            ans += self.dfs(grid, next_i, next_j) # 这个位置dfs
        return ans
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        ans = 0
        for i, l in enumerate(grid):
            for j, n in enumerate(l): # i,j 遍历每一个位置,在每个位置dfs搜索最大面积
                ans = max(self.dfs(grid, i, j), ans)
        return ans
s=Solution()
print(s.maxAreaOfIsland([[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]))
```

岛屿的最大面积 数据结构与算法 DFS搜索

[https://blog.csdn.net/darkrabbit/article/details/89409548](https://blog.csdn.net/darkrabbit/article/details/89409548)






（1） 出栈序列共有多少种可能？

（2） 求出所有出栈（入栈）序列。

（3） 给出一个出栈序列，问栈的容量最少需要多少？

（4） 给出一个（或多个）出栈序列，问此序列是不是（哪一个序列不是）原序列混洗得到的？


![在这里插入图片描述](/static/img/images/00970.png)

python

题目描述

给定一个正整数N代表火车数量，0<N<10，接下来输入火车入站的序列，一共N辆火车，每辆火车以数字1-9编号，火车站只有一个方向进出，同时停靠在火车站的列车中，只有后进站的出站了，先进站的才能出站。

要求输出所有火车出站的方案，以字典序排序输出。
```python
while True:
    try:
        n = int(input())
        trains = [  str(1+i)  for i in range(n)]
        res = []
        def rec_trains(cur_idx, in_trains, out_trains):
            # 如果原始火车列表的最后一个元素已经进站，此时只能出站，将入站列表中的火车倒序加入出站火车中
            if trains[-1] in in_trains:
                res.append(' '.join(out_trains + in_trains[::-1]))
                return
            # 如果进站列表为空，此时只能进站，进站列表加上当前火车，出站列表不变
            elif in_trains == []:
                rec_trains(cur_idx + 1, in_trains + [trains[cur_idx]], out_trains)
            # 否则，就既有可能进站也有可能出站
            else:
                # 出站，当前火车索引不变，进站火车列表减去最后一个元素，出站列表加上进站列表刚刚出站的火车
                rec_trains(cur_idx, in_trains[:-1], out_trains + [in_trains[-1]])
                # 进站，当前火车索引加1，进站列表加上当前火车，出站列表不变
                rec_trains(cur_idx + 1, in_trains + [trains[cur_idx]], out_trains)
        rec_trains(0, [], [])
        res.sort()
        print(len(res))
    except:
        break
```

数据结构 栈混洗 个数 Stack Shuffling 卡特兰数

![在这里插入图片描述](/static/img/images/01120.png)





前序[0, 1, 3, 4, 2]

```python
# Definition for a binary tree node.
from typing import List
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def dfs(root):
            if not root:
                return
            res.append(root.val)
            dfs(root.left)
            dfs(root.right)
        dfs(root)
        return res
root = TreeNode(0)
lc = TreeNode(1)
rc = TreeNode(2)
lc_lc = TreeNode(3)
lc_rc = TreeNode(4)
root.left = lc
root.right = rc
lc.left=lc_lc
lc.right=lc_rc
print(Solution().inorderTraversal(root))
```

中序  [3, 1, 4, 0, 2]

```python
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
```

后序  [3, 4, 1, 2, 0]

```python
            dfs(root.left)
            dfs(root.right)
            res.append(root.val)
```