数据结构java版之线性表，栈

<span style="font-size:32px;">单链表</span>

package com.zby.linkedlist;

import java.util.Scanner;

class Lnode{
	public char data;
	public Lnode next;
}

public class LinkedList {
	/*
	 * 1. 链表的头插法
	 */
	Scanner scanner = new Scanner(System.in);
	Lnode h;
	public void headInsert() {
		char ch;
		Lnode p;
		h = new Lnode();//建立头结点
		h.next=null;//使头结点的指针域为空
		String str = scanner.nextLine();
		int i = 0;
		while(i<str.length()){
			ch = str.charAt(i);
			p = new Lnode();//建立一个新结点p
			p.data = ch;//将ch赋给p的数据域
			p.next = h.next;//改变指针情况，p所指向的结点的指针域是空（head.next为空）
			h.next=p;//head所指向结点的指针域指向p
			i++;
		}
	}
	/*
	 * 2. 链表的尾插法
	 */
	public void tailInsert() {
		Lnode p,t;
		char ch;
		h = new Lnode();//声明头结点指针
		h.next = null;//链表为空时，h所指向的结点的指针域所指向的结点为空
		t = h;//创建一个h指针的拷贝
		String str = scanner.nextLine();
		int i = 0;
		while(i < str.length()) {
			ch = str.charAt(i);
			p = new Lnode();
			p.data = ch;
			p.next = null;
			t.next = p;
			t = p;
			i++;
		}
	}
	/*
	 * 3. 求链表的长度
	 */
	public int size() {
		Lnode p;
		int i = 0;
		p = h.next;
		while(p!=null) {
			i++;
			p = p.next;
		}
		return i;
	}
	/*
	 * 4. 在单链表的某个节点之后插入新结点
	 */
	public void insertElementAfter(Lnode p, char x) {
		Lnode s;
		s = new Lnode();
		s.data = x;
		s.next = p.next;
		p.next = s;
	}
	/*
	 * 5. 在单链表中第i个元素之前插入一个结点
	 */
	public int insertElementBefore(int i, char x) {
		Lnode p, s;
		int j;
		p = h;//初始化p，p是head指针的一份拷贝
		j = 0;
		while(p != null && j < i - 1) {//寻找第 i - 1 号结点
			p = p.next;
			j++;
		}
		if(p != null) {
			s = new Lnode();
			s.data = x;
			s.next = p.next;//s的指针域指向p的指针域所指向的元素（p的下一个元素）
			p.next = s;//p的指针域所指向的元素指向s
			return 1;
		}
		else
			return 0;
	}
	/*
	 * 6. 删除单链表中的某个节点的后继结点
	 */
	public void remove(Lnode p) {
		Lnode q;
		if(p.next != null) {
			q = p.next;//q为p的直接后继
			p.next = q.next;//p的next指针域指向q的next指针域所指向的结点
			q = null;//释放q
		}
	}
	/*
	 * 7. 单循环链表中的查找算法
	 */
	public Lnode get(char x) {
		Lnode p;
		p = h.next;//初始化p，p指针指向头结点指向的下一个结点
		while(p != h && x != p.data)//如果p不等于头结点并且p的数据域与x不相等，继续查找
			p = p.next;
		if(p == h)
			return null;
		return p;
	}
	/*
	 * 8. 单链表的逆置
	 */
	public int inverse(Lnode h) {
		Lnode r,p,q;
		p = h.next;
		if(p == null)
			return 0;
		else if(p.next == null)
			return 0;
		q = p;
		p = p.next;
		q.next=null;
		while(p != null) {
			r = p.next;
			p.next = q;
			q = p;
			p = r;
		}
		h.next = q;
		return 1;
	}
}

<span style="font-size:32px;">双向链表</span>

package com.zby.linkedlist;

class DulNode {
	public char data;
	public DulNode next;
	public DulNode prior;
}

public class DoubleLinkedList {
	
	DulNode h;
	
	/*
	 * 1. 双向循环链表的插入算法
	 * 在a，b结点之间插入结点s的步骤：
	 * 		1. s的前驱指向a
	 * 		2. a的后继指向s
	 * 		3. s的后继指向b
	 * 		4. b的前驱指向s
	 */
	public int insert(DulNode h, int i, char x){
		DulNode p, s;
		int j;
		p = h.next;//p为h所指向的下一个结点
		j = 1;
		//查找第i个元素
		while(p != h && j < i) {
			j++;
			p = p.next;
		}
		if(j == i) {
			s = new DulNode();//初始化s
			s.data = x;
			s.prior = p.prior;
			p.prior.next = s;
			s.next = p;
			p.prior = s;
			return 1;
		}
		else
			return 0;
	}
	/*
	 * 2. 双向循环链表删除某一结点
	 */
	char dele(DulNode h, int i) {
		char s;
		DulNode p;
		int j;
		p = h.next;
		j = 1;
		while(p != h && j < i) {
			j++;
			p = p.next;
		}
		if(j == i) {
			s = p.data;
			p.prior.next = p.next;
			p.next.prior = p.prior;
			p = null;
			return s;
		}
		else
			return 0;
	}
	
}

链栈

package com.zby.linkedstack;

class StackNode {
	int data;
	StackNode next;
}

public class LinkStack {
	StackNode top;
	LinkStack ls = new LinkStack();
	/*
	 * 1. 栈的初始化，建立一个空栈
	 */
	public LinkStack() {
		ls.top = null;
	}
	/*
	 * 2. 在链栈上实现进栈操作
	 */
	public void push(int x) {
		StackNode s = null;
		s = new StackNode();
		s.data = x;
		s.next = top;//s所指向结点的指针域指向top所指向的结点
		top = s;//top指向s所指向的结点
	}
	/*
	 * 3. 在链栈上实现出栈操作
	 * 若栈不空，删去栈顶元素并返回元素值，否则返回空元素null
	 */
	public int pop() {
		StackNode p = null;
		int x;
		if(top == null)
			return 0;
		else {
			x = top.data;
			p = top;
			top = p.next;
			p = null;
			return x;
		}
	}
}

链式队列

package com.zby.linkedqueue;

class NodeType {
	int data;
	NodeType next;
}

public class LinkQueue {
	public NodeType front;
	public NodeType rear;
	/*
	 * 1. 初始化操作
	 */
	public LinkQueue() {
		front = new NodeType();
		front.next = null;
		rear = front;
	}
	/*
	 * 2. 判断队列是否为空
	 */
	public boolean isEmpty() {
		if(front == rear)
			return true;
		return false;
	}
	/*
	 * 3. 求队列长度
	 */
	public int size() {
		int i = 0;
		NodeType p = front.next;
		while(p != null) {
			i++;
			p = p.next;
		}
		return i;
	}
	/*
	 * 4. 在链表队列上实现读队头元素操作
	 */
	public int head() {
		if(front == rear)
			return 0;
		else
			return (front.next.data);
	}
	/*
	 * 5. 队尾插入元素
	 */
	public void enQueue(int x) {
		NodeType s;
		s = new NodeType();
		s.data = x;
		s.next = null;
		rear.next = s;
		rear = s;
	}
	/*
	 * 6. 队头元素出队操作
	 */
	public int delQueue() {
		int x;
		NodeType p;
		if(front == rear)
			return 0;
		else {
			p = front.next;
			front.next = p.next;
			if(p.next==null) {
				rear = front;
			}
			x = p.data;
			p = null;
			return x;
		}
	}
}