java實現stack

1. 在java中如何下能Stack壓入一對數，例如stack.push((12,34))

你好，很高興回答你的問題。

代碼中Stack內存放的是Pair對象，你可以先構造一個Pair對象，然後將這個對象push壓入。

2. JAVA中運用Stack類實現十進制轉換成八進制

直接在分割的時候就執行壓棧操作，出棧時移位相加，一個棧就能解決，不過毫無意義，在開發中並沒有什麼卵用。

有問題歡迎提問，滿意請採納，謝謝！

3. 怎麼用java代碼實現棧內存

使用java.util包中的Stack類創建一個棧對象
public Object push(Object data);輸入數據，實現壓棧
public Object pop();輸出數據，實現彈棧
public boolean empty()判空
public Object peek();查看棧頂元素
可以去查查API嘛
我也是學java的，大家一起進步。

4. 用java實現數據結構「棧

Java棧的實現

public class MyStack { //定義一個堆棧類

int[] array; //用int數組來保存數據，根據需要可以換類型
int s_size; //定義堆棧的寬度

public MyStack(int i){ //定義一個帶參數構造器
array=new int[i]; //動態定義數組的長度
s_size=0; //堆棧的默認寬度為0
}

public MyStack(){ //默認構造器
this(50); //默認構造器可容納50個元素
}

public void push(int i){ //壓棧
array[this.s_size]=i;
this.s_size++;
}

public int pop(){ //從堆棧中取元素，從棧頂開始取
if(this.s_size!=0){
int t=array[s_size-1]; //用中間變數保存棧頂的元素
array[s_size-1]=0; //取完元素該位置設為0
s_size--; //棧的大小減1
return t; //返回棧頂元素
}else{
System.out.println("This stack is empty"); //當棧為空時顯示提示信息，返回0
return 0;
}
}

public boolean isEmpty(){ //判斷棧是否為空
return this.s_size==0;
}

public int top(){ //從棧頂取值，功能和 pop() 方法一樣
if(!this.isEmpty()){
int t=array[this.s_size-1];
array[this.s_size-1]=0;
this.s_size--;
return t;
}else{
System.out.println("This stack is empty!");
return 0;
}
}

public void printAll(){ //列印出堆棧中的所有元素的值，不是取出，元素依然在堆棧里
if(!this.isEmpty()){
for(int i=this.s_size - 1;i>=0;i--){
System.out.println(array[i]);
}
}
}

//下面是測試代碼
public static void main(String[] args){
MyStack stack=new MyStack();
stack.push(4);
stack.push(5);
stack.push(6);
stack.push(7);
//System.out.println(stack.isEmpty());
stack.printAll();
System.out.println("===========");
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.top());
}

}

5. java語言中用LinkList實現堆棧

棧和隊列是兩種特殊的線性表，它們的邏輯結構和線性表相同，只是其運算規則較線性表有更多的限制，故又稱它們為運算受限的線性表。

LinkedList數據結構是一種雙向的鏈式結構，每一個對象除了數據本身外，還有兩個引用，分別指向前一個元素和後一個元素，和數組的順序存儲結構（如：ArrayList）相比，插入和刪除比較方便，但速度會慢一些。

棧的定義

棧（Stack）是限制僅在表的一端進行插入和刪除運算的線性表。

(1)通常稱插入、刪除的這一端為棧頂（Top），另一端稱為棧底（Bottom）。

(2)當表中沒有元素時稱為空棧。

(3)棧為後進先出（Last In First Out）的線性表，簡稱為LIFO表。

棧的修改是按後進先出的原則進行。每次刪除（退棧）的總是當前棧中"最新"的元素，即最後插入（進棧）的元素，而最先插入的是被放在棧的底部，要到最後才能刪除。

實現代碼：

package com.weisou.dataStruct;

import java.util.LinkedList;

@SuppressWarnings("unchecked")

public class MyStack {

LinkedList linkList = new LinkedList<Object>();

public void push(Object object) {

linkList.addFirst(object);

}

public boolean isEmpty() {

return linkList.isEmpty();

}

public void clear() {

linkList.clear();

}

// 移除並返回此列表的第一個元素

public Object pop() {

if (!linkList.isEmpty())

return linkList.removeFirst();

return "棧內無元素";

}

public int getSize() {

return linkList.size();

}

public static void main(String[] args) {

MyStack myStack = new MyStack();

myStack.push(2);

myStack.push(3);

myStack.push(4);

System.out.println(myStack.pop());

System.out.println(myStack.pop());

}

}

隊列定義

隊列（Queue）是只允許在一端進行插入，而在另一端進行刪除的運算受限的線性表

（1）允許刪除的一端稱為隊頭（Front）。

（2）允許插入的一端稱為隊尾（Rear）。

（3）當隊列中沒有元素時稱為空隊列。

（4）隊列亦稱作先進先出（First In First Out）的線性表，簡稱為FIFO表。

實現代碼：

package com.weisou.dataStruct;

import java.util.LinkedList;

/**

*

* @author gf

* @date 2009-11-13

*/

public class MyQueue {

LinkedList linkedList = new LinkedList();

//隊尾插

public void put(Object o){

linkedList.addLast(o);

//隊頭取 取完並刪除

public Object get(){

if(!linkedList.isEmpty())

return linkedList.removeFirst();

else

return "";

}

public boolean isEmpty(){

return linkedList.isEmpty();

}

public int size(){

return linkedList.size();

}

public void clear(){

linkedList.clear();

}

/**

* @param args

*/

public static void main(String[] args) {

MyQueue myQueue= new MyQueue();

myQueue.put(1);

myQueue.put(2);

myQueue.put(3);

System.out.println(myQueue.get());

}

}

6. 用java編寫出來：用數組實現一個棧

public class Stack {
private Object[] stack;
//這個不需要;
//private int top = 0; //初始化棧頂
//這個也不需要;
//寫一個棧出來,最好是可以動態的,可以自己改變大小的,即數組的長度;
//private int size = 0; // 初始化大小

//元素個數;
private int size;

//默認長度為10;
public Stack(){
this(10);
}

//也可以自己設置長度,即容量;
public Stack(int len){
stack = new Object[len];
}

//返回元素個數;
public int size(){
return size;
}

//返回數組長度,即容量;
public int capacity(){
return stack.length;
}

//實現動態的數組;
public void ensureCapacity(){
if(size() == capacity()){
Object[] newStack = new Object[size() * 3 / 2 + 1];
System.array(stack, 0, newStack, 0, size());
stack = newStack;
}
}

//入棧;
public void push(Object o){
size++;
ensureCapacity();
stack[size - 1] = o;
}

/*
public void push(Object object) {
if (isFull()) {
System.out.println("棧滿! 入棧失敗");
}
stack[top++] = object;
}
*/

//判空;
public boolean isEmpty(){
return size == 0;
}

//出棧;
public Object pop(){
//首先要判空;
if(isEmpty()){
throw new ("不能為空");
}

Object o = stack[--size];
stack[size] = null;
return o;
}

/*
// 出棧
public Object pop() {
Object object = stack[--top];
stack[top] = null;
return object;
}
*/

/*
// 計算棧當前大小
public int size() {
return top;
}

// 判斷是否是空棧
public boolean isEmpey() {
return top == 0;
}

// 判斷是否棧滿
public boolean isFull() {
return top >= size;
}

public Stack(int size) {
this.size = size;
}
*/

public static void main(String[] args) {
Stack stack = new Stack(3);
String[] data = new String[] { "a", "b", "c" };
for (int i = 0; i < data.length; i++) {
stack.push(data[i]);
System.out.println(data[i] + "");
}
System.out.println("***********");
while (!stack.isEmpty()) {
System.out.println(stack.pop() + "");
}
//}
}
}
你自己對比一下,我是在你的裡面修改的

7. java的自己創建的棧可以作為緩存區嗎

可以。
棧的創建和使用JAVAStack類：棧是Vector的一個子類，它實現了一個標準的後進先出的棧，棧本身最重要的就是push和pop堆棧只定義了默認構造函數。
棧是Vector的一個子類，它實現了一個標準的後進先出的棧。堆棧只定義了默認構造函數，用來創建一個空棧。堆棧除了包括由Vector定義的所有方法，也定義了自己的一些方法。

8. java里Stack類怎麼用啊

如下示例代碼

//
Stackstack=newStack();
Strings1="element1";
Strings2="element2";
stack.push(s1);
stack.push(s2);

現在棧中有兩個元素，棧頂應該是element 2，我們可以通過peek方法看棧頂的元素：

System.out.println(stack.peek());

輸出：

element 2

要看element 1的位置需要使用search方法：

//Findpositionofacertainelement
intpos=stack.search("element1");
System.out.println(pos);

上面代碼將輸出：

2

要移除棧頂的元素應該用pop()方法：

System.out.println(stack.pop());
System.out.println(stack.pop());

輸出：

element 2
element 1

在上一步中棧中的兩個元素都被pop了，現在我們看下empty()方法是否返回true

System.out.println(stack.empty());

輸出：

true

9. Java如何實現堆棧

//這是JDK提供的棧

import java.util.Stack;

public class UsingStack {
public static void main(String[] args) {
//構造棧對象，使用類型限制，只能存儲Integer數據
Stack<Integer> s = new Stack<Integer>();

//1、2、3依次入棧
s.push(1);
s.push(2);
s.push(3);

//3、2、1依次出棧
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}

//這是我寫的順序結構的棧
import java.util.EmptyStackException;
import java.util.Vector;

public class UsingStack{
public static void main(String[] args){
//構造棧對象，使用類型限制，只能存儲Integer數據
MyStack<Integer> s = new MyStack<Integer>();

//1、2、3依次入棧
s.push(1);
s.push(2);
s.push(3);

//3、2、1依次出棧
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}

/**
* 棧類
* @author developer_05
* @param <T>
*/
class MyStack<T> extends Vector<T>{
/**
* 構造方法
*/
public MyStack(){
}

/**
* 入棧方法
* @param item 待入棧的元素
* @return 返回入棧的元素
*/
public T push(T item) {
addElement(item);

return item;
}

/**
* 出棧方法(同步處理)
* @return 返回出棧元素
*/
public synchronized T pop() {
T obj;
int len = size();

if (len == 0)
throw new EmptyStackException();
obj = elementAt(len - 1);

removeElementAt(len - 1);

return obj;
}

/**
* 判斷棧是否為空的方法
* @return 返回true(棧空)或false(棧非空)
*/
public boolean empty() {
return size() == 0;
}

private static final long serialVersionUID = 1L;
}

10. 用一維整數數組實現數據結構中的堆棧(Stack)。（用java語言）

public class IntStack {

private int[] stack;
private int top;

/**
*初始化棧，傳入一個非負的整數，否則拋出一個錯誤
*/
public IntStack(int size) throws StackErrorException{
if(size<0){
throw new StackErrorException("錯誤的大小");
}

init(size);
}

private void init(int size) {
stack = new int[size];
top = 0;
}

/**
*判斷棧是否為空，true則為空，反之則反
*/
public boolean isEmpty(){
return top==0;
}

/**
*判斷棧是否已滿，true則已滿，反之則反
*/
public boolean isFull(){
return top==stack.length;
}
/**
*向棧頂添加元素，滿則拋出異常
*/
public void push(int value) throws StackErrorException{
if(isFull()){
throw new StackErrorException("棧已滿");
}
stack[top++] = value;
}
/**
*移除棧頂元素並返回，空則拋出異常
*/
public int pop() throws StackErrorException{
if(isEmpty()){
throw new StackErrorException("已到棧底!");
}
return stack[--top];
}
/**
*返回棧頂元素，空則拋出異常
*/
public int peek() throws StackErrorException{
if(isEmpty()){
throw new StackErrorException("已在棧底!");
}
return stack[top-1];
}
/**
*返回棧大小
*/
public int size(){
return stack.length;
}
class StackErrorException extends Exception{
public StackErrorException(String msg) {
super(msg);
}
}
}