Java算法

1. 利用数组实现一个栈（先进后出）

元素辅助数组arr，栈实际容量size，初始容量initialSize

栈的常用操作：入栈push()，出栈pop()，取栈顶元素peek()，获取栈的元素个数或者实际容量size()，判空isEmpty()

1.1 在构造栈对象时可以给一个默认初始容量。

1.2 push()时栈满需要扩容(双倍)，利用Arrays.copyOf(arr,newSize)。

1.3 pop()时栈空需要报错。

public class ArrImplStack {

	private int[] arr;

	private int size = 0;

	private int initialSize = 15;

	public ArrImplStack() {
		arr = new int[initialSize]; // 分配初始数组空间给此栈
	}

	public void push(int value) {
		// 栈已满,需要扩容:copyOf()底层先开辟一个initialSize*2大小的新数组,然后将原数组arraycopy到新数组并返回新数组
		if (size == initialSize) {
			arr = Arrays.copyOf(arr, initialSize * 2);
		}
		arr[size++] = value;
	}

	public int pop() {
		if (size == 0) {    //size已经指向索引0，不能再往下了
			throw new IndexOutOfBoundsException("栈已空");
		}
		return arr[--size];
	}

	public int peek() {
		if (size == 0) {
			throw new IndexOutOfBoundsException("栈已空");
		}
		int index = size - 1;
		return arr[index];
	}
	
	public boolean isEmpty(){
		return size==0;
	}
	
	public int size() {
		return size;
	}
}

2. 利用数组实现一个循环队列（先进先出）

辅助数组arr，指向待删除节点位置的头指针front，指向待插入位置的尾指针rear，循环队列的最大容量maxSize。

队列的常用操作：入队列enQueue()，出队列deQueue()，获取队列实际容量或者元素个数size()，判空isEmpty()，返回队列头指针getHead()

2.1 构造循环队列时可指定最大容量，利用构造方法。

2.2 为了判断队列满还是空，牺牲了一个存储单元。

当（rear+1）% maxSize = front，即rear的下一个位置就是front，追上front，表示队列已满。此时牺牲的单元就是rear指向的单元。enQueue()时需要判断队列是否满，有地儿则入队列，rear = (rear+1)%maxSize，因为是循环队列，有可能回到0重新开始。

当front = rear ，front追上rear，表示队列空，待删除的位置就是待插入的位置，没得删啊。deQueue()时需要判断队列是否为空，有值则出队列，front=(front+1)%maxSize，同样因为是循环队列的原因。

2.3 获取当前循环队列大小（元素个数）时，别忘了(rear-front+maxSize)%maxSize，因为rear-front有可能为负数。

public class ArrImplCirQueue {

	private int[] arr;

	private int front = 0;                   //指向队头元素(待删除位置)

	private int rear = 0;                    //指向队尾元素下一个位置(待插入位置)

	public int maxSize = 15;                 //循环队列默认大小

	public ArrImplCirQueue(int maxSize) {
		this.maxSize = maxSize;
		arr = new int[maxSize];              //构造指定大小的循环队列
	}

	//入队
	public boolean enQueue(int value) {      
		if (front == (rear+1) % maxSize) {   //rear下一个位置就是front,表示队列已满
			System.out.println("循环队列已满");
			return false;
		}
		arr[rear] = value;                   //元素插入队尾
		rear = (rear + 1) % maxSize;         //指向下一个待插入位置,有可能从0位置继续入队
		return true;
	}

	//出队
	public int deQueue() {
		if (front == rear) {                 //待删除位置就是待插入位置，没得删
			System.out.println("循环队列已空");
			return -1;
		}
		int item = arr[front];               
		arr[front] = 0;                      //删除元素置为0即可
		front = (front + 1) % maxSize;       //指向待删除元素,有可能从0位置继续出队
		return item;
	}
	
	//返回队头元素
	public int getHead(){
		if (front == rear) {                 
			System.out.println("循环队列已空");
			return -1;
		}
		return arr[front];
	}

	//判空
	public boolean isEmpty() {
		return front == rear;
	}

	//当前长度(元素个数)
	public int size() {
		return (rear - front + maxSize) % maxSize;  //不加maxSize有可能为负数
	}

}

3. 自定义一个链表

单链表由一个个节点连接而成。节点listNode：数据域data，指向下一个节点的next指针域。访问权限为default（同包下能访问就行），这里让数据域能存放任意类型的节点。

public class ListNode{
	
	//数据
	Object data;    //default,包权限
	//下一个节点
	ListNode next;
}

链表包含元素：头节点first，尾节点last，长度size。

链表的常用操作：插入addNode()，删除deleteNode()，判空isEmpty()，获取链表实际长度size()，获取头节点getFist()，获取尾节点getLast()几大功能。

3.1 addNode()时传的是数据，需要先构建一个节点出来，然后判断头节点first是否还是默认初始值null，是的话将first指向新节点，否则直接插在last后面，并且将last指向当前新节点。size还别忘了++。

3.2 deleteNode()比较麻烦，因为需要找到链表的倒数第二个节点，并将其next置null。只能根据头节点first依次遍历到倒数第二个节点(其next=last），先将last节点数据保存下来，将倒数第二个节点next置null，并将last指向它。size别忘了--。

public class MyList {
	
	//头节点
	private ListNode first;
	//尾节点
	private ListNode last; 
	//链表长度
	private int size;
	
	//添加
	public void addNode(Object item){ 
		//创建新节点
		ListNode nn = new ListNode();        
		//数据域
		nn.setData(item);
		//链表为空，第一次添加节点(头节点指向它)
		if(first == null){
			first = nn;
		}else{
			//尾节点指向当前新添加的节点
			last.setNext(nn);
		}
		//当前节点为新的尾节点
		last = nn;
		size++;
	}
	
	//删除单链表的最后一个节点(单链表只能从前往后遍历到倒数第二个节点，删除最后一个节点)
	public Object deleteNode(){
		ListNode tempNode = first;
		//头节点不为空,链表存在节点,遍历到倒数第二个节点为止
		while(tempNode!=null && tempNode.getNext()!=last){
			tempNode = tempNode.getNext();
		}	
		//返回尾节点的数据
		Object item = last.getData();
		//倒数第二个节点的next为空
		tempNode.setNext(last.getNext());
		//倒数第二个节点为尾节点
		last = tempNode;
		size--;
		return item;
	}
	
	//判空
	public boolean isEmpty(){
		return size==0;
	}
	
	//长度
	public int size(){
		return size;
	}
	
	//返回头节点
	public ListNode getFirst(){
		return first;
	}
	
	//返回尾节点
	public ListNode getLast(){
		return last;
	}
}

4. 反转一个链表（只给头节点head）

输出反转后链表的头节点(原链表的尾节点)。

拿到题目首先思考测试用例，再动手写代码。

4.1 特殊情况：头节点为null，只有一个节点，那直接返回头节点就行了丫。多省事。

4.2 一般情况：链表有多个节点。实现反转，也就是将每个当前节点的next指向其前一个节点，此时原链（指向其后一个节点）会断开，所以需要一个later指针出手，先记录下来。为了方便，当前节点的前一个节点也用pre标记着，只不过初始时赋值为null，因为反转后头节点head就是尾节点，其next就是null丫。

当later不为null时，就依次将当前节点mid的next指向pre节点，pre，当前指针mid，later依次后移，继续反转。

最后一次，later为null，当前节点的next还没指向倒数第二个节点，需要补充处理一下。

	//反转链表:只给此链表的头节点
	public static ListNode reverseList(ListNode head){
		//边界情况，头节点为空和链表只有一个节点，无需反转，直接返回头节点即可
		if(head==null || head.next==null){
			return head;
		}
		//初始时，头节点的next置空，当前节点为头节点，下一个节点要处理的节点为头节点的下一个节点
		//pre--mid--lat
		ListNode pre = null;
		ListNode mid = head;
		ListNode lat = head.next;
		while(lat!=null){      //当前节点已经是尾节点，但是还没有断链
			mid.next = pre;    //当前节点的下一个节点为前一个节点，断链
			pre = mid;         //当前节点归为前面已经反转好的节点
			mid = lat;         //待处理节点为当前节点的下一个节点
			lat = lat.next;    //待处理节点的下一个节点(用于判断是否到达尾节点)
		}
		mid.next = pre;        //处理原链表的最后一个节点
		return mid;
	}

5. 通过一次迭代：O(n) 找到LinkedList的中间元素

分析：单链表，要想获取长度，只能依次遍历到链表末尾。

           两个指针，指针p每次前进2时，指针q才前进1。当p到达链表末尾的时候，q刚好就是中间节点。

//假设链表非空
public static void main(String[] args) {
		
		MyList mList = new MyList();
		mList.addNode(1);
		mList.addNode(2);
		mList.addNode(3);
		mList.addNode(4);
		ListNode head = mList.getFirst();
		ListNode pListNode = head;
		ListNode qListNode = head;
		int len = 0;
		while(pListNode.next!=null){
			pListNode = pListNode.getNext();
			len++;
			if(len%2==0){
				qListNode = qListNode.getNext();
			}
		}
		len++;   //len从第二个节点开始加，所以长度要加上头节点
		System.out.println("链表的长度为："+len);
		System.out.println("中间节点为："+qListNode.toString());		
	}