实现单向队列(Java)、

1、实现单向队列 

package app;

public class MyQueue {

	private Object[] queArray;
	//队列总大小
	private int maxSize;
	//前端
	private int front;
	//后端
	private int rear;
	//队列中元素的实际数目
	private int nItems;
	
	public MyQueue2(int s) {
		maxSize = s;
		queArray = new Object[maxSize];
		front = 0;
		rear = -1;
		nItems = 0;
	}
	
	//队列中新增数据
	public void insert(int value) {
		if(isFull()) {
			System.out.println("队列已满!!!");
		}else {
			//如果队列尾部指向顶了，那么循环回来，执行队列的第一个元素
			if(rear == maxSize - 1) {
				rear = -1;
			}
			
			queArray[++rear] = value;
			nItems++;
		}
	}
	
	//移除数据
	public Object remove() {
		Object removeValue = null;
		if(!isEmpty()) {
			removeValue = queArray[front];
			queArray[front] = null;
			front++;
			if(front == maxSize) {
				front = 0;
			}
			
			nItems--;
			return removeValue;
		}
		
		return removeValue;
	}
	
	//查看对头数据
	public Object peekFront() {
		return queArray[front];
	}
	
	//判断队列是否满了
	public boolean isFull() {
		return (nItems == maxSize);
	}
	
	//判断队列是否为空
	public boolean isEmpty() {
		return (nItems == 0);
	}
	
	//返回队列的大小
	public int getSize() {
		return nItems;
	}
	
	
	public static void main(String[] args) {
		
		MyQueue queue = new MyQueue(3);
        queue.insert(1);
        queue.insert(2);
        queue.insert(3);//queArray数组数据为[1,2,3]
         
        System.out.println(queue.peekFront()); //1
        queue.remove();//queArray数组数据为[null,2,3]
        System.out.println(queue.peekFront()); //2
         
        queue.insert(4);//queArray数组数据为[4,2,3]
        queue.insert(5);//队列已满,queArray数组数据为[4,2,3]
	}
	
	
	
	
	
}

 

2、实现单向链表

package app;

/**
 * 单向链表的具体实现
 * @author Administrator
 *
 */
public class MySingleLinkedList {

	private int size;
	private Node head;
	
	public MySingleLinkedList() {
		size = 0;
		head = null;
	}
	
	//在链表头插入元素
	public Object addHead(Object data) {
		
		Node newNode = new Node(data);
		if(size == 0) {
			head = newNode;
		}else {
			newNode.next = head;
			head = newNode;
		}
		
		size++;
		return data;
	}
	
	//链表头删除元素
	public Object deleteHead() {
		Object obj = head.data;
		head = head.next;
		size--;
		return obj;
	}
	
	//查找指定元素，找到了返回节点的Node,找不到返回null
	public Node find(Object data) {
		
		Node current = head;
		int tmpSize = size;
		while(tmpSize > 0) {
			
			if(data.equals(current)) {
				return current;
			}else {
				current = current.next;
			}
			
			tmpSize--;
		}
		
		return null;
	}
	
	//删除指定的元素
	public boolean delete(Object data) {
		
		if(size == 0) {
			return false;
		}
		
		Node current = head;
		Node previous = head;
		while(previous.data != data) {
			
			if(current.next == null) {
				return false;
			}else {
				previous = current;
				current = current.next;
			}
			
		}
		
		//如果删除的节点是第一个节点
		if(current == head) {
			head = current.next;
			size--;
		}else { //删除的节点不是第一个节点
			previous.next = current.next;
			size--;
		}
		
		return true;
	}
	
	//判断链表是否为空
	public boolean isEmpty() {
		return (size == 0);
	}
	
	//显示节点信息
	public void display() {
		if(size > 0) {
			Node node = head;
			int tmpSize = size;
			if(tmpSize == 1) {
				System.out.println("["+node.data+"]");
				return;
			}
			
			while(tmpSize > 0) {
				if(node.equals(head)) {
					System.out.print("["+node.data+"->");
				}else if(node.next == null){
					System.out.print(node.data+"]");
				}else {
					System.out.print(node.data+"->");
				}
				
				node = node.next;
				tmpSize--;
			}
			
			System.out.println();
		}else {
			System.out.println("[]");
		}
	}
	
	public static void main(String[] args) {
		
		MySingleLinkedList sl = new MySingleLinkedList();
		sl.addHead(1);
		sl.addHead(2);
		sl.addHead(3);
		sl.addHead(4);
		sl.addHead(5);
		sl.display();
	}
}