数据结构：堆，栈，队列

堆

是在程序运行时，而不是在程序编译时，申请某个大小的内存空间。即动态分配内存，对其访问和对一般内存的访问没有区别。堆和栈都是一样的都是先进后出的原则 ，又分为二叉堆，斐波那契堆，实际应用：堆排序等

栈

有一句经典的言语来概括：先进后出，后进先出。往里面加数据叫入栈，取数据叫出栈，底部叫栈底，顶部叫栈顶

• 使用数组实现的叫静态栈
• 使用链表实现的叫动态栈

public class Stack {
    // 栈顶
    public Node stackTop;
    // 栈底
    public Node stackBottom;

    public Stack(Node stackTop, Node stackBottom) {
        this.stackTop = stackTop;
        this.stackBottom = stackBottom;
    }

    public Stack() {
    }

}

进栈操作

将原本栈顶指向的节点交由新节点来指向，栈顶指向新加入的节点

/**
 * 进栈
 * @param stack 栈
 * @param value 要进栈的元素
 */
public static void pushStack(Stack stack, int value) {

    // 封装数据成节点
    Node newNode = new Node(value);

    // 栈顶本来指向的节点交由新节点来指向
    newNode.next = stack.stackTop;

    // 栈顶指针指向新节点
    stack.stackTop = newNode;
}

遍历栈

只要栈顶元素的指针不指向栈底，那么就一直输出遍历结果

/**
 * 遍历栈
 * @param stack
 */
public static void traverse(Stack stack) {
    Node stackTop = stack.stackTop;
    //栈顶元素的指针不指向栈底，那么就一直输出遍历结果
    while (stackTop != stack.stackBottom) {
        System.out.println("栈数据：" + stackTop.data);
        stackTop = stackTop.next;
    }

}

出栈操作

在出栈之前看看该栈是否为空，不为空才出栈
将栈顶的元素的指针(指向下一个节点)赋值给栈顶指针(完成出栈)

 

/**
 * 出栈(将栈顶的指针指向下一个节点)
 * @param stack
 */
public static void popStack(Stack stack) {
    // 栈不为空才能出栈
    if (stack.stackTop != stack.stackBottom) {
        //栈顶元素
        Node top = stack.stackTop;
        // 栈顶指针指向下一个节点
        stack.stackTop = top.next;
        System.out.println("栈数据：" + top.data);
    }
}

实际应用，安卓中定义一个activity栈来管理activity

队列

相对于栈而言，队列的特性是：先进先出，后进后出

• 使用数组实现的叫静态队列
• 使用链表实现的叫动态队列

• public class Queue<E> {
    private Object[] data=null;
    private int maxSize; //队列容量
    private int front;  //队列头，允许删除
    private int rear;   //队列尾，允许插入

      //构造函数
    public Queue(){
        this(5);
    }
    
    public Queue(int initialSize){
        if(initialSize >=0){
            this.maxSize = initialSize;
            data = new Object[initialSize];
            front = rear =0;
        }else{
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }
    
    //判空
    public boolean empty(){
        return rear==front?true:false;
    }
    
    //入队
    public boolean add(E e){
        if(rear== maxSize){
            throw new RuntimeException("队列已满，无法插入新的元素！");
        }else{
            data[rear++]=e;
            return true;
        }
    }

  //出队
      public E poll(){
          if(empty()){
              throw new RuntimeException("空队列异常！");
          }else{
              E value = (E) data[front];  //保留队列的front端的元素的值
              data[front++] = null;     //释放队列的front端的元素                
              return value;
          }            
      }
      
      //队列长度
      public int length(){
          return rear-front;
      }

      /**
       * 遍历队列
       * @param queue
       *
       */
      public static void traverseQueue(Queue queue) {
          // front的位置
          int i = queue.front;
          while (i != queue.rear) {
              System.out.println("队列值：" + queue.data[i]);
              //移动front
              i = (i + 1) % queue.data.length;
          }
      }

  }