Java数据结构习题：(该程序用递归实现)编写一个RecursionMax（)，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）

(该程序用递归实现)编写一个RecursionMax（)，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）

核心代码：

  // (该程序用递归实现)编写一个RecursionMax（)，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）
  int n = 0;
  int Max = 0;

  public int RecursionMax(NODE first) {
    if (n == 0) {
      Max = (int) first.obj;
    }

    if (first == null) {
      System.out.println("链表为空");
      return 0;
    }

    if (Max < (int) first.obj) {
      Max = (int) first.obj;
    }
	
	//递归开始！！！！！！！！！！！
    n++;
    if (n < N) {
      RecursionMax(first.next);
    }

    return Max;
  }

总体代码：

// 编写一个max（），接受首节点作为参数，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）
import java.util.*;

public class Node {
  // 链表指针
  private NODE first = null;

  public NODE getFirst() {
    return first;
  }

  private NODE lase = null;

  public NODE getLase() {
    return lase;
  }

  // 计数器
  private int N = 0;

  public int getN() {
    return N;
  }
  // 结点
  private class NODE {
    Object obj;
    NODE next;
  }

  // 判断链表是否为空
  public Boolean IsEmpty() {
    return first == null;
  }

  // 添加节点
  public void EnNode(Object obj) {
    NODE oldNode = lase;
    lase = new NODE();
    lase.obj = obj;
    lase.next = null;

    if (IsEmpty()) {
      first = lase;
      oldNode = lase;
    }

    oldNode.next = lase;
    N++;
  }
  // 接受一个链表结点并插入到指定结点的后面
  public void insertAfter(NODE node1, NODE node2) {

    if (node1 == null || node2 == null) {
      System.out.println("插入失败");
      return;
    }

    node2.next = node1.next.next;
    node1.next = node2;
  }

  // 编写一个EnNodeFirstNext（），接受首节点作为参数，将第二个结点插入链表并使之成为第一个结点的后续结点（如果参数为空则什么也不做）
  public void EnNodeFirstNext(NODE first) {
    if (first == null || this.first == null) {
      System.out.println("结点为空，无法插入");
      return;
    }

    first.next.next = this.first.next;
    this.first.next = first.next;

    N++;
  }

  // 删除节点
  public Object delete(int k) {
    if (k < 0 || k > N) {
      System.out.println("k的范围不符合规定");
      return "";
    }

    NODE Node = first;
    Object obj = null;

    for (int i = 1; i < k - 1; i++) {
      Node = Node.next;
    }

    obj = Node.next.obj;
    Node.next = Node.next.next;

    N--;

    return "删除的元素是：" + obj;
  }
  // 接受一个链表结点并接受另一个结点作为后续结点，并删除原后续结点
  public Object removeAfter(NODE Top_Node) {

    if (Top_Node == null || Top_Node.next == null) {
      return "空";
    }

    Object Deter_Obj = Top_Node.next.obj;
    Top_Node.next = Top_Node.next.next;

    N--;

    return Deter_Obj;
  }
  // 获取指定结点
  public NODE Get_Node(int Key) {
    if (Key < 0 || Key > N) {
      System.out.println("指定位置不存在");
      return null;
    }

    NODE node = first;

    for (int i = 0; i < Key - 1; i++) {
      node = node.next;
    }

    return node;
  }

  int k = 0;
  NODE Node_Text = null;
  // 接受一条链表和一个字符串key作为参数，删除链表中所有item域为key的结点
  public void remove(Object obj) {
    if (N <= 0) {
      return;
    }

    NODE node = first;

    for (int i = 1; i < N; i++) {
      // 数值相匹
      while (node.next.obj == obj) {
        node.next = node.next.next;
        N--;
      }

      node = node.next;
      k++;
    }

    node = first;
    if (node.obj == obj) {
      first = node.next;
      N--;
    }
  }

  // 查寻
  public boolean find(Object KEY) {
    NODE node = first;

    if (N <= 0) {
      return false;
    }

    for (int i = 0; i < N; i++) {
      if (node.obj.equals(KEY)) {
        return true;
      }

      node = node.next;
    }

    return false;
  }

  // 编写一个max（），接受首节点作为参数，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）
  public int max(NODE first) {
    if (null == first) {
      return 0;
    }

    NODE node = first;
    int max = (int) node.obj;
    node = node.next;

    for (int i = 0; i < N - 1; i++) {
      if (max < (int) node.obj) {
        max = (int) node.obj;
      }

      node = node.next;
    }

    return max;
  }

  // (该程序用递归实现)编写一个RecursionMax（)，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）
  int n = 0;
  int Max = 0;

  public int RecursionMax(NODE first) {
    if (n == 0) {
      Max = (int) first.obj;
    }

    if (first == null) {
      System.out.println("链表为空");
      return 0;
    }

    if (Max < (int) first.obj) {
      Max = (int) first.obj;
    }

    n++;
    if (n < N) {
      RecursionMax(first.next);
    }

    return Max;
  }

  // 遍历
  public void print() {
    if (N <= 0) {
      System.out.println("链表已为空，无法删除");
      return;
    }

    NODE node = first;

    for (int i = 0; i < N; i++) {
      System.out.println("元素：" + node.obj);
      node = node.next;
    }

    System.out.println();
  }
}

测试代码：

import java.util.*;

public class Main {
  public static void main(String[] args) {
    Node node = new Node();

    node.EnNode(5);
    node.EnNode(2);
    node.EnNode(3);
    node.EnNode(1);
    node.EnNode(10);
    node.EnNode(8);

    node.print();

    System.out.println("Max = " + node.RecursionMax(node.getFirst()));
  }
}

生成：

元素：5
元素：2
元素：3
元素：1
元素：10
元素：8

Max = 10

[运行结束]

感谢观看~