リンクリストを使用したスタックの実装
Javaでリンクリストを使用してスタックを実装するための最良の方法は何ですか？
編集：私はクリーンなコードを使用して最も効率的であると最もよく定義します。私はすでに配列を使用してスタックを実装しましたが、リンクリストに精通していないため、以下のような実装を誰かが手伝ってくれるかどうか疑問に思っていました。
public class StackArray{
private Object [] objArray;
private int stackSize;
public StackArray(){
objArray = new Object[50];
stackSize = 0;
}
public StackArray(int size){
objArray = new Object[size];
stackSize = 0;
}
//public interface methods - Push, pop, top, empty & clear
public void Push(Object o)throws StackArrayException{
if(stackSize < objArray.length){
objArray[stackSize] = o;
stackSize ++;
}else{
throw new StackArrayException("Stack Overflow");
}
}
public Object pop()throws StackArrayException{
if(stackSize != 0){
stackSize--;
return(objArray[stackSize]);
}else{
throw new StackArrayException("Stack Underflow");
}
}
public void top() throws StackArrayException{
if(stackSize != 0){
return(objArray[stackSize-1]);
}else{
throw new StackArrayException("Stack Underflow");
}
}
public boolean empty(){
return (stackSize == 0):
}
public void clear(){
stackSize = 0;
}
}
編集：誰かが興味を持っているなら、これがリンクリストの実装です。
public class StackList{
private Node listHead;
protected class Node{
protected Object datum;
protected Node next;
public Node(Object o, Node n){
datum = o;
next = n;
}
public StackList(){
listHead = null;
}
//public interface methods - Push pop top empty clear
public void Push(Object o){
listHead = new Node(o, listHead);
}
public Object pop() throws StackListException{
if(listHead!=null){
Object top = listHead.datum;
listHead = listHead.next;
return top;
}else{
throw new StackListException("Stack Underflow");
}
}
public Object top()throws StackListException{
if(listHead != null){
return(listHead.datum);
}else{
throw new StackListException("Stack Underflow");
}
}
public boolean empty(){
return (listHead == null);
}
public void clear(){
listHead = null;
}
}
完全に優れた既存のスタック実装 のいずれかを使用するのではなく、本当に最初からこれを実行したいと仮定すると、次のことをお勧めします。
- 必要なインターフェイスを実装する「MyStack <T>」クラスを作成します（おそらくList <T>？）
- MyStack内で、リンクリストアイテムごとに「プライベート静的最終クラスNode <T>」内部クラスを作成します。各ノードには、タイプTのオブジェクトへの参照と「次の」ノードへの参照が含まれています。
- MyStackへの「topOfStack」Node参照を追加します。
- プッシュおよびポップ操作は、このtopOfStackノードで操作する必要があります。 nullの場合、スタックは空です。後で混乱しないように、標準のJavaスタックと同じメソッドシグネチャとセマンティクスを使用することをお勧めします。
- 最後に、必要な他のメソッドを実装します。ボーナスポイントについては、追加のストレージ割り当てなしでイテレータが作成された時点でのスタックの不変状態を記憶するように「Iterable <T>」を実装します（thisis可能:-)）
単一のリンクリストについて話している場合（ノードには次のオブジェクトへの参照がありますが、前のオブジェクトへの参照はありません）、クラスは次のようになります。
public class LinkedListStack {
private LinkedListNode first = null;
private LinkedListNode last = null;
private int length = 0;
public LinkedListStack() {}
public LinkedListStack(LinkedListNode firstAndOnlyNode) {
this.first = firstAndOnlyNode;
this.last = firstAndOnlyNode;
this.length++;
}
public int getLength() {
return this.length;
}
public void addFirst(LinkedListNode aNode) {
aNode.setNext(this.first);
this.first = aNode;
}
}
public class LinkedListNode {
private Object content = null;
private LinkedListNote next = null;
public LinkedListNode(Object content) {
this.content = content;
}
public void setNext(LinkedListNode next) {
this.next = next;
}
public LinkedListNode getNext() {
return this.next;
}
public void setContent(Object content) {
this.content = content;
}
public Object getContent() {
return this.content;
}
}
もちろん、正しく効果的に機能するためには、残りのメソッドをコーディングする必要がありますが、基本はわかっています。お役に立てれば！
LinkedListを使用してスタックを実装する場合-このStackLinkedListクラスは、LinkedList参照を内部的に維持します。
StackLinkedListのPushメソッドは、linkedListのinsertFirst()メソッドを内部的に呼び出します
_public void Push(int value){
linkedList.insertFirst(value);
}
_StackLinkedListのメソッドは、linkedListのdeleteFirst()メソッドを内部的に呼び出します
_public void pop() throws StackEmptyException {
try{
linkedList.deleteFirst();
}catch(LinkedListEmptyException llee){
throw new StackEmptyException();
}
}
_フルプログラム
_/**
*Exception to indicate that LinkedList is empty.
*/
class LinkedListEmptyException extends RuntimeException{
public LinkedListEmptyException(){
super();
}
public LinkedListEmptyException(String message){
super(message);
}
}
/**
*Exception to indicate that Stack is empty.
*/
class StackEmptyException extends RuntimeException {
public StackEmptyException(){
super();
}
public StackEmptyException(String message){
super(message);
}
}
/**
*Node class, which holds data and contains next which points to next Node.
*/
class Node {
public int data; // data in Node.
public Node next; // points to next Node in list.
/**
* Constructor
*/
public Node(int data){
this.data = data;
}
/**
* Display Node's data
*/
public void displayNode() {
System.out.print( data + " ");
}
}
/**
* LinkedList class
*/
class LinkedList {
private Node first; // ref to first link on list
/**
* LinkedList constructor
*/
public LinkedList(){
first = null;
}
/**
* Insert New Node at first position
*/
public void insertFirst(int data) {
Node newNode = new Node(data); //Creation of New Node.
newNode.next = first; //newLink ---> old first
first = newNode; //first ---> newNode
}
/**
* Deletes first Node
*/
public Node deleteFirst()
{
if(first==null){ //means LinkedList in empty, throw exception.
throw new LinkedListEmptyException("LinkedList doesn't contain any Nodes.");
}
Node tempNode = first; // save reference to first Node in tempNode- so that we could return saved reference.
first = first.next; // delete first Node (make first point to second node)
return tempNode; // return tempNode (i.e. deleted Node)
}
/**
* Display LinkedList
*/
public void displayLinkedList() {
Node tempDisplay = first; // start at the beginning of linkedList
while (tempDisplay != null){ // Executes until we don't find end of list.
tempDisplay.displayNode();
tempDisplay = tempDisplay.next; // move to next Node
}
System.out.println();
}
}
/**
* For implementing stack using using LinkedList- This StackLinkedList class internally maintains LinkedList reference.
*/
class StackLinkedList{
LinkedList linkedList = new LinkedList(); // creation of Linked List
/**
* Push items in stack, it will put items on top of Stack.
*/
public void Push(int value){
linkedList.insertFirst(value);
}
/**
* Pop items in stack, it will remove items from top of Stack.
*/
public void pop() throws StackEmptyException {
try{
linkedList.deleteFirst();
}catch(LinkedListEmptyException llee){
throw new StackEmptyException();
}
}
/**
* Display stack.
*/
public void displayStack() {
System.out.print("Displaying Stack > Top to Bottom : ");
linkedList.displayLinkedList();
}
}
/**
* Main class - To test LinkedList.
*/
public class StackLinkedListApp {
public static void main(String[] args) {
StackLinkedList stackLinkedList=new StackLinkedList();
stackLinkedList.Push(39); //Push node.
stackLinkedList.Push(71); //Push node.
stackLinkedList.Push(11); //Push node.
stackLinkedList.Push(76); //Push node.
stackLinkedList.displayStack(); // display LinkedList
stackLinkedList.pop(); //pop Node
stackLinkedList.pop(); //pop Node
stackLinkedList.displayStack(); //Again display LinkedList
}
}
_[〜＃〜]出力[〜＃〜]
スタックの表示>上から下へ：76 11 71 39
スタックの表示>上から下へ：71 39
礼儀： http://www.javamadesoeasy.com/2015/02/implement-stack-using-linked-list.html
すでにそこにある Stack 実装を使用してみませんか？
またはそれ以上（実際にはリンクリストであり、高速で、スレッドセーフであるため）： LinkedBlockingDeque
これは リンクリストを使用してJava Java $ ===でスタックを実装する 。スタックアイテムを反復処理するイテレータとともにPushメソッドとpopメソッドを実装するチュートリアルです。お役に立てば幸いです。
STLアダプターstd::stackを使用します。どうして？あなたが書く必要のないコードがあなたのタスクを完了するための最速の方法だからです。 stackは十分にテストされており、注意を払う必要はないでしょう。何故なの？コードに必要な特別な目的の要件がいくつかあるため、ここでは文書化されていません。
デフォルトでは、stackはdeque両端キューを使用しますが、基礎となるコンテナが.Push_backとも呼ばれる「逆挿入シーケンス」をサポートする必要があるだけです。
typedef std::stack< myType, std::list<myType> > myStackOfTypes;
これは、配列とリンクリストを使用したチュートリアルの実装です スタック実装 。
状況によります。
配列：-サイズを変更することはできません（サイズを修正）LinkedList：-次のノードをメモリに保持する必要があるため、配列ベースのものよりも多くのメモリを消費します。
LinkedListを使用して多くのスタックの実装を見ました。最後に、スタックとは何かを理解し、自分でスタックを実装しました（私にとってはクリーンで効率的です）。新しい実装を歓迎することを願っています。ここにコードが続きます。
class Node
{
int data;
Node top;
public Node()
{
}
private Node(int data, Node top)
{
this.data = data;
this.top = top;
}
public boolean isEmpty()
{
return (top == null);
}
public boolean Push(int data)
{
top = new Node(data, top);
return true;
}
public int pop()
{
if (top == null)
{
System.out.print("Stack underflow<-->");
return -1;
}
int e = top.data;
top = top.top;
return e;
}
}
そしてここにそのメインクラスがあります。
public class StackLinkedList
{
public static void main(String[] args)
{
Node stack = new Node();
System.out.println(stack.isEmpty());
stack.Push(10);
stack.Push(20);
stack.Push(30);
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
System.out.println(stack.pop());
System.out.println(stack.isEmpty());
System.out.println(stack.pop());
}
}