链表和二叉树

链表

概念

链表 [Linked List]：链表是由一组不必相连（不必相连：可以连续也可以不连续）的内
存结构（节点），按特定的顺序链接在一起的抽象数据类型。

单链表

概念

单链表 [Linked List]：由各个内存结构通过一个 Next 指针链接在一起组成，每一个内
存结构都存在后继内存结构(链尾除外），内存结构由数据域和 Next 指针域组成

代码

创建了一个节点类一个链表类
节点类由指向下一个对象的next指针和包含数据的data组成
链表类包含单链表的增删改查一系列的方法

public class LinkCode {

    private LinkCode next = null;
    private int data;

    public LinkCode() {
    }

    public LinkCode(int data) {
        this.data = data;
    }

    public LinkCode(LinkCode next, int data) {
        this.next = next;
        this.data = data;
    }

    public LinkCode getNext() {
        return next;
    }

    public void setNext(LinkCode next) {
        this.next = next;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }
}

public class LinkList {

public LinkCode first = null;
public LinkList() {

}
public int lengthList(){
    /**
    * @Description 获取链表的长度
    * @param
    * @Return int
    * @Auther 
    * @Date Created in 2020/7/26 10:41
    **/

    int length = 0;
    LinkCode code;
    code = first;
    while (code != null){
        code = code.getNext();
        length++;
    }
    return length;
}
public void addFirst(int data){
    /**
    * @Description 头部插入
    * @param
    * @Return void
    * @Auther 
    * @Date Created in 2020/7/26 10:20
    **/
    LinkCode code = new LinkCode(data);
    code.setNext(first);
    first = code;
}
public void delList(int index){
    /**
    * @Description 删除指定下标
    * @param index
    * @Return void
    * @Auther 
    * @Date Created in 2020/7/26 15:07
    **/
    if(index < 1||index>lengthList()){
        System.out.println("输入下标小于0或大于链表长度");
    }
    else if(index == 1){
        first = first.getNext();
    }
    else{
        LinkCode precode = first;
        LinkCode code = first.getNext();
        int i = 2;
        while(code != null){
            if(i == index){
                precode.setNext(code.getNext());
                return;
            }
            precode = precode.getNext();
            code = code.getNext();
            i++;
        }
    }

}
public void printList(){
    /**
    * @Description 遍历输出
    * @param
    * @Return void
    * @Auther 
    * @Date Created in 2020/7/26 10:55
    **/

    LinkCode code;
    code = first;
    while (code != null){
        System.out.print(code.getData()+" ");
        code = code.getNext();
    }
    System.out.println();
}
public void addList(int index,int data){
    /**
    * @Description 指定位置添加数据
    * @param index
    * @param data
    * @Return void
    * @Auther 
    * @Date Created in 2020/7/26 15:23
    **/

    if(index < 1||index>lengthList()){
        System.out.println("输入下标小于0或大于链表长度");
    }
    if(index == 1){
        addFirst(data);
    }
    LinkCode precode = first;
    LinkCode code = first.getNext();
    LinkCode newcode = new LinkCode(data);
    int i = 2;
    while(code != null){
        if(i == index){
            precode.setNext(newcode);
            newcode.setNext(code);
        }
        precode = precode.getNext();
        code = code.getNext();
        i++;
    }
}
public void getData(int index){
    if(index < 1||index>lengthList()){
        System.out.println("输入下标小于0或大于链表长度");
    }
    if(index == 1){
        System.out.println("要查找的是链表头部的数据,数据为:"+first.getData());
    }
    LinkCode precode = first;
    LinkCode code = first.getNext();
    int i = 2;
    while(code != null){
        if(i == index){
            System.out.println("下标为:"+i+"的数据为:"+code.getData());
            return;
        }
        precode = precode.getNext();
        code = code.getNext();
        i++;
    }
}

}

public class MainTest {
    public static void main(String[] args) {
        LinkList l = new LinkList();
        // 增
        // 头部添加
        l.addFirst(1);
        l.addFirst(2);
        l.addFirst(3);
        System.out.println("原链表");
        l.printList();
        //指定下标添加
        l.addList(2,2);
        l.addList(3,3);
        //输出
        System.out.println("添加后链表");
        l.printList();
        //删
        l.delList(2);
        //输出
        System.out.println("删除后链表");
        l.printList();
        //查
        l.getData(2);

    }
}

二叉树

代码

二叉树的增，删，查

public class binTree {
    binCode root = null;
    public boolean addTree(int data){
        binCode code = new binCode();
        code.setData(data);
        /**
        * @Description  插入
        * @param
        * @Return void
        * @Auther 徐建
        * @Date Created in 2020/7/26 16:10
        **/
        if(root == null){
            root = code;
            root.setData(data);
            return true;
        }
        binCode current = root;
        binCode parent = null;

        while (current != null){
            parent = current;
            // 当前值大
            if(current.getData()>data){
                current = current.getLeftcode();
                if (current == null){
                    parent.setLeftcode(code);
                    return true;
                }
            }
            else{
                //当前值小
                current = current.getRightcode();
                if (current == null){
                    parent.setRightcode(code);
                    return true;
                }
            }

        }
        return false;
    }
    public binCode find(int data){
        /**
        * @Description  查
        * @param data
        * @Return void
        * @Auther 徐建
        * @Date Created in 2020/7/26 16:33
        **/
        binCode current = root;
        while (current != null){
            if (current.getData()>data){
                current = current.getLeftcode();
            } else if (current.getData()<data){
                current = current.getRightcode();
            }else{
                return current;// 返回对象
            }
        }
        return null;
    }
    public boolean delTree(int data){
        /**
        * @Description  删除指定数据(删除下标原理相同）
        * @param data
        * @Return boolean
        * @Auther 徐建
        * @Date Created in 2020/7/26 21:34
        **/

        binCode current = root;
        binCode parent = null;
        while (current != null){
            if (current.getData()>data){
                parent = current;
                current = current.getLeftcode();
            } else if (current.getData()<data){
                parent = current;
                current = current.getRightcode();
            }else{
                // 判断有几个分支
                // 叶子结点，没有分支
                if(current.getLeftcode() == null&&current.getRightcode() == null){
                    if(isLeft(current,parent)){
                        parent.setLeftcode(null);
                        return true;
                    }else{
                        parent.setRightcode(null);
                        return true;
                    }
                }else if ((current.getLeftcode() != null&&current.getRightcode() == null)){
                    //有一个分支，左节点
                    if(isLeft(current,parent)){
                        parent.setLeftcode(current.getLeftcode());
                        return true;
                    }else{
                        parent.setRightcode(current.getLeftcode());
                        return true;
                    }
                }else if ((current.getLeftcode() == null&&current.getRightcode() != null)){
                    //有一个分支，右节点
                    if(isLeft(current,parent)){
                        parent.setLeftcode(current.getRightcode());
                        return true;
                    }else{
                        parent.setRightcode(current.getRightcode());
                        return true;
                    }
                }else{
                    // 有两个分支
                    if(isLeft(current,parent)){
                        // 找比当前结点大的最小值
                        delTree(minCode(current));
                        current.setData(minCode(current));
                        return true;
                    }else{
                        // 找比当前结点小的最大值
                        delTree(maxCode(current));
                        current.setData(maxCode(current));
                        return true;
                    }

                }
            }
        }
        return false;
    }
    public boolean isLeft(binCode A,binCode B){
        /**
        * @Description 判断A是不是B的左子树
        * @param
        * @Return boolean
        * @Auther 徐建
        * @Date Created in 2020/7/26 17:38
        **/
        if(A == B.getLeftcode()){
            return true;
        }else{
            return false;
        }
    }
    public int minCode(binCode begin){
        /**
        * @Description 找从当前结点下，比当前结点data大的最小值
        * @param begin
        * @Return int
        * @Auther 徐建
        * @Date Created in 2020/7/26 21:35
        **/

        binCode current = begin.getRightcode();
        int min = 10000;
        while (current != null){
            if (current.getData()<min){
                min = current.getData();
                current = current.getLeftcode();
            }
        }
        return min;
    }
    public int maxCode(binCode begin){
        /**
        * @Description 找当前节点下，比当前结点小的最大值
        * @param begin
        * @Return int
        * @Auther 徐建
        * @Date Created in 2020/7/26 21:36
        **/

        binCode current = begin.getRightcode();
        int max= -1;
        while (current != null){
            if (current.getData() > max){
                max= current.getData();
                current = current.getRightcode();
            }
        }
        return max;
    }
    public void traversePreOrder(binCode root) {
        /**
        * @Description 遍历 先结点，再左，再右
        * @param root
        * @Return void
        * @Auther 徐建
        * @Date Created in 2020/7/26 21:38
        **/

        if (root != null) {
            System.out.println(root.getData());
            traversePreOrder(root.getLeftcode());
            traversePreOrder(root.getRightcode());
        }
    }
    public void traverseInOrder(binCode root) {
        /**
        * @Description 遍历 先左，再结点，再右
        * @param root
        * @Return void
        * @Auther 徐建
        * @Date Created in 2020/7/26 21:38
        **/

        if (root != null) {
            traverseInOrder(root.getLeftcode());
            System.out.print(root.getData()+" ");
            traverseInOrder(root.getRightcode());
        }
    }
}

难点

分析二叉树删除的几种不同的情况，比如左右子树都存在的情况下，需要找寻符合条件的值来替换当前位置的值，并将符合条件的对象置空值。