数据结构基础（三）广义表

广义表是线性表的推广。区别在于：线性表的元素仅限于原子项；而广义表的元素即可以是原子项，也可以是广义表。

概念

定义：

广义表是n (n>=0)个元素a1,a2,a3,…,an的有限序列，其中ai或者是原子项，或者是一个广义表（子表）。不为空时，a1为表头（Header）,其余元素组成的表（a2,a3,……，an）是LS的表尾（Tail）

结构：

采用链式结构，节点分为原子节点（tag,atom）,以及表节点（tag,hp,tp）
tag:0为原子节点，1为表节点
atom:原子节点的值
hp:子表表头
tp:子表表尾

递归特性

由表头、表尾的定义可知：任何一个非空广义表其表头可能是原子，也可能是列表，而其表尾必定是列表。每个表尾又可以继续分为表头，表尾……

实现代码

注意点：

• 代码中实现了广义表的创建，插入，获取深度、长度，输出广义表字符串等功能。
• 采用了递归思想实现创建，获取深度。
  依照广义表定义，创建时可以每次把字符串分为表头和表尾，依次创建每个表头的节点，最终实现广义表。但考虑到这样做递归次数太多，代码中修改成只递归表节点。

package test;

import java.util.ArrayList;
import java.util.List;

/**
 * 广义表
 */
public class GList {

    /**
     * 广义表的头节点
     */
    private Node hNode;
    /**
     * 广义表的尾部节点，方便添加节点
     */
    private Node lastNode;
    /**
     * 广义表长度
     */
    private int length = 0;;

    /**
     * 广义表节点
     */
    private static class Node {
        // 0为值节点，1为广义表节点
        public int tag;
        //原子节点使用的值域
        public String atom;
        //表节点使用的表头
        public Node hp;
        //指向下一个节点
        public Node tp;

        public Node(int tag, String atom) {
            this.tag = tag;
            this.atom = atom;
        }

        public Node(int tag, Node hp) {
            this.tag = tag;
            this.hp = hp;
        }

    }

    /**
     * 空构造
     */
    public GList() {
        hNode = lastNode = null;
    }

    /**
     * 依据字符串构造出广义表
     * 
     * @param gl
     */
    public GList(String gl) {
        hNode = createGList(gl);
        lastNode = getTailNode();
    }

    /**
     * 返回广义表长度
     * 
     * @return
     */
    public int getLength() {
        return length;
    }

    /**
     * 向广义表中添加元素
     * @param n
     */
    public void add(Node n) {
        length++;
        if (lastNode == null) {
            hNode = lastNode = n;
            return;
        }
        lastNode = lastNode.tp = n;
    }

    /**
     * 返回广义表头节点
     * @return
     */
    public Node getHead() {
        return hNode;
    }

    /**
     * 返回广义表尾部节点
     * @return
     */
    public Node getTailNode() {
        if (lastNode != null)
            return lastNode;

        Node n = hNode;
        length = 1;
        while (n != null && n.tp != null) {
            n = n.tp;
            length++;
        }
        return n;
    }
    /**
     * 返回广义表的尾节点
     * @return
     */
    public GList getTail() {
        GList gList=new GList();
        gList.hNode=hNode.tp;
        return gList;
    }

    /**
     * 获取广义表深度
     * @return
     */
    public int getGListDepth() {
        if (hNode == null)
            return 0;
        return 1 + getDepth(hNode);
    }

    @Override
    public String toString() {
        return doList(hNode);
    }

    /**
     * 以一节点为头节点获取深度
     * @param n
     * @return
     */
    private int getDepth(Node n) {
        if (n == null)
            return 0;
        //如为原子节点则深度为0，表节点=子表深度加1
        int depth = (n.tag == 0 ? 0 : 1 + getDepth(n.hp));
        //递归比较相邻节点深度
        int depthNext = getDepth(n.tp);
        return depth > depthNext ? depth : depthNext;
    }

    /**
     * 以一节点为头节点返回生成的广义表字符串
     * @param n
     * @return
     */
    private String doList(Node n) {
        if (n == null)
            return null;
        String result = "(";
        boolean isBegin = false;
        while (n != null) {
            //原子节点直接拼接其atom值
            if (n.tag == 0) {
                if (isBegin == false) {
                    result += n.atom;
                    isBegin = true;
                } else {
                    result += "," + n.atom;
                }
            } 
            //表节点进行递归
            else {
                if (isBegin == false)
                    result += doList(n.hp);
                else {
                    result += "," + doList(n.hp);
                }
            }
            n = n.tp;
        }
        result = result.substring(0, result.length()) + ")";
        return result;
    }

    /**
     * 根据字符串生成广义表
     * @param gl
     * @return 返回生成广义表的头结点
     */
    private Node createGList(String gl) {
        Node hN = null;
        Node n = null;
        //获取初步分割后的节点集合，此时表节点atom为表字符串，hp未指定
        List<Node> list = splitGL(gl);

        int size = list.size();
        //将表节点hp指定，并连接相邻节点
        for (int i = 0; i < size; i++) {
            n = list.get(i);
            if (n.tag == 1) {
                n.hp = createGList(n.atom);
            }
            if (i > 0)
                list.get(i - 1).tp = n;
        }
        hN = list.get(0);
        return hN;
    }

    /**
     * 将广义表字符串单元分割，每个划分单元放入一个Node，划分的字符串放入Node.atom
     * @param gl
     * @return
     */
    private List<Node> splitGL(String gl) {
        // 去除左右两边括号
        gl = gl.substring(1, gl.length() - 1).trim();
        // 最后加上','方便末尾片段的分割
        char[] gchar = (gl + ",").toCharArray();
        //标记分割字符单元有几个括号
        int flag = 0;
        //分割字符单元生成的Node集合
        List<Node> list = new ArrayList<Node>();
        //分割字符单元
        String segment = "";

        for (int i = 0; i < gchar.length; i++) {
            if (gchar[i] == '(')
                flag++;
            else if (gchar[i] == ')')
                flag--;
            //若一个字符单元结束
            if ((gchar[i] == ',' && flag == 0)) {
                if (segment.contains("("))
                    list.add(new Node(1, segment));
                else
                    list.add(new Node(0, segment));
                segment = "";
                continue;
            }
            segment += gchar[i];
        }

        return list;
    }

    public static void main(String[] args) {
        GList gList = new GList(
                "(aa,(aa,bb,cc,(aaa)),c,(aa,(ccc,(eeee)),dd),k)");
        gList.add(new Node(0, "haha"));
        System.out.println(gList);
        System.out.println(gList.getGListDepth());
        System.out.println(gList.getLength());
        System.out.println("-----------------");
        GList gList2 = new GList("(a,b)");
        System.out.println(gList2);
        System.out.println(gList2.getGListDepth());
        System.out.println(gList2.getLength());

    }

}/**output:
(aa,(aa,bb,cc,(aaa)),c,(aa,(ccc,(eeee)),dd),k,haha)
4
6
-----------------
(a,b)
1
2*/