数据结构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;
}
}
}