Java实现stack

好的，Java实现stack可以使用Java提供的Stack类，也可以使用LinkedList类来实现。下面是使用LinkedList实现stack的示例代码：

import java.util.LinkedList;

public class MyStack<T> {
    private LinkedList<T> list;

    public MyStack() {
        list = new LinkedList<>();
    }

    public void push(T item) {
        list.addLast(item);
    }

    public T pop() {
        return list.removeLast();
    }

    public boolean isEmpty() {
        return list.isEmpty();
    }

    public int size() {
        return list.size();
    }
}

这个示例代码实现了一个泛型的stack，可以存储任意类型的数据。push方法将数据添加到stack的末尾，pop方法从stack末尾取出数据并删除它，isEmpty方法判断stack是否为空，size方法返回stack中元素的个数。

相关问题

java实现stack并测试_JUnit3.8实现模拟堆栈的测试 | 学步园

好的，下面是Java实现stack并测试的步骤：

1. 创建一个Stack类，该类应该包含以下方法：

- push(Object obj): 将元素obj压入堆栈中
- pop(): 弹出并返回堆栈顶部的元素
- peek(): 返回堆栈顶部的元素，但不弹出它
- isEmpty(): 如果堆栈为空，则返回true，否则返回false

2. 使用JUnit3.8编写测试用例，测试Stack类中的所有方法。测试用例应该包含以下测试：

- 测试push()方法是否能够将元素正确地压入堆栈中
- 测试pop()方法是否能够弹出并返回堆栈顶部的元素
- 测试peek()方法是否能够返回堆栈顶部的元素，但不弹出它
- 测试isEmpty()方法是否能够正确返回堆栈是否为空的状态

下面是一个示例代码，可以参考一下：

Stack.java

import java.util.ArrayList;

public class Stack {
    private ArrayList<Object> stack = new ArrayList<Object>();

    public void push(Object obj) {
        stack.add(obj);
    }

    public Object pop() {
        Object obj = stack.get(stack.size() - 1);
        stack.remove(stack.size() - 1);
        return obj;
    }

    public Object peek() {
        return stack.get(stack.size() - 1);
    }

    public boolean isEmpty() {
        return stack.isEmpty();
    }
}

StackTest.java

import junit.framework.TestCase;

public class StackTest extends TestCase {
    private Stack stack;

    protected void setUp() throws Exception {
        super.setUp();
        stack = new Stack();
    }

    protected void tearDown() throws Exception {
        super.tearDown();
        stack = null;
    }

    public void testPush() {
        stack.push("Hello");
        stack.push("World");
        assertFalse(stack.isEmpty());
    }

    public void testPop() {
        stack.push("Hello");
        stack.push("World");
        assertEquals("World", stack.pop());
        assertEquals("Hello", stack.pop());
        assertTrue(stack.isEmpty());
    }

    public void testPeek() {
        stack.push("Hello");
        stack.push("World");
        assertEquals("World", stack.peek());
        assertFalse(stack.isEmpty());
    }

    public void testIsEmpty() {
        assertTrue(stack.isEmpty());
        stack.push("Hello");
        assertFalse(stack.isEmpty());
    }
}

这是一个简单的实现，你可以根据自己的需求进行修改和扩展。希望对你有所帮助！

dfs stack实现 java

DFS（深度优先搜索）是一种图遍历算法，可以用来解决很多问题，比如查找图中的连通分量、查找图中的路径等。在Java中，我们可以用Stack来实现DFS算法。

DFS使用栈（Stack）数据结构来存储待遍历的节点。具体实现步骤如下：

1. 首先，我们需要创建一个Stack对象来存储待遍历的节点。
2. 然后，我们选择一个起始节点作为DFS的起点，将其入栈。
3. 接着，我们进行循环操作，直到栈为空为止。每次循环中，我们从栈中取出一个节点，将其标记为已访问，并遍历其邻居节点。将邻居节点中未访问过的节点入栈。
4. 最后，当栈为空时，表示DFS遍历结束。

这样就可以使用Stack来实现DFS算法。下面是一个简单的Java代码示例：

import java.util.Stack;

public class DFSStack {
    public void dfs(int[][] graph, int start) {
        boolean[] visited = new boolean[graph.length];
        Stack<Integer> stack = new Stack<>();
        
        stack.push(start);
        
        while (!stack.isEmpty()) {
            int node = stack.pop();
            if (!visited[node]) {
                visited[node] = true;
                System.out.print(node + " ");
                
                for (int i = 0; i < graph.length; i++) {
                    if (graph[node][i] == 1 && !visited[i]) {
                        stack.push(i);
                    }
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int[][] graph = {
            {0, 1, 1, 0, 0},
            {1, 0, 0, 1, 0},
            {1, 0, 0, 1, 1},
            {0, 1, 1, 0, 1},
            {0, 0, 1, 1, 0}
        };
        
        DFSStack dfs = new DFSStack();
        dfs.dfs(graph, 0);
    }
}

以上就是用Stack实现DFS算法的一个简单例子。通过这种方式，我们可以使用Stack数据结构来实现深度优先搜索算法，解决各种与图相关的问题。