决策树算法的主要思想源于Quinlan在1986年提出的ID3算法和1993年提出的C4.5算法，以及由Breiman等人在1984年提出的CART算法，其主要优点是：
- 可读性；
- 分类速度快。
决策树学习通常包括3个步骤：
- 特征选择；
- 决策树的生成；
- 决策树的修剪。
信息增益
为了说明信息增益算法，需要先给出熵entropy的定义，熵表示随机变量的不确定性的度量。设 X X X是一个取有限个值的离散随机变量，其概率分布为
P ( X = x i ) = p i , i = 1 , 2 , . . . , n P(X=x_i)=p_i, i=1,2,...,n P(X=xi)=pi,i=1,2,...,n
则随机变量 X X X的熵定义为
H ( x ) = − ∑ i = 1 n p i log p i H(x)=-\sum_{i=1}^{n}p_{i}\log p_i H(x)=−i=1∑npilogpi
特征 A A A对训练数据集 D D D的信息增益 g ( D , A ) g(D,A) g(D,A)，定义为集合 D D D的经验熵 H ( D ) H(D) H(D)与特征 A A A给定条件下 D D D的经验条件熵 H ( D ∣ A ) H(D|A) H(D∣A)之差，即
g ( D , A ) = H ( D ) − H ( D ∣ A ) g(D,A)=H(D)-H(D|A) g(D,A)=H(D)−H(D∣A)
根据信息增益准则的特征选择方法是：++对训练数据集（或子集） D D D，计算其每个特征的信息增益，并比较它们的大小，选择信息增益最大的特征++。
设训练数据集为 D D D， ∣ D ∣ \left | D \right | ∣D∣表示样本容量，即样本个数。设有 K K K个类 C k C_k Ck， k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K， ∣ C k ∣ \left | C_k \right | ∣Ck∣为属于类 C k C_k Ck的样本个数， ∑ k = 1 K ∣ C k ∣ = ∣ D ∣ \sum_{k=1}^{K}{\left | C_k \right | }={\left | D \right | } ∑k=1K∣Ck∣=∣D∣。
设特征 A A A有 n n n个不同的取值 { a 1 , a 2 , . . . , a n } \{a_1,a_2,...,a_n\} {a1,a2,...,an}，根据特征 A A A的取值将 D D D划分为 n n n个子集 D 1 , D 2 , . . . , D n D_1,D_2,...,D_n D1,D2,...,Dn， ∣ D i ∣ \left | D_i \right | ∣Di∣为 D i D_i Di的样本个数， ∑ i = 1 n ∣ D i ∣ = ∣ D ∣ \sum_{i=1}^{n}{\left | D_i \right | }={\left | D \right | } ∑i=1n∣Di∣=∣D∣。记子集 D i D_i Di中属于类 C k C_k Ck的样本的集合为 D i k D_{ik} Dik， D i k = D i ∩ C k D_{ik}=D_i\cap C_k Dik=Di∩Ck， ∣ D i k ∣ {\left | D_{ik} \right | } ∣Dik∣为 D i k D_{ik} Dik的样本个数。
算法：
输入：训练集 D D D和特征 A A A；
输出：特征 A A A对训练数据集 D D D的信息增益 g ( D , A ) g(D,A) g(D,A)。
- 计算数据集 D D D的经验熵 H ( D ) H(D) H(D)
H ( D ) = − ∑ k = 1 K ∣ C k ∣ ∣ D ∣ log 2 ∣ C k ∣ ∣ D ∣ H(D)=-\sum_{k=1}^{K}\frac {\left | C_k \right | }{\left | D \right | }\log_2 {\frac {\left | C_k \right | }{\left | D \right | }} H(D)=−k=1∑K∣D∣∣Ck∣log2∣D∣∣Ck∣- 计算特征 A A A对数据集 D D D的经验条件熵 H ( D ∣ A ) H(D|A) H(D∣A)
H ( D ∣ A ) = ∑ i = 1 n ∣ D i ∣ ∣ D ∣ H ( D i ) = − ∑ i = 1 n ∣ D i ∣ ∣ D ∣ ∑ k = 1 K ∣ D i k ∣ ∣ D i ∣ log 2 ∣ D i k ∣ ∣ D i ∣ H(D|A)=\sum_{i=1}^{n}\frac {\left | D_i \right | }{\left | D \right | }H(D_i)=-\sum_{i=1}^{n}\frac {\left | D_i \right | }{\left | D \right | }\sum_{k=1}^{K}\frac {\left | D_{ik} \right | }{\left | D_i \right | }\log_2{\frac{\left | D_{ik} \right | }{\left | D_i \right | }} H(D∣A)=i=1∑n∣D∣∣Di∣H(Di)=−i=1∑n∣D∣∣Di∣k=1∑K∣Di∣∣Dik∣log2∣Di∣∣Dik∣- 计算信息增益
g ( D , A ) = H ( D ) − H ( D ∣ A ) g(D,A)=H(D)-H(D|A) g(D,A)=H(D)−H(D∣A)
ID3算法
ID3算法的核心是在决策树各个结点上应用信息增益准则选择特征，递归地构建决策树。具体方法是：从根节点开始，对结点计算所有可能的特征的信息增益，选择信息增益最大的特征作为结点的特征，由该特征的不同取值建立子节点；再对子节点递归地调用以上方法，构建决策树；直到所有特征的信息增益均很小或没有特征可以选择为止。
算法：
输入：训练数据集 D D D，特征集 A A A，阈值 ε \varepsilon ε；
输出：决策树 T T T。
- 若 D D D中所有实例属于同一类 C k C_k Ck，则 T T T为单节点树，并将类 C k C_k Ck作为该结点的类标记，返回 T T T；
- 若 A = ∅ A=\emptyset A=∅，则 T T T为单节点树，并将 D D D中实例数最大的类 C k C_k Ck作为该结点的类标记，返回 T T T；
- 否则，计算 A A A中各特征对 D D D的信息增益，选择信息增益最大的特征 A g A_g Ag；
- 如果 A g A_g Ag的信息增益小于阈值 ε \varepsilon ε，则置 T T T为单结点树，并将 D D D中实例最大的类 C k C_k Ck作为该结点的类标记，返回 T T T；
- 否则，对 A g A_g Ag的每一可能值 a i a_i ai，依 A g = a i A_g=a_i Ag=ai将 D D D分割为若干非空子集 D i D_i Di，将 D i D_i Di中实例数最大的类作为标记，构建子节点，由结点及其子节点构成树 T T T，返回 T T T；
- 对第 i i i个子节点，以 D i D_i Di为训练集，以 A − { A g } A-\{A_g\} A−{Ag}为特征集，递归地调用步骤1~5，得到子树 T i T_i Ti，返回 T i T_i Ti。
C4.5算法
C 4.5 C4.5 C4.5算法与 I D 3 ID3 ID3算法相似， C 4.5 C4.5 C4.5对 I D 3 ID3 ID3进行了改进，在生成树的过程中，改用信息增益比来选择特征。
特征 A A A对训练数据集 D D D的信息增益比 g R ( D , A ) g_R(D,A) gR(D,A)定义为其信息增益 g ( D , A ) g(D,A) g(D,A)与训练数据集 D D D关于特征 A A A的值的熵 H A ( D ) H_A(D) HA(D)之比，即
g R ( D , A ) = g ( D , A ) H A ( D ) g_R(D,A)=\frac{g(D,A)}{H_A(D)} gR(D,A)=HA(D)g(D,A)
其中 n n n是特征 A A A取值的个数， H A ( D ) = − ∑ i = 1 n ∣ D i ∣ ∣ D ∣ log 2 ∣ D i ∣ ∣ D ∣ H_A(D)=-\sum_{i=1}^{n}\frac {\left | D_i \right | }{\left | D \right | }\log_2 {\frac {\left | D_i \right | }{\left | D \right | }} HA(D)=−∑i=1n∣D∣∣Di∣log2∣D∣∣Di∣。
算法：
输入：训练数据集 D D D，特征集 A A A，阈值 ε \varepsilon ε；
输出：决策树 T T T。
- 若 D D D中所有实例属于同一类 C k C_k Ck，则 T T T为单节点树，并将类 C k C_k Ck作为该结点的类标记，返回 T T T；
- 若 A = ∅ A=\emptyset A=∅，则 T T T为单节点树，并将 D D D中实例数最大的类 C k C_k Ck作为该结点的类标记，返回 T T T；
- 否则，计算 A A A中各特征对 D D D的信息增益比，选择信息增益比最大的特征 A g A_g Ag；
- 如果 A g A_g Ag的信息增益小于阈值 ε \varepsilon ε，则置 T T T为单结点树，并将 D D D中实例最大的类 C k C_k Ck作为该结点的类标记，返回 T T T；
- 否则，对 A g A_g Ag的每一可能值 a i a_i ai，依 A g = a i A_g=a_i Ag=ai将 D D D分割为若干非空子集 D i D_i Di，将 D i D_i Di中实例数最大的类作为标记，构建子节点，由结点及其子节点构成树 T T T，返回 T T T；
- 对第 i i i个子节点，以 D i D_i Di为训练集，以 A − { A g } A-\{A_g\} A−{Ag}为特征集，递归地调用步骤1~5，得到子树 T i T_i Ti，返回 T i T_i Ti。
剪枝
为解决决策树学习产生的过拟合现象，通常采用的办法是降低决策树的复杂度，对已生成的决策树进行简化，即剪枝(pruning)。剪枝从已生成的树上裁掉一些子树或叶节点，并将其根节点或父节点作为新的叶节点，从而简化分类树模型。
决策树的剪枝往往通过极小化决策树整体的损失函数或代价函数来实现。设树 T T T的叶节点个数为 ∣ T ∣ \left | T \right | ∣T∣， t t t是树 T T T的叶节点，该叶节点有 N t N_t Nt个样本点，其中 k k k类的样本点有 N t k N_{tk} Ntk个， k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K， H t ( T ) H_t(T) Ht(T)为叶节点 t t t上的经验熵， α ≥ 0 \alpha \ge0 α≥0为参数，则决策树学习的损失函数可以定义为
C α ( T ) = ∑ t = 1 ∣ T ∣ N t H t ( T ) + α ∣ T ∣ C_{\alpha}(T)=\sum_{t=1}^{\left | T \right |}N_tH_t(T)+\alpha{\left | T \right |} Cα(T)=t=1∑∣T∣NtHt(T)+α∣T∣
其中经验熵为
H t ( T ) = − ∑ k ∣ N t k ∣ ∣ N t ∣ log ∣ N t k ∣ ∣ N t ∣ H_t(T)=-\sum_{k}\frac {\left | N_{tk} \right | }{\left | N_t \right | }\log {\frac {\left | N_{tk} \right | }{\left | N_t \right | }} Ht(T)=−k∑∣Nt∣∣Ntk∣log∣Nt∣∣Ntk∣
算法：
输入：生成算法产生的整个树 T T T，参数 α \alpha α；
输出：修剪后的子树 T α T_{\alpha} Tα；
- 计算每个结点的经验熵；
- 递归地从树的叶节点向上回缩。设一组叶节点回缩到父节点之前与之后的整体树分别为 T B T_B TB和 T A T_A TA，其对应的损失函数值分别为 C α ( T B ) C_{\alpha}(T_B) Cα(TB)与 C α ( T A ) C_{\alpha}(T_A) Cα(TA)，如果 C α ( T A ) ≤ C α ( T B ) C_{\alpha}(T_A)\le C_{\alpha}(T_B) Cα(TA)≤Cα(TB)，则进行剪枝，将父节点变为新的叶节点。
- 返回2，直至不能继续为止，得到损失函数最小的子树 T α T_{\alpha} Tα。