2022-08-05 第五组张明敏学习笔记

1.在二叉树中第i层上最多有2^（i-1）个结点(i>=1)

2.二叉树中如果深度为，那么最多有2k-1个结点。

3.ne=n2+1，ne表示度数为0的结点，n2表示度数为2的结点数

4.在完全二叉树中，具有n个结点的完全二叉树的深度为[Log2n] +1,
其中[ Log2n]是向下取整

5.若对含n个结点的完全二叉树从上到下且从左到右进行1至n的编号，
则对完全二叉树中任意一个编号为i的结点有如下特性:
(1）若i=1，则该结点是二叉树的根，无父节点，否则，编号为i/2的结点为其父节点

(2）若2i>n，则该结点无左孩子结点，否则，编号为2i的结点为其左孩子结点

(3）若2i+1>n，则该结点无右孩子结点，否则，编号为2i+1的结点为右孩子结点

3. 斜树:

所有的结点都只有左子树的二叉树叫做左斜树。所有结点都是只有右子树的二叉树叫右斜树。

4. 满二叉树:

在一颗二叉树中，如果所有分支结点都存在左子树和右子树，并且所有的叶子都在同一层上，这样的二叉树叫满二叉树。

满二叉树的特点:

1.叶子只能出现在下一层。
2.非叶子结点的度一定是2
3.在同样深度的二叉树中，满二叉树的结点个数最多，叶子数也最多。

5. 完全二叉树：

对一颗具有n个结点的二叉树按层编号，如果编号为i.(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点, 这颗二叉树就称为完全二叉树。

6. 二叉树的存储结构:

1.顺序存储

使用一维数组存储二叉树中的结点，并且结点的存储位置，就是数组的下标索引。

当二叉树为完全二叉树时，结点数刚好填满数组。
如果二叉树不是完全二叉树，采用顺序存储，顺序存储结构中已经出现了空间浪费的情况。比如右斜树极端情况，采用顺序存储的方式是十分浪费空间。
顺序存储只适用于完全二叉树。

2.二叉链表

顺序存储不能满足二叉树的存储要求，采用链式存储。
二叉树的每个结点都有两个孩子。
可以将结点数据结构定义成一个数据和两个指针域。

3. 二叉树遍历:重点考察

二叉树的遍历从根节点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次。
二叉树的访问次序可以分为四种:
递归遍历：自上而下，从左到右，每个结点会走三次。

前序遍历：
     从二叉树的根结点出发，按照先向左再向右的方向访问。（根左右)
后序遍历：
     从二叉树的根结点出发，先向左再向右的方向访问。(左右根)
中序遍历：
     从二叉树的根结点出发，按照先向左再向右访问。(左根右)
层次遍历：
     按照树的层次自上而下的遍历二叉树。ABCDEFGHI

class TreeNode<T>{
    T data; //数据本身
    TreeNode lift;
    TreeNode right;

    public TreeNode(T data){
        this.data=data;

    }

    //前序遍历，先序遍历
    //root 结点
    public static void preorder(TreeNode root){
        if (root==null){
            return;
        }
        System.out.print(root.data);
        //递归，自己调自己

        preorder(root.lift);
        preorder(root.right);
    }

    //中序遍历
    public static void inorder(TreeNode root){
        if (root==null){
            return;
        }
        inorder(root.lift);
        System.out.print(root.data);
        inorder(root.right);
    }

    public static void postorder(TreeNode root){
        if (root==null){
            return;
        }
        preorder(root.lift);
        preorder(root.right);
        System.out.print(root.data);
    }
}

public class Ch01 {
    public static void main(String[] args) {
        TreeNode<Integer>root=new TreeNode<>(1);
        root.lift=new TreeNode( 2);
        root.right = new TreeNode(  3);
        root.lift.lift = new TreeNode(  4);
        root.lift.right = new TreeNode(  5);
        root.right.lift = new TreeNode(  6);
        root.right.right = new TreeNode(  7);

        //前序遍历
        System.out.println("----------前序遍历--------------");
        TreeNode.preorder(root);
        System.out.println( "----------中序遍历--------------");
        TreeNode.inorder(root);
        System.out.println( "-------- --后序遍历------------- ");
        TreeNode.postorder(root);

    }

}

7. 其他的数分类:

1.二叉查找树（二叉搜索树。二叉排序树)

(1）若左子树不为空，左子树的所有的值小于它的根节点的值
(2）若右子树不为空，右子树的所有的值大于它的根节点的值
(3）左右子树也是一个二叉查找树
(4）没有键值相等的点

2.平衡二叉树(AVL树)

含有形同结点的二叉树的不同形态，找出一个查找平均长度最小的一颗二叉查
(1）要么是一颗空树，要么其根结点的左右子树的深度之差的值不超过1
(2）左右子树也都是平衡二叉树
(3）二叉树结点的平衡因子定义为该结点的左子树的深度减去右子树的深度。
平衡因子=左子树的深度-右子树的深度-1 0 1

二、集合

集合框架（重要）

集合：容器，存放数据的一个容器

使用集合的目的：更方便的存储和操作数据，CURD。

集合继承结构

Collection<E>:存放单值的最大父接口

Map<K,v>

1.List集合

List集合的概述

有序集合,这里的有序指的是存取顺序，用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
与Set集合不同,列表通常允许重复的元素

List集合的特点

存取有序
可以重复
有索引

List集合的特有方法
void add (int index,E element) ：在此集合中的指定位置插入指定的元素
E remove(int index) ：删除指定索引处的元素，返回被删除的元素
E set (int index,E element) ：修改指定索引处的元素，返回被修改的元素
E get (int index) ：返回指定索引处的元素

ArrayList：内部结构是一个数组

底层是数组结构实现，查询快、增删慢

public static void main(String[] args) {
        //创建了一个ArrayList集合
        //开发中，一般情况下，使用多态创建集合
        //向上转型
        List<Integer> l1 = new ArrayList<>();
        //集合新增
        l1.add(1);
        l1.add(2);
        l1.add(3);
        l1.add(4);
        l1.add(5);
        l1.add(1, -1);

        List<Integer> l2 = new ArrayList<>();
        l2.add(1);
        l2.add(2);
        l2.add(3);
        l2.add(4);
        l2.add(5);
        l2.add(1, 100);
        l1.addAll(l2);//将l2添加到l1末尾

        //清空集合
        //请控制后，集合中没有数据size=0；
       l1.clear();
        //删除
        l1.remove(Integer.valueOf(100));
        //修改
        l1.set(0, 200);

        //直接打印集合对象
        System.out.println(l1);
       System.out.println(l1.contains(-3));
        System.out.println(l1.get(0));//0下标的元素
        System.out.println(l1.indexOf(1000));//对象第一次出现下表的位置
        System.out.println(l1.isEmpty());


        //集合和数组之间的转换
        //数组->集合
        int[] arr = new int[]{1, 2, 3, 4, 5};
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> integers1 = List.of(1, 23, 4, 5);
       List<int[]> arr1 = List.of(arr);
        System.out.println(arr1.get(0[0]));

        //数组和集合之间的转换
    }