使用索引递归地从 LinkedList 中删除 Odds

Question

我在使用递归概念时遇到了一点困难。

给定一个具有整数值的 LinkedList

L1 = (2->1->4->6->3)
L2=  (1->9->6->3)

该函数应该从链表中删除从整数 N 开始的奇数，并返回对新头的引用

即

L1.deleteOdd(2)  = >  (2->4->6)

L2.deleteOdd(1)  = >  (6)

我实现了一个正常的迭代函数来完成这项工作，就是这样

public node deleteOdd(int n) {

    node head = this.head;
    if (head == null)
        return head;
    while (head != null) {
        if (head.data == n) {
            node head2 = head;
            while (head2.next != null) {
                if (head2.next.data % 2 != 0) {
                    head2.next = head2.next.next;
                } else {
                    head2 = head2.next;
                }
            }
            if (head.data % 2 != 0) {
                return head.next;
            }
            return head;
        }
        head = head.next;

    }
    return head;
}

现在我正在尝试做一个递归函数，我尝试做一些事情，但似乎我错过了一些东西。

我的递归函数是

public node DeleteOddR(int n) {
    node head = this.head;

    if (head == null)
        return head;
    if (head != null) {
        if (head.data == n) {
            node head2 = head;
            if (head2.next.data % 2 != 0)

            {
                head2.next = head2.next.next;

            } else {

                head2 = head2.next;
            }

            if (head.data % 2 != 0) {
                return DeleteOddR(head.next.data);
            } else {
                head.next = DeleteOddR(head.next.data);
                return head;
            }

        } else {
            head = head.next;
        }

    }
    return head;
}

结果是

    node f = l1.DeleteOddR(2);
    display(f); // Gives-   >2->3->4->6

我会很感激帮助..

Answer 1

我写一个可能满足你的要求。
保存前一个节点并递归使用它。

public class LinkedList{

    public static void main(String[] args) {
    LinkedList node0 = new LinkedList(0);
    LinkedList node1 = new LinkedList(1);
    LinkedList node2 = new LinkedList(2);
    LinkedList node3 = new LinkedList(3);
    LinkedList node4 = new LinkedList(4);
    LinkedList node5 = new LinkedList(5);
    LinkedList node6 = new LinkedList(6);
    LinkedList node7 = new LinkedList(7);
    LinkedList node8 = new LinkedList(8);
    node0.setNext(node1);
    node1.setNext(node2);
    node2.setNext(node3);
    node3.setNext(node4);
    node4.setNext(node5);
    node5.setNext(node6);
    node6.setNext(node7);
    node7.setNext(node8);

    node0.removeOddFromVale(3, false);
    System.out.println();
    }

    public void removeOddFromVale(int value,boolean start){
    LinkedList head = this;
    LinkedList prev = this;

    if(!start){
        while(head != null){
        if(head.value == value){
            start = true;
            break;
        }
        prev = head;
        head = head.next;
        }
    }

    if(prev != null && head != null){
        if(prev == head){
        head = head.next;
        }

        if (head != null) {
        if (head.value % 2 == 0) {
            prev.next = head.next;
        } else {
            prev = prev.next;
            head = head.next;
        }
        if (prev != null) {
            prev.removeOddFromVale(value, true);
        }
        }
    }

    }

    private LinkedList next;
    private int value;

    public LinkedList(int value){
    this.value = value;
    }

    public LinkedList getNext() {
        return next;
    }
    public void setNext(LinkedList next) {
        this.next = next;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
}