对使用节点的堆栈进行int searchObject o方法

如何解决对使用节点的堆栈进行int searchObject o方法

我正在尝试制作一个使用通用节点类的通用堆栈和队列类。它具有empty()，pop()，peek()，push()和search()方法。我知道有一个内置的Stack类和堆栈search方法，但是我们必须使用Node类来实现。

我不确定如何制作search方法。假设search方法返回距事件堆栈顶部最近的堆栈顶部的距离。最上面的项目被认为在距离1处；下一项在距离2处；等

我的课在下面：

import java.io.*; 
import java.util.*;

public class MyStack<E> implements StackInterface<E>
{
    private Node<E> head;
    private int nodeCount;

    public static void main(String args[]) {
    }
    
    public E peek() {
        return this.head.getData();
    }
   
    public E pop() {
        E item;
        item = head.getData();
        head = head.getNext();
        nodeCount--;
        return item;
    }
    
    public boolean empty() {
        if (head==null) {
            return true; 
        } else {
            return false;
        }
    }
   
    public void push(E data) {
        Node<E> head = new Node<E>(data);
        nodeCount++;
    }
   
    public int search(Object o) {
        // todo
    }
}

public class Node<E>
{
    E data;
    Node<E> next;
    // getters and setters  
    public Node(E data) 
    { 
        this.data = data; 
        this.next = null; 
    } 
    public E getData() {
        return data;
    }
    public void setData(E data) {
        this.data = data;
    }
    public Node<E> getNext() {
        return next;
    }
    public void setNext(Node<E> next) {
        this.next = next;
    }
}

public class MyQueue<E> implements QueueInterface<E>
{
    private Node<E> head;
    private int nodeCount;
    Node<E> rear;
    public MyQueue() 
    { 
        this.head = this.rear = null; 
    } 
    
    public void add(E item){
        Node<E> temp = new Node<E>(item);
        if (this.rear == null) { 
            this.head = this.rear = temp; 
            return; 
        }  
        this.rear.next = temp; 
        this.rear = temp; 
    }
    
    public E peek(){
        return this.head.getData();
    }
    
    public E remove(){ 
        E element = head.getData();
        Node<E> temp = this.head;
        this.head = this.head.getNext();
        nodeCount--;
        return element;
    }
}

根据第一条评论进行研究后，我得到了以下内容：

public int search(Object o){
    int count=0;
    Node<E> current = new Node<E> (head.getData());
    while(current.getData() != o){
        current.getNext();
        count++;
    }
    
    return count;
}

它没有任何错误，但我无法确定它是否实际上正常工作。这看起来正确吗？

解决方法

它需要进行以下改进，

搜索方法应具有“ E”类型的参数。因此，签名应类似于public int search(E element)
从1开始而不是从0开始计数。您已经提到最上面的项目在距离1处
使用head初始化电流，因为创建一个数据值为head（new node（head.getData（）））的新节点将创建一个独立的节点，其数据与head节点相同；而while将仅在头节点上运行，因为current.getNext（）始终为null。 Node<E> current = head将创建另一个指向头部的参考变量。
使用if( !current.getData().equals(element.getData())) )

！=

如果使用您自己的类作为数据类型，请不要忘记重写 equals 方法。
将current.getNext();更改为current = current.getNext();

您对其他方法有疑问。请注意top == null。要计算search()，您只需要遍历元素并找到所需值的位置即可：

public class MyStack<E> {

    private Node<E> top;
    private int size;

    public void push(E val) {
        Node<E> node = new Node<>(val);
        node.next = top;
        top = node;
        size++;
    }

    public E element() {
        return top == null ? null : top.val;
    }

    public E pop() {
        if (top == null)
            return null;

        E val = top.val;
        top = top.next;
        size--;
        return val;
    }

    public boolean empty() {
        return size == 0;
    }

    public int search(E val) {
        int res = 1;
        Node<E> node = top;

        while (node != null && node.val != val) {
            node = node.next;
            res++;
        }

        return node == null ? -1 : res;
    }

    private static final class Node<E> {

        private final E val;
        private Node<E> next;

        public Node(E val) {
            this.val = val;
        }

    }
}

我假设您的MyStack类应该与Java在您所提问题中提供的Stack类兼容。这意味着您的签名public int search(Object o)与java.util.Stack#search的签名匹配（synchronised除外）。

要使用您的search类实现Node方法，我们需要遍历堆栈并返回第一个（最高）匹配项的索引。首先，将head分配给局部变量（current）。然后，您可以创建一个循环，在最后current.getNext()处获得下一个元素。如果下一个元素是null，请停止，因为我们已经到达堆栈的末尾。在循环中，您可以递增index或在当前元素的数据与参数o匹配时返回该索引。

求值结果必须能够处理参数null的{{1}}值。因此，您需要首先检查o并相应地调整逻辑。当null为o时，请对null进行null检查。如果current.getData()不是o，请检查null是否等于current.getData()与o。

以下是一个有效的示例： （与equals()兼容）

java.util.Stack#search

要对此进行测试，可以使用JUnit编写一个简单的单元测试，如下所示：

public int search(Object o) {
    int index = 1;
    Node<E> current = head;
    while (current != null) {
        if (o == null) {
            if (current.getData() == null) {
                return index;
            }
        } else {
            if (o.equals(current.getData())) {
                return index;
            }
        }
        current = current.getNext();
        index++;
    }
    return -1; // nothing found
}

由于已经有了参考实现，因此可以将@Test public void testMyStackSearch() { // initialize final MyStack<String> stack = new MyStack<>(); stack.push("e5"); stack.push("e4"); stack.push(null); stack.push("e2"); stack.push("e1"); // test (explicitly creating a new String instance) assertEquals(5,stack.search(new String("e5"))); assertEquals(3,stack.search(null)); assertEquals(2,stack.search(new String("e2"))); assertEquals(1,stack.search(new String("e1"))); assertEquals(-1,stack.search("X")); }替换为MyStack（Stack），然后查看您的断言是否正确。如果此操作成功运行，请将其更改回java.util.Stack，然后查看您的实施是否正确。

我不建议实际使用Java中的Stack实现。在这里，它仅用作MyStack方法的参考实现。 Deque接口及其实现提供了一套更完整和一致的LIFO堆栈操作，应优先使用Stack。

对使用节点的堆栈进行int searchObject o方法

如何解决对使用节点的堆栈进行int searchObject o方法

解决方法

相关推荐