java 数据结构之栈与队列

java 数据结构之栈与队列

一：对列

队列是一种先进先出的数据结构

实现代码：

package queue; 
 
/* 
 * 使用java构建队列，并模拟实现队列的入队和出对方法 
 */ 
 
public class queue {   //队列类 
 
  private int maxsize; //定义队列的长度 
  private int[] arrqueue;   //队列 
  private int rear;   //定义队列的尾指针 
  private int front;  //定义队列的头指针 
  private int empty; //元素的个数 
   
  public queue(int s)  //初始化构造函数 
  { 
    maxsize = s; 
    arrqueue = new int[s]; 
    rear = -1; 
    front=0; 
    empty = 0; 
  } 
   
  //实现插入方法 
  public void insert(int m) 
  { 
    if(rear == maxsize-1)  //处理循环 
      rear = -1;    
    arrqueue[++rear] = m;  //对尾指针加一，把值放在队列结尾 
    empty++;   //队列元素个数加1 
    system.out.println("队列入队元素 为：" + m); 
  } 
   
  //实现出栈的方法，即取得队列的头元素 
  public int remove() 
  { 
    int temp = arrqueue[front++]; //将栈顶元素赋值给temp，栈顶指针加1 
    if(front == maxsize) //处理循环 
      front = 0; 
    empty--; //元素个数-1 
    return temp; 
  } 
   
  //判断队列是否为空 
  public boolean isempty() 
  { 
    return (empty==0); 
  } 
   
  //判断对列是否为满 
  public boolean isfull() 
  { 
    return (empty == maxsize); 
  } 
   
  //返回队列长度 
  public int qlong() 
  { 
    return empty; 
  } 
   
  public static void main(string[] args) { 
    queue q = new queue(5); //初始化队列为5个元素 
     
    q.insert(1); 
    q.insert(2); 
    q.insert(3); 
    q.insert(4); 
    q.insert(5); 
     
    int t1 = q.remove(); 
    system.out.println("队列元素出队：" + t1); 
    int t2 = q.remove(); 
    system.out.println("队列元素出队：" + t2); 
     
    system.out.println("队列是否为空：" + q.isempty()); 
    system.out.println("队列是否为满：" + q.isfull()); 
    system.out.println("队列的长度：" + q.qlong()); 
  } 
   
} 

二：栈

栈是一种先进后出的数据结构

1：使用数组模拟栈

package statck; 
/* 
 * 使用java构建栈，并模拟实现栈的入栈和出栈方法 
 * 使用数组实现 
 */ 
 
public class statck1 { 
 
  private int maxsize;   //栈的最多元素数 
  private int top;  //栈顶指针 
  private int len;   //栈的深度 
  private int[] arrstack; // 模拟栈 
   
  //栈的初始化 
  public statck1(int s){ 
    maxsize = s; 
    len =0; 
    top= -1; 
    arrstack = new int[s]; 
  } 
   
  //获取栈的长度 
  public int getlen(){ 
    return len; 
  } 
   
  //获取当前栈还能插入多少个f元素 
  public int getleavelen(){ 
    return (maxsize-len); 
  } 
  //判断栈是否满 
  public boolean isfull(){ 
    return (len==maxsize); 
  } 
   
  //判断栈是否为空 
  public boolean isempty(){ 
    return (len ==0); 
  } 
   
  //元素入栈 
  public void instack(int s) 
  { 
    arrstack[++top] = s; //栈顶指针加1,入栈 
    system.out.println("元素入栈：" + s); 
    len ++ ;//栈深度+1 
  } 
   
  //元素出栈 
  public int outstack() 
  { 
    int temp = arrstack[top--];//赋值之后减1 
    system.out.println("元素出栈：" + temp); 
    len--;  //栈深度-1 
    return temp; 
  } 
   
  public static void main(string[] args) { 
    statck1 s = new statck1(5); 
     
    s.instack(1); 
    s.instack(2); 
    s.instack(3); 
    s.instack(4); 
    s.instack(5); 
     
    s.outstack(); 
    s.outstack(); 
    system.out.println("栈的长度：" + s.getlen()); 
    system.out.println("还能入栈元素个数：" + s.getleavelen()); 
    system.out.println("栈的是否为空：" + s.isempty()); 
    system.out.println("栈的是否为满：" + s.isfull()); 
  } 
} 

2：使用链表模拟栈

package statck; 
 
import java.util.arraylist; 
import java.util.emptystackexception; 
import java.util.list; 
 
/* 
 * 使用java构建栈，并模拟实现栈的入栈和出栈方法 
 * 使用链表实现 
 */ 
 
public class statck2<e extends object> {  
   
  private list<e> statck = new arraylist<e>();  
   
  public statck2(){ 
       //栈的初始化 
  } 
   
  //清空栈 
  public void clear(){ 
    statck.clear(); 
    system.out.println("清空栈.........."); 
  } 
  //判断栈是否为空 
  public boolean isempty(){ 
    return statck.isempty(); 
  } 
  //获取栈顶元素 
  public e gettop(){ 
    if(isempty()) 
      return null; 
    return statck.get(0); 
  } 
   
  //弹出栈操作 
  public e pop(){ 
    if (isempty())  
      throw new emptystackexception();  
    system.out.println(statck.size() + "\t 出栈"); 
    return statck.remove(statck.size() - 1);  
  } 
   
  //压入栈操作 
  public void push(e e){ 
    statck.add(e); 
    system.out.println(e + "\t 入栈"); 
  } 
   
  //获取当前栈的深度 
  public int getstatcksize(){ 
    if(isempty()) 
      throw new emptystackexception(); 
    return statck.size(); 
  } 
   
  public static void main(string[] args) { 
    statck2 s = new statck2(); 
    s.clear();      //清空栈 
    system.out.println("当前栈是否为空：" + s.isempty()); 
    s.push(1); 
    s.push(2); 
    s.push(3); 
     
    s.pop(); 
    system.out.println("当前栈的深度为：" + s.getstatcksize()); 
    system.out.println("当前栈顶元素为：" + s.gettop()); 
  } 
   
} 

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持，如有疑问请留言或者到本站社区交流讨论，大家共同进步！