java链表与二叉树

1. 链表

1) 基本特征：内存中不连续的节点序列，节点之间通过next指针彼此相连；

                         每个节点的next指针都指向下一个节点，最后一个节点的next指针为NULL。

2) 基本操作：插入、删除、遍历。

3) 实现要点

追加：将新分配节点的地址赋给原链表最后一个节点的next指针。

插入：将前节点中存储的后节点地址赋给新节点的next指针，将新节点的地址赋给前节点的next指针。

删除：将前节点的next指针赋值为待删除节点的next指针。对于单向链表而言，寻找前节点会有一定开销。

遍历：沿着next指针依次访问链表中的各个节点。

伪随机访问：遍历+计数。

（1）单向链表

       只能向后走

（2）双向链表

        既可以向前走，又可以向后走。

public class Node {

     protected Node next; //指针域

     protected int data;//数据域

     public Node( int data) {

           this. data = data;

     }

     //显示此节点

     public void display() {

          System. out.print( data + " ");

     }

}

package com.tyxh.link;

//单链表

public class LinkList {

     public Node first; // 定义一个头结点

     private int pos = 0;// 节点的位置

     public LinkList() {

           this. first = null;

     }

     // 插入一个头节点

     public void addFirstNode( int data) {

          Node node = new Node(data);

          node. next = first;

           first = node;

     }

     // 删除一个头结点,并返回头结点

     public Node deleteFirstNode() {

          Node tempNode = first;

           first = tempNode. next;

           return tempNode;

     }

     // 在任意位置插入节点 在index的后面插入

     public void add(int index, int data) {

          Node node = new Node(data);

          Node current = first;

          Node previous = first;

           while ( pos != index) {

              previous = current;

              current = current. next;

               pos++;

          }

          node. next = current;

          previous. next = node;

           pos = 0;

     }

     // 删除任意位置的节点

     public Node deleteByPos( int index) {

          Node current = first;

          Node previous = first;

           while ( pos != index) {

               pos++;

              previous = current;

              current = current. next;

          }

           if(current == first) {

               first = first. next;

          } else {

               pos = 0;

              previous. next = current. next;

          }

           return current;

     }

2.树

如果单向线性链表里，每个节点可以向后找到多个其他节点，这也是一个数据结构，这个数据结构叫树

        可以把树里的所有节点分成几层，不同层之间有方向，这些方向都是一致的

树最上面一层应该只有一个节点，这个节点叫做根节点

        根节点可以代表整棵树

        树里存在直接联系的两个节点之间有父子关系，靠近根节点的是父节点，远离根节点的是子节点

        任何节点最多只能有一个父节点（根节点没有父节点）

        如果一个树里任何节点最多只能有两个子节点，这种树叫做二叉树

        二叉树是最简单的树

        二叉树里用左右区分任何一个节点的两个子节点

        二叉树里任何一个节点和他下面的所有节点都可以看作的是一个新的二叉树

        节点A的左子节点代表的树叫做节点A的左子树，右子节点代表的树叫做右子树。

        树中的大多数操作都是通过遍历来实现的，树的遍历大多都是通过递归来实现的。（问题能分解，分解后的小问题可以用该方法解决，一般采用递归）

        在遍历树的时候左子树一定在右子树前被处理，一共有三种方式遍历树：

                （1）最开始处理根节点的遍历方式，叫做前序遍历         处理节点自己的数据->处理左节点->处理右节点。

                （2）中间处理根节点的遍历方式，叫做中序遍历             处理左节点->处理节点自己的数据->处理右节点。

                （3）最后处理根节点的遍历方式，叫做后序遍历             处理左节点->处理右节点->处理节点自己的数据。

public class BinaryTree {

private TreeNode root=null;

public BinaryTree(){

root=new TreeNode(1,"rootNode(A)");

}

//树的高度

public int height(){

return height(root);

}

//节点个数

public int size(){

return size(root);

}

//前序遍历

public void preOrder(TreeNode subTree){

if(subTree!=null){

visted(subTree);

preOrder(subTree.leftChild);

preOrder(subTree.rightChild);

}

}

//中序遍历

public void inOrder(TreeNode subTree){

if(subTree!=null){

inOrder(subTree.leftChild);

visted(subTree);

inOrder(subTree.rightChild);

}

}

//后续遍历

public void postOrder(TreeNode subTree) {

if (subTree != null) {

postOrder(subTree.leftChild);

            postOrder(subTree.rightChild);

            visted(subTree);

        }