Question

我正在尝试完成一个项目，要求我不使用任何类型的循环，而只使用递归。我必须使用LinkedLists而不是数组创建一个StringBuilder类。如果有人可以帮我在这个方法delete（）中实现递归，我将不胜感激。

public MyStringBuilder delete(int start, int end)
    {
        if(!(start < 0 || start > length || end <= start)){
            CNode currNode = firstC;
            CNode startNode = currNode;
            if(start == 0){
                for(int i = 1; i < end +1; i++){
                    currNode = currNode.next;
                    length -= 1;
                }
                firstC = currNode;
            }else if (end > length){
                for(int i = 1; i < start; i++){
                    currNode = currNode.next;
                }
                length = start;
                currNode.next = null;
                lastC = currNode;
            } else {
                for(int i = 0; i < end; i++){
                    //find starting deletion point
                    if(i == (start - 1)){
                        startNode = currNode;
                    }
                    currNode = currNode.next;
                }
                length = length - (end-start);
                //actual deletion part
                startNode.next = currNode;
            }
        }
        return this;
    }

非常感谢。

Answer 1

我无法理解，即使你说不应该有任何循环，你仍然有一些循环提到那里。

我试图使用链接列表来解决问题。我不得不在这里和那里包括for循环。所以，看看......

ListNode.java

public class ListNode<T>{
    public T data;
    public ListNode<T> next;
    public int nos;
}

MyStringBuilder.java

import java.util.*;
public class MyStringBuilder {
    ListNode<Character> list = new ListNode<Character>();

    public void add(String s){
        ListNode<Character> p1 = list; 
        for(int i=0; i<s.length(); i++){
            p1.data = s.charAt(i);
            p1.next = new ListNode<Character>();
            p1 = p1.next;
        }
        list.nos=s.length();

    }

    public void print(){
        ListNode<Character> p1 = list;

        while(p1.next!=null){
            System.out.print(p1.data);
            p1= p1.next;
        }
        System.out.println();
    }

    public void delete(int start, int end){
        ListNode<Character> p1 = list;
        ListNode<Character> p2;
        ListNode<Character> prev =list;
        if (start < 0){
            throw new IllegalArgumentException("first argument cannot be less than 0");
        }
        if (start > end){
            throw new IllegalArgumentException("first argument cannot be greater than second");
        }
        if (end > list.nos){
            throw new IllegalArgumentException("second argument cannot be greater than size of string");
        }

        if(start==0){
            while(end!=0){
                p1=p1.next;
                end--;
            }
            list = p1.next;
            return;
        }

        //iterate over start steps
        int i=start;
        while(i!=0){
            prev = p1;
            p1= p1.next;
            i--;
        }

        p2 = p1.next;

        end = end-start;
        while(end!=0){
            p2 = p2.next;
            end--;
        }
        prev.next = p2;
    }
}

我希望解决方案适合您。我尝试了以下示例来检查它是否有效。我在main()

中写了这些代码

        MyStringBuilder abc = new MyStringBuilder();
        abc.add("apocalypto");

        abc.delete(2, 6);
        abc.print();

我得到了这个答案： appto

Answer 2

要使用递归实现这一点，您必须做两件事：定义基本案例，并弄清楚如何从一个递归调用转到另一个递归调用。我不会写出代码，但这里有一个大致的想法：

首先，让我们考虑删除方法的作用。它从 a 包含删除到 b 独占。因此，一个很好的基本情况是我们到达 b 并停止删除。

现在，从一个步骤到另一个步骤，我们可以简单地删除我们所在的节点，并递归调用我们的函数用于下一个节点。

但是，在实现逻辑时要小心;处理此问题的最佳方法是跟踪要删除的节点数并将其用作基本案例。这样做的原因是删除时会修改列表，您需要跟踪要删除的节点数量，直到您点击 b 。

如果您只是记住这个一般准则，那么代码应该在某种程度上自行编写。随意问任何问题！

使用递归实现StringBuilder删除方法

2 个答案: