线性栈和单向链表的实现

线性栈

数组实现

public class Stack {
	public static void main(String[] args) {
		myStack S1 = new myStack();
		//打印初始栈
		S1.print();
		//1,11,111进栈后打印
		S1.instack(1);
		S1.instack(11);
		S1.instack(111);
		S1.print();
		//弹栈1次后打印
		S1.outstack();
		S1.print();
		//打印栈顶元素
		System.out.println(S1.top());
		//打印此时元素个数
		System.out.println(S1.number());
		//清空栈并打印
		S1.clear();
		S1.print();
	}
}
//自定义线性栈
class myStack{
	private int size;//栈内元素有效长度||当前要添加元素对应的角标位置
	private int[] array;//栈内元素容器	
	public myStack() {
		this(10);//初始化栈容量为10
	}
	//初始化栈构造函数
	public myStack(int begin) {
		this.array = new int[begin];
		this.size = 0;
	}
	//进栈
	public void instack(int e) {
		//满栈后扩充栈容量（2倍扩充）
		if(size == array.length) {
			extend(array.length * 2);
		}
		//元素e进栈，有效长度加1
		array[size] = e;
		size++;
	}
	//出栈
	public int outstack() {
		if(size == 0) {
			System.out.println("栈为空！");
		}
		//转移栈顶元素，有效长度-1
		int e = array[size - 1];
		size--;
		//栈容量至少为10，当 有效长度 < 栈容量一半 时，缩减栈容量（1/2缩小）
		if(size < array.length / 2 && array.length > 10) {
			extend(array.length / 2);
		}
		//返回出栈元素
		return e;
	}
	//获取栈顶元素
	public int top() {
		return array[size - 1];
	}
	//获取栈内元素个数
	public int number() {
		return size;
	}
	//清空栈
	public void clear() {
		size = 0;
		array = new int[10];
	}
	//打印栈内元素
	public void print() {
		if(size == 0) {
			System.out.println("栈为空！");
		}else {
			String s = "栈内元素：[";
			for(int i = 0;i < size;i++) {
				if(i == size - 1) {
					s += array[i]+"]top";
				}else {
					s += array[i]+",";
				}
			}
			System.out.println(s);
		}
	}
	//改变栈的容量
	public void extend(int e) {
		int[] newarray = new int[e];
		for(int i = 0;i < Math.min(array.length, newarray.length);i++) {
			newarray[i] = array[i];
		}
		//新栈容器赋值给原栈
		array = newarray;
	}
}

单向链表

头插法实现

public class linkStack{
	public static void main(String[] args) {
		myLinkStack stack=new myLinkStack();
		//打印初始栈
		stack.print();
		//进栈10个元素并打印
		for(int i = 0;i < 10;i++) {
			stack.inLinkStack(i);
		}
		stack.print();
		//弹栈3次并打印
		for(int i = 0;i < 3;i++) {
			stack.outLinkStack();
		}
		stack.print();
		//输出当前栈顶元素
		System.out.println(stack.top());
		//打印当前栈内元素个数
		stack.number();
		//清空栈并打印
		stack.clear();
		stack.print();
	}
}
class myLinkStack {
	private int size;//当前栈实际长度
	private Node head;//头结点，不存储元素
	//初始化链栈
	public myLinkStack() {
		this.size = 0;
		this.head = new Node();
	}
	//节点类
	private class Node{
		int e;//元素(e)
		Node next;//下一个节点(next)
		//初始化节点
		public Node() {
			this(0,null);
		}
		public Node(int e,Node next) {
			this.e = e;
			this.next = next;
		}
	}
	//进栈(头插法)
	public void inLinkStack(int e) {
		/*
		Node n = new Node(e,null);将元素e封装为节点n
		n.next = head.next;将头节点的下一个节点（栈顶节点）赋给进栈节点的下一个节点
		head.next = n;将进栈节点赋给栈顶节点
		*/
		head.next = new Node(e,head.next);
		size++;//栈元素有效长度+1
	}
	//出栈（从栈顶释放）
	public int outLinkStack() {
		if(size == 0) {
			System.out.println("栈为空！");
			return -1;
		}else {
			Node p = head.next;//转移栈顶节点
			int e = p.e;//转移栈顶节点的元素
			head.next = p.next;//改变栈顶节点
			p = null;//释放栈顶节点
			size--;//栈元素有效长度-1
			return e;//返回弹栈元素
		}
	}
	//获取栈顶元素
	public int top() {
		return (size == 0)? -1:head.next.e;
	}
	////获取栈内元素个数
	public void number() {
		System.out.println("栈内元素个数为："+size);
	}
	//清空栈
	public void clear() {
		size = 0;
		head = null;
	}
	//打印栈内元素
	public void print() {
		if(size == 0) {
			System.out.println("栈为空！");
		}else {
			String path = "top[";
			Node p =head.next;
			while(true) {
				if(p.next != null) {//不为最后一个元素时
					path += p.e+",";
					p = p.next;
				}else {//为最后一个元素时
					path += p.e+"]";
					break;
				}
			}
			System.out.println(path);
		}
	}
}