【java学习之路】（数据结构篇）004.递归和二叉搜索树

递归

递归的概念

递归的方式求1-100的和

public class DGDemo {
    public static int sum(int n){
        //递归到底的情况
        if(n==1){
            return 1;
        }
        return n+sum(n-1);
    }
    
    public static void main(String[] args) {
        System.out.println("1+2+3+...+100="+sum(100));//5050
    }
}

递归的方式删除链表

//使用递归的方式删除链表
public Node removeDG(T val){
    if(this.isEmpty()){
        return null;
    }
    removeDG(head,val);
}

//递归函数
private Node removeDG(Node head, T val) {
    //递归到底的情况
    if(head==null){
        return null;
    }
    //递归操作
    Node eNode = head;
    Node newHead = head.next;
    if(eNode.val==val){
        return newHead;
    }else {
        eNode.next = removeDG(newHead,val);
        return eNode;
    }

练习（剑指offer022）

代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        if(head == null){
            return null;
        }
        int n=0;
        ListNode curNode = head;
        while (curNode!=null){
            n++;
            curNode = curNode.next;
        }
        int index = n-k;
        if(index<0){
            return null;
        }

        curNode = head;
        for(int i=0;i<index;i++){
            curNode = curNode.next;
        }
        return curNode;
    }
}

通过截图

二分搜索树

为什么要有树结构

• 树结构本身是一种天然的组织结构
• 高效

二分搜索树的基础

二叉搜索树各种功能实现

package subject.lesson04;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * 二分搜索树
 */
public class BinarySearch<T extends Comparable<T>> {

    //定义节点的结构
    class Node{
        T val;
        Node left;
        Node right;

        public Node(T val){
            this.val = val;
            this.left = this.right = null;
        }
    }

    //定义根节点
    private Node root;

    public BinarySearch(){
        this.root = null;
    }

    //判断树是否为空
    public boolean isEmpty(){
        return this.root == null;
    }

    //向树中添加节点
    public void add(T ele){
        //使用递归的方式添加节点
        root = add(root,ele);
    }

    private Node add(Node root, T ele) {
        //递归到底
        if(root == null){
            Node node = new Node(ele);
            return node;
        }
        //递归操作
        if(ele.compareTo(root.val)>0){
            root.right = add(root.right,ele);
        }else {
            root.left = add(root.left, ele);
        }
        return root;
    }

    //从树中查找节点
    public Node contains(T ele){
        return contains(root,ele);
    }

    private Node contains(Node root, T ele) {
        //递归到底
        if(root==null){
            return null;
        }
        //递归操作
        T val = root.val;
        if(ele.compareTo(val)==0){
            return root;
        }else if(ele.compareTo(val)>0){
            return contains(root.right,ele);
        }else {
            return contains(root.left,ele);
        }
    }

    //中序遍历
    public List<T> middleOrder(){
        List<T> result = new ArrayList<>();
        middleOrder(root,result);
        return result;
    }

    private void middleOrder(Node root, List<T> result) {
        //递归到底
        if(root==null){
            return;
        }
        //递归方法
        middleOrder(root.left,result);
        result.add(root.val);
        middleOrder(root.right,result);
    }

    //前序遍历
    public List<T> preOrder(){
        List<T> result = new ArrayList<>();
        middleOrder(root,result);
        return result;
    }

    private void preOrder(Node root, List<T> result) {
        //递归到底
        if(root==null){
            return;
        }
        //递归方法
        result.add(root.val);
        middleOrder(root.left,result);
        middleOrder(root.right,result);
    }

    //后序遍历
    public List<T> subOrder(){
        List<T> result = new ArrayList<>();
        middleOrder(root,result);
        return result;
    }

    private void subOrder(Node root, List<T> result) {
        //递归到底
        if(root==null){
            return;
        }
        //递归方法
        middleOrder(root.left,result);
        middleOrder(root.right,result);
        result.add(root.val);
    }

    //层序遍历（广度优先）
    public List<T> laterOrder(){
        List<T> list = new ArrayList<>();
        if(root!=null){
            Queue<Node> queue = new LinkedList<>();
            queue.add(root);
            while (!queue.isEmpty()){
                //从队列中取出队首元素
                Node node = queue.poll();
                list.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
        }
        return list;
    }
    
    //查找最小节点
    public Node findMinNode(){
        if(root ==null){
            return null;
        }
        Node curNode = root;
        while (curNode.left!=null){
            curNode = curNode.left;
        }
        return curNode;
    }
}
return list;
    }
    
    //查找最小节点
    public Node findMinNode(){
        if(root ==null){
            return null;
        }
        Node curNode = root;
        while (curNode.left!=null){
            curNode = curNode.left;
        }
        return curNode;
    }
}