Java-链表与二叉数的基本概念

链表与二叉数

之前我们接触过的数据结构有数组和对象。

数组是变量的容器，数组在创建的时候就已经规定了大小。如果想要存储更多的数据我们就需要创建一个新的更大的数组，接着把旧数组的内容传递的到新数组，再加上需要存储的内容，最后把新数组赋值给旧数组(数组扩容思想)，这种扩容方式有很慢，且很浪费内存，效果很不好；同样当我们想要删除数组当中的数据，就得找到数组的数据以后，删除，再把后面的数组逐一前移，当数组的数据很多的时候效率就很低下。

java认为万物皆对象，我们想在里面存储什么东西就可以自己定制，存什么写什么类型的class。而链表和二叉树就是基于对象存储数的一种实现。

链表(LinkedList)

什么是链表？

1. 自行车链大家都见过，一个连接着一个，在链表当中每一个链就相当于一个对象，一个链连着一个链就相当于一个对象连着一个对象(一个对象尾部存储着下一个对象的地址)，这就组成了链表。
2. 链表是由一组不必相连（不必相连：可以连续也可以不连续）的内存结构（节点），按特定的顺序链接在一起的抽象数据类型(数学中抽象出来的一些操作的集合)。

数组和链表的区别和优缺点：

数组是一种连续存储线性结构，元素类型相同，大小相等

**数组的优点：**存取速度快

数组的缺点：

1. 事先必须知道数组的长度
2. 插入删除元素很慢
3. 空间通常是有限制的
4. 需要大块连续的内存块
5. 插入删除元素的效率很低

链表是离散存储线性结构

n 个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。

链表优点： 空间没有限制、插入删除元素很快(断开链接以后很快被GC回收)

链表缺点： 存取速度很慢

链表的分类

链表共分为3类

**链表共分为：**单向链表、双向链表和循环链表，循环链表有分为单向循环链表和双向循环链表

下面是链表的一种实现方式(Node是结点)：

链表代码演示：
链表创建部分：

package com.test.fourThree.task;
/**
 * 单向链表
 * 1.   可以进行add，delete操作
 * 2.   创建一个节点->add->delete->printList
 */
public class Demo1 {
    //链表头结点，作为链表的第一个节点,一开始为空
    private Node head = null;

    /**
     * 节点创建
     * data表示节点的值，next是指向下一个节点的引用
     */
    public class Node {
        //属性，规定为int类型,即数据
        private int data;
        //当前节点链接的下一个节点,一开始为空
        Node next = null;

        //有参构造方法
        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 创建addNode方法，向链表中插入数据。传入一个需要添加的String数据
     * 1.   传入一个需要存储的数据。同时判断链表长度是否为0，为0则头节点等于刚刚创建的节点；不为0则创建新节点。
     *
     * @param data
     */
    public void addNode(int data) {
        //实例化一个节点，创建Node的对象.同时把需要存储的数据进行存储
        Node newNode = new Node(data);
        if (head == null) {
            //说明此时链表为空,把头节点设置刚创建的节点
            head = newNode;
            //return结束方法
            return;
        }
        //创建一个对象复制一份head
        Node temp = head;
        while (temp.next != null){
            //下一个节点不为空，移动下到下一位再判断
            temp = temp.next;
        }
        //来到尾节点连接上一个新节点
        temp.next = newNode;
    }

    /**
     *  删除节点操作
     *  1.  传入一个需要删除节点的位置的int类型的数据。遍历查找
     * @param index 传入需要删除的位置
     * @return 判断删除操作是否成功
     */
    public boolean deleteNode(int index) {
        if(index<1 || index>length()){
            //需要删除的位置不在链表范围内
            return false;
        }
        if(index == 1){
            //因为这是单向链表，当需要删除的位置为第一个，直接使得头节点后移一个即可
            head = head.next;
            return true;
        }
        //创建两个Node对象备份目标节点之前一个和当前节点
        Node previousNode = head;
        Node currentNode = previousNode.next;
        for(int i=1;currentNode != null;i++){
            if(i == index){
                //找到需要查找的节点，把目标节点断开，GC进行回收
                previousNode.next = currentNode.next;
                return true;
            }
            //后移继续查找
            previousNode = currentNode;
            currentNode = currentNode.next;
        }
        //没有找到return false
        return false;
    }

    /**
     * 获取链表的长度
     * 1.   使用while循环，在里面进行不断后移查找null，得出长度
     * @return
     */
    public int length() {
        int lenth = 0;
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
            lenth++;
        }
        return lenth;
    }

    /**
     * 遍历打印链表数据
     */
    public void printList(){
        Node temp = head;
        while (temp != null){
            System.out.println(temp.data);
            temp = temp.next;
        }
    }
}

main函数部分：

package com.test.fourThree.task;

public class Main {
    public static void main(String[] args) {
        Demo1 list = newtest Demo1();
        //添加数据
        list.addNode(0);
        list.addNode(1);
        list.addNode(2);
        list.addNode(3);
        list.addNode(4);
        list.addNode(5);
        list.addNode(6);
        //打印链表长度
        System.out.println("LinkLength:"+list.length());
        System.out.println("---------------------");
        //遍历链表
        list.printList();
        System.out.println("---------------------");
        //删除下标为4的链表数据
        System.out.println(list.deleteNode(4));
        //遍历链表查看
        list.printList();
    }
}

二叉树

什么是二叉树？

二叉树是树的一种，每个节点最多可具有两个子树，即结点的度最大为 2（结点度：结点拥有的子树数）

二叉树就是每个结点不能多于两个儿子，上面的图就是一颗二叉树，而且还是一种特殊的二叉树–二叉查找树

**定义：**当前根节点的左边全部比根节点小，当前根节点的右边全部比根节点大。

可以看出，这对我们来找一个数是非常方便快捷的，一棵树至少会有一个节点(根节点)，树由节点组成

因此，我们定义树的时候往往是**->定义节点->节点连接起来就成了树**，而节点的定义就是：一个数据、两个指针(如果有节点就指向节点、没有节点就指向 null)

二叉树的种类

斜树

满二叉树

所有的分支节点都具有左右节点

完全二叉树

若设二叉树的深度为 h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h
层所有的结点都连续集中在最左边，这就是完全二叉树。

二叉树的一些性质

1. 二叉树第 i 层上的结点数目最多为 2^(i-1) (i≥1)
2. 深度为 h 的二叉树至多有 2^h-1 个结点(h≥1)
3. 包含 n 个结点的二叉树的高度至少为 log2 (n+1)
4. 在任意一棵二叉树中，若终端结点的个数为 n0，度为 2 的结点数为 n2，则 n0=n2+1

二叉树的遍历方式

二叉树的遍历方式，一般分为先序遍历，中序遍历，后序遍历。
• 先序遍历

​ 先访问根节点，然后访问左节点，最后访问右节点(根->左->右)
• 中序遍历

​ 先访问左节点，然后访问根节点，最后访问右节点(左->根->右)
• 后序遍历

​ 先访问左节点，然后访问右节点，最后访问根节点(左->右->根)

如下：

先序遍历(根-左-右):1-2-4-8-9-5-10-3-6-7
中序遍历:(左-根-右):8-4-9-2-10-5-1-6-3-7