数据结构第一天0401 一些概念、栈与队列的数组实现

• 传值，传引用
  • 栈，堆，地址
• 数组复制
  • System.arraycopy(a, 0, b, 0, a.length);
• 数据结构
  • 概念
    • 数据结构主要研究编程过程中要处理的对象以及对象之间的关系
    • 数据（data）是描述客观世界的符号集合
    • 数据元素（data element）是数据集合的个体
    • 数据结构（data structure）是指数据之间的关系
    • 数据关系：集合、线性结构、树形结构、图状结构
    • 数据结构研究三个方面的问题的：数据的逻辑结构、数据的存储结构、数据的运算
    • 算法就是处理问题的方法，涉及到时间复杂度、空间复杂度
  • 栈与队列
    • 数组实现
    • ​​​​​​​

      package com.qut.day1;
      
      public class StackDemo {
      
      	private Object[] st;
      	private int top;
      	private int size;
      	
      	public StackDemo(int s) {
      		size = s;
      		st = new Object[size];
      		top = 0;
      	}
      	
      	public void stackPush(Object o) {
      		if(top == size) {
      			stackLarge(); 
      		}
      		st[top++] = o;
      	}
      	
      	public void stackLarge() {
      		Object[] obj = new Object[size * 2];
      		System.arraycopy(st, 0, obj, 0, size);
      		st = obj;
      		size *= 2;
      	}
      	
      	public Object stackPop() {
      		if(top != 0) {
      			Object o = new Object();
      			o = st[--top];
      			st[top] = null;
      			return o;
      		}
      		return null;
      	}
      	
      	public boolean stackEmpty() {
      		return top == 0;
      	}
      	
      	public Object stackTop() {
      		if(top != 0) {
      			return st[top-1];
      		}
      		return null;
      	}
      	
      	public int stackSize() {
      		return top;
      	}
      	
      	public void show() {
      		for(int i = 0; i < top; i++) {
      			System.out.println(st[i]);
      		}
      	}
      }
      

    • package com.qut.day1;
      
      public class QueueDemo {
      
      	private int front;
      	private int last;
      	
      	Object[] que;
      	private int size;
      	
      	/**
      	 * 构造函数 设初始值
      	 * @param s 模拟队列长度
      	 */
      	public QueueDemo(int s) {
      		size = s;
      		front = 0;
      		last = 0;
      		que = new Object[size];
      	}
      	
      	/**
      	 * 入队
      	 * @param o 入队对象
      	 */
      	public void queuePush(Object o) {
      		if(last == size) {
      			queueLarge();
      		}
      		que[last++] = o;
      	}
      	
      	/**
      	 * 扩容
      	 */
      	public void queueLarge() {
      		Object[] obj = new Object[size * 2];
      		System.arraycopy(que, 0, obj, 0, size);
      		que = obj;
      		size *= 2;
      	}
      	
      	/**
      	 * 出队
      	 * @return 出队的对象
      	 */
      	public Object queuePop() {
      		if(queueEmpty()) {
      			return null;
      		}
      		Object o = que[front];
      		que[front++] = null;
      		return o;
      	}
      		
      	/**
      	 * 得到队首元素
      	 * @return 队首对象
      	 */
      	public Object getFront() {
      		if(queueEmpty()) {
      			return null;
      		}
      		return que[front];
      	}
      	
      	/**
      	 * 判断队列是否为空
      	 * @return true空
      	 */
      	public boolean queueEmpty() {
      		return front == last;
      	}
      	
      	/**
      	 * 求队列元素个数
      	 * @return int类型
      	 */
      	public int queueSize() {
      		return last - front;
      	}
      }