广义表是对线性表的扩展——线性表存储的所有的数据都是原子的（一个数或者不可分割的结构），且所有的数据类型相同。而广义表是允许线性表容纳自身结构的数据结构。
广义表定义：
广义表是由n个元素组成的序列：LS = （a1，a2, ... an）;其中 ai是一个原子项或者是一个广义表。n是广义表的长度。若ai是广义表，则称为LS的子表。
广义表表头和表尾： 若广义表LS不空，则a1，称为LS的表头，其余元素组成的子表称为表尾。
广义表的长度： 若广义表不空，则广义表所包含的元素的个数，叫广义表的长度。
广义表的深度： 广义表中括号的最大层数叫广义表的深度。
例如：
对广义表LS=((),a,b,(a,b,c),(a,(a,b),c))
表头为子表LSH = ();
表尾为子表LST = (a,b,(a,b,c),(a,(a,b),c));
广义表LS的长度：5
广义表LS的深度：3
对于广义表的操作都是建立在已经构建好的广义表上，那么如何通过一个广义表字符串构造一个广义表？
广义表的存储结构——广义表有多重存储结构，以下只讲代码中使用的存储结构，代码中采用以下存储结构：
| tag | data | pH | pT |
tag ：tag == 0 ； 表示该节点为原子节点 。tag == 1 ； 表示该节点为表节点
data ：data是原子节点的数据，为表节点时该值域无效。
pH ：广义表的表头——是一个表节点或原子节点。
pT ：广义表的表尾——必定是一个表节点 或者 null。
表节点存储结构选择好了，那么如何来构造广义表呢？（比如：LS = ((),a,b,(a,b,c),(a,(a,b),c))）， 根据以下规则，构造出来的广义表如下图：
header表示表头 ， 带圈的指针表示由该符号创建的对应的节点（为了图片清晰有些节点没有画）。
对于一个广义表总有一个header节点指向该表的表节点，一个node表示当前正在操作的节点。
当遇到‘(’ 时构造一个表节点，并且将该符号压栈charStack，如果栈中的数据长度 > 1 ， 表明广义表的深度加深一层 ，此时将该节点压入栈nodeStack，并且让node的pH节点指向新构造的节点。其代码如下：
if (ts.charAt(i) == mStartSymb) {
tmpNode = new Node(null, null, TAG_TABLE, null);
// tableNode = tableNode.mPt;
symbStack.push(ts.charAt(i));
if (symbStack.size() > 1) {
nodeStck.push(tableNode);
tableNode.mPh = tmpNode;
tableNode = tableNode.mPh;
} else {
tableNode.mPt = tmpNode;
tableNode = tableNode.mPt;
}
} 其中mStartSymb 表示广义表的 '表起始指示符' ， symbStack.push(ts.charAt(i));将 '表起始指示符压栈' ， 接下来判断symbStack栈的大小，代码：
nodeStck.push(tableNode);
tableNode.mPh = tmpNode;
tableNode = tableNode.mPh;
将当前的表节点压栈 ， 接着表头指向新的node ， 当前节点向前滑动一个位置。
当遇到原子节点符号(如：’a‘) 时，则创建一个原子节点，并且让表头指向该节点，其代码如下：
else {
itemNode = new Node(null, null, TAG_ITEM, ts.charAt(i));
tableNode.mPh = itemNode;
}当遇到符号 ’,‘ 时构造一个表节点，让当前节点的表尾指向新的节点，其代码如下：
else if (ts.charAt(i) == ',') {
tableNode.mPt = new Node(null, null, TAG_TABLE, null);
tableNode = tableNode.mPt;
}当遇到符号 ')' 时，做两件事
1、如果 symbStack 的长度 > 1 , 表明此时并没有回到表的最外层，肯定存在一个nodeStack中的节点需要出栈，接着让与之对应的 ’(‘ 符号出栈，其代码如下：
else if (ts.charAt(i) == mEndSymb) {
if (symbStack.isEmpty()) {
throw new IllegalArgumentException(
"IllegalArgumentException in constructor GeneralizedTable!...");
}
if (symbStack.size() > 1) {
tableNode = nodeStck.pop();
}
symbStack.pop();
}当表字符串结束，切symStack的长度为0时，表明是一个格式正确的表字符串，否则说明该表字符串的格式错误，不予处理。
至此，一个广义表就构造OK了。根据上述原理，构造一个广义表的完整代码如下：
public GeneralizedTable(String genTable) {
if (genTable == null) {
throw new NullPointerException(
"genTable is null in constructor GeneralizedTable!...");
}
initTable(genTable);
}
private void initTable(String genTable) {
String ts = genTable.replaceAll("\\s", "");
int len = ts.length();
Stack<Character> symbStack = new Stack<Character>();
Stack<Node> nodeStck = new Stack<Node>();
initSymbolicCharactor(ts);
mGenTable = new Node(null, null, TAG_TABLE, null);
Node itemNode, tableNode = mGenTable, tmpNode;
for (int i = 0; i < len; i++) {
if (ts.charAt(i) == mStartSymb) {
tmpNode = new Node(null, null, TAG_TABLE, null);
// tableNode = tableNode.mPt;
symbStack.push(ts.charAt(i));
if (symbStack.size() > 1) {
nodeStck.push(tableNode);
tableNode.mPh = tmpNode;
tableNode = tableNode.mPh;
} else {
tableNode.mPt = tmpNode;
tableNode = tableNode.mPt;
}
} else if (ts.charAt(i) == mEndSymb) {
if (symbStack.isEmpty()) {
throw new IllegalArgumentException(
"IllegalArgumentException in constructor GeneralizedTable!...");
}
if (symbStack.size() > 1) {
tableNode = nodeStck.pop();
}
symbStack.pop();
} else if (ts.charAt(i) == ',') {
tableNode.mPt = new Node(null, null, TAG_TABLE, null);
tableNode = tableNode.mPt;
} else {
itemNode = new Node(null, null, TAG_ITEM, ts.charAt(i));
tableNode.mPh = itemNode;
}
}
if (!symbStack.isEmpty()) {
throw new IllegalArgumentException(
"IllegalArgumentException in constructor GeneralizedTable!...");
}
}
private void initSymbolicCharactor(String ts) {
mStartSymb = ts.charAt(0);
switch (mStartSymb) {
case '(':
mEndSymb = ')';
break;
case '{':
mEndSymb = '}';
break;
case '[':
mEndSymb = ']';
break;
default:
throw new IllegalArgumentException(
"IllegalArgumentException ---> initSymbolicCharactor");
}
}注释：本代码中支持 ( , ) , { , } , [ , ] 为"广义表标示符"的广义表字符串（默认是()）。
求广义表的长度： 根据广义表长度的定义，该表的长度，等于原子节点或表节点的个数，即 header.pT != null 的个数 ， 其代码如下：
public int length() { // 广义表的长度
if (mGenTable == null || mGenTable.mPt == null) {
return -1;
}
int tLen = 0;
Node node = mGenTable;
while (node.mPt != null) {
node = node.mPt;
if (node.mPh == null && node.mPt == null) {
break;
}
tLen++;
}
return tLen;
}广义表的深度：因为广义表由
表头 和
表尾 组成 ， 所以 ， 广义表的深度是 表头、表尾中的最大深度。由此定义，得到如下代码：
public int depth() { // 广义表的深度
if (mGenTable == null) {
throw new NullPointerException("Generalized Table is null !.. ---> method depth");
}
return depth(mGenTable);
}
private int depth(Node node) {
if (node == null || node.mTag == TAG_ITEM) {
return 0;
}
int depHeader = 0, depTear = 0;
depHeader = 1 + depth(node.mPh);
depTear = depth(node.mPt);
return depHeader > depTear ? depHeader : depTear;
}广义表的表头：广义表的第一项称为表头，表头可能是一个原子项和广义表。但是不管如何，他都是第一个的pH指向的内容：其代码如下：
public GeneralizedTable getHeader() {
if (isEmpty())
return null;
Node node = mGenTable.mPt;
GeneralizedTable gt = new GeneralizedTable();
gt.mGenTable.mPt = node.mPh;
return gt;
}广义表的表尾：广义表的表尾必定是一个广义表，但不管由什么子表组成，都是广义表的pT所指向的内容：求解广义表表尾的代码如下：
public GeneralizedTable getTear() {
if (isEmpty())
return null;
Node node = mGenTable.mPt;
GeneralizedTable gt = new GeneralizedTable();
gt.mGenTable.mPt = node.mPt;
return gt;
}打印广义表的内容：这里打印广义表内容是指，打印所有原子项中的数据，一个深度优先打印的代码如下：
public void print() {
print(mGenTable);
}
private void print(Node node) {
if (node == null) {
return;
}
if (node.mTag == 0) {
System.out.print(node.mData.toString() + " \t");
}
print(node.mPh);
print(node.mPt);
}下面是整个广义表操作的代码：
import java.util.Stack; /**
* 广义表操作：
* 1、广义表的构造 ：
* 1.1 构造一个空的广义表
* 1.2 根据现有的广义表，构造一个新的广义表
* 1.3 根据广义表字符串构造一个广义表
* 2、广义表的深度
* 3、广义表的长度
* 4、按照深度优先顺序打印广义表
* 5、求广义表表头
* 6、求广义表表尾
*
*/
public class GeneralizedTable { public static final int TAG_ITEM = 0; // 原子节点
public static final int TAG_TABLE = 1; // 表节点
/*
* 广义表支持的符号包括'(' , ')' , '{' , '}' , '[' , ']'
* 广义表表示符号,使用字符串构造广义表时第一个字符必须是'(', '{' , '[' 之一 并以')' , '}' , ']' 之一结束，
* 并且各符号相对应
*/
private char mStartSymb = '(';
private char mEndSymb = ')';
private Node mGenTable; public GeneralizedTable() {
mGenTable = new Node(null, null, TAG_TABLE, null);
} // 使用广义表 src 构造一个新的广义表
public GeneralizedTable(GeneralizedTable src) {
if (src != null) {
mGenTable = src.mGenTable;
} } /**
* @param genTable
*/
public GeneralizedTable(String genTable) {
if (genTable == null) {
throw new NullPointerException(
"genTable is null in constructor GeneralizedTable!...");
}
initTable(genTable);
} private void initTable(String genTable) {
String ts = genTable.replaceAll("\\s", "");
int len = ts.length();
Stack<Character> symbStack = new Stack<Character>();
Stack<Node> nodeStck = new Stack<Node>();
initSymbolicCharactor(ts);
mGenTable = new Node(null, null, TAG_TABLE, null);
Node itemNode, tableNode = mGenTable, tmpNode;
for (int i = 0; i < len; i++) {
if (ts.charAt(i) == mStartSymb) {
tmpNode = new Node(null, null, TAG_TABLE, null);
// tableNode = tableNode.mPt;
symbStack.push(ts.charAt(i));
if (symbStack.size() > 1) {
nodeStck.push(tableNode);
tableNode.mPh = tmpNode;
tableNode = tableNode.mPh;
} else {
tableNode.mPt = tmpNode;
tableNode = tableNode.mPt;
}
} else if (ts.charAt(i) == mEndSymb) {
if (symbStack.isEmpty()) {
throw new IllegalArgumentException(
"IllegalArgumentException in constructor GeneralizedTable!...");
}
if (symbStack.size() > 1) {
tableNode = nodeStck.pop();
}
symbStack.pop();
} else if (ts.charAt(i) == ',') {
tableNode.mPt = new Node(null, null, TAG_TABLE, null);
tableNode = tableNode.mPt;
} else {
itemNode = new Node(null, null, TAG_ITEM, ts.charAt(i));
tableNode.mPh = itemNode;
}
} if (!symbStack.isEmpty()) {
throw new IllegalArgumentException(
"IllegalArgumentException in constructor GeneralizedTable!...");
}
} private void initSymbolicCharactor(String ts) {
mStartSymb = ts.charAt(0);
switch (mStartSymb) {
case '(':
mEndSymb = ')';
break;
case '{':
mEndSymb = '}';
break;
case '[':
mEndSymb = ']';
break;
default:
throw new IllegalArgumentException(
"IllegalArgumentException ---> initSymbolicCharactor");
}
} public void print() {
print(mGenTable);
} private void print(Node node) {
if (node == null) {
return;
}
if (node.mTag == 0) {
System.out.print(node.mData.toString() + " \t");
}
print(node.mPh);
print(node.mPt); } public int depth() { // 广义表的深度
if (mGenTable == null) {
throw new NullPointerException("Generalized Table is null !.. ---> method depth");
}
return depth(mGenTable);
} private int depth(Node node) {
if (node == null || node.mTag == TAG_ITEM) {
return 0;
}
int depHeader = 0, depTear = 0;
depHeader = 1 + depth(node.mPh);
depTear = depth(node.mPt);
return depHeader > depTear ? depHeader : depTear;
} public int length() { // 广义表的长度
if (mGenTable == null || mGenTable.mPt == null) {
return -1;
}
int tLen = 0;
Node node = mGenTable;
while (node.mPt != null) {
node = node.mPt;
if (node.mPh == null && node.mPt == null) {
break;
}
tLen++;
}
return tLen;
} public GeneralizedTable getHeader() {
if (isEmpty())
return null;
Node node = mGenTable.mPt;
GeneralizedTable gt = new GeneralizedTable();
gt.mGenTable.mPt = node.mPh;
return gt;
} public GeneralizedTable getTear() {
if (isEmpty())
return null;
Node node = mGenTable.mPt;
GeneralizedTable gt = new GeneralizedTable();
gt.mGenTable.mPt = node.mPt;
return gt;
} public boolean isEmpty() {
if (mGenTable == null) {
return true;
}
Node node = mGenTable.mPt;
return node == null || node.mPh == null;
} public class Node {// 广义表节点
Node mPh; // 广义表的表节点
Node mPt; // 广义表表尾节点
int mTag; // mTag == 0 , 院子节点 ; mTag == 1 , 表节点 。
Object mData; // 广义表的数据值 public Node(Node ph, Node pt, int tag, Object data) {
mPh = ph;
mPt = pt;
mTag = tag;
mData = data;
}
} /**
* @param args
*/
public static void main(String[] args) {
// String tStr = "((),(a,b,c),a,d,((d,g,(c))),(k,g),c)";
String p = "((),a,b,(a,b,c),(a,(a,b),c))";
String p2 = "((()),2)";
// String space = "()";
String big = "{{a,b},{{a,g},{h},{a,n,f,{a,b,c}}},c}";
String middle = "[[p],[[d,f,[g]]],[h],[2]]";
GeneralizedTable gTab = new GeneralizedTable(middle);
// GeneralizedTable header, tear;
// // gTab.print();
// // System.out.println();
System.out.println("length: " + gTab.length());
System.out.println("depth: " + gTab.depth());
//
// header = gTab.getHeader();
// if (header != null) {
// System.out.println("header: ");
// header.print();
// }
// tear = gTab.getTear();
//
// if (tear != null) {
// System.out.println("tear: ");
// tear.print();
// }
// gTab.print();
// System.out.println();
// GeneralizedTable gTab4 = null;
// GeneralizedTable gTab2 = new GeneralizedTable(gTab4);
// gTab2.print();
// gTab2 = new GeneralizedTable(gTab);
// gTab2.print();
} }
广义表的内容就先写到这里 ， 后续有新内容再补充 。