struct {*elem ,length,size}
L init: 申请elem空间，如果申请成功，length=0;size =100
忽略：(SqList L),把声明过的列表用来初始化
int insert: elem是首地址，判断elem是否为空，空返回，否则获取elem[length]，if(length+1>100) {扩充空间}length++,elem[length]= data,return L
忽略：l ,insert(L,index,data) 1,判断index是否越界if(i<1 ||i>L.length) return error;
2 ,当前list是否满 (L.length >= L.size){扩充空间，如果扩充成功，新地址= 新空间，给最大长度加上扩充长度，否则退出}
3，p为当前元素，把p以后的位置向后移，插入，长度+1
void insertAfterTail :(list,data)在线性表的末尾插入一个元素，判断下标是否到最大值，如果到的话按照insert方法增加表空间，否则length++,最后一个的大小是data
int delete:（L，i,data）,判断i是否越界（i<1||i>L.length）return error;判断表是否为空，（L.length==0）return error;如果都满足，p = elem[i],i之后的数据向前移动一个，free(p)reutrnL
忽略：--length
int locate:(L.value):1,判断L的首地址是否存在，如果不存在返回error,存在的话elem[i]开始遍历，如果不遇到指针一直向后移，如果遇到退出循环，打印出i
忽略：不用判断首地址是否存在
顺序表合并： 两个升序排列的顺序表，合并成一个，i=j=0（i<La.length && j<Lb.length）在a,b两表都有值的情况下，{取 a.b的元素比较放最小值，放的下标+1}，如果两个元素不一样多，最后还剩下一个
if(i>=La.length){只对b操作} 同样b也是 最后返回c
忽略：刚开始c的长度=a+b长度之和，之后要申请c的空间，最后判断判断本表还未到达最大，不用判断另外一张表，因为从while执行下来肯定只剩一张表

linkedList
struct Lnode {datatype data,struct *next}Lnode,*LinkList
L getElem:（L，value）查看首地址是否存在，如果不存在exit(0)，如果存在一直遍历，知道next为空。如果中间遇到满足的元素，返回1，否则返回0
忽略：（L，i,e）当第i个元素存在时，把值赋给e并返回，上面的意思完全理解错了
1，遍历计数，直到i，如果i，p不满足退出，否则返回第i个元素
L crteateInit:(&L)加上头结点吧，next指向空，不用申请表空间，然后就没有然后了
忽略：（L，n）插入n个元素的值，循环技术并申请空间，输入数值，
int listInsert :(L,i,data)如果带头结点，先init,然后查看i是<0或者>list的长度，如果满足，如果i是最后一个，next=elem[i]，如果处于头结点和尾结点之间，i插入，不用挪动元素，
忽略：生成新结点，不带头结点
int listDelete:(L,i,e)寻找结点，如果位置不合理退出，如果合理删除，，，用不用区分i刚好是最后一个结点
将两个有序链表并成一个无序链表：分别取头结点，比较大小，插入，直到结束，采取和顺序表同样的比较方法，
忽略：只是最后不用挨个比较，把首地址给c就行
从尾部插入：判断链表是否为空，如果不为空，一直遍历到尾部，然后插入
循环：http://blog.csdn.net/hongkangwl/article/details/22284249
双向：http://blog.csdn.net/hongkangwl/article/details/22286469

queue sqqueue
struct(datatype data[size],ine head,int tail)
init :申请节点空间，复制，添加指针
isempty:判断head==tail
isFull :head == size
inQueue :是否满，给尾节点复制，尾部下标+1
outQueue :是否空，队列=头部节点向后移

linkQueue:
struct node(datatype data,node *next) struct linkList(node front,node rear)
init:初始化头节点，rear=front,front->next=NULL
inqueue:初始化要加入节点，p->data = http://www.mamicode.com/e,p->next = NULL.LQ ->rear ->next = p.lq->rear = p.
outqueue:判断是否为空，头节点p,头节点指向p的next，如果删除的是尾节点，重新补上，释放p

circlequeue:
stuct{datatype *base,int front,int rear}
init:申请base节点，头=尾
length:(尾-头+maxsize)%maxsize
in:是否满 尾+1%maxsize= front base[rear]=e,rear=(rear+1)%maxsize,所以不会超过最大值
de:是否空，e=头，头=头+1%maxsize

稀疏矩阵的反转：
triple(int i,int j,datatype e) tsmatrix(triple[size+1],int mu,nu,tu)
普通方法：crpot[size]，num[size] ,新老矩阵行列数交换，非零数量赋值给新矩阵，如果非零元素个数不为0，q=1,对老矩阵列遍历，对三元表挨个遍历，如果碰到其中一个的列等于当前列，
新三元组的行列交换存储，新三元组个数加1,
快速方法：新老矩阵行列数交换，如果有非零值，先为新矩阵每列的非零个数设初值0，然后遍历三元表得到每个列中非零个数的值，然后得到每个列中第一个元素在三元表中的序号，
挨个遍历老三元表，得到列，从新三元组的列中序号开始装载，列的个数+1

特殊矩阵的压缩算法，广义表的存储结构，递归算法设计
广义表：{tag,(data,*sublist)a,*next} 在串的基础上实现：{char *ch,int length}HString
首先，串的操作：
strAssign:生成一个串T等于chars，如果T不为空，释放T空间，求chars的长度，如果为0，T->ch = null.t->length=0;如果长度不为0，分配串空间，拷贝串，长度等于串的长度
因为t为空的时候不用申请表空间
strCopy:将串s复制给t，如果t不为空，释放t空间，分配t空间，根据下标拷贝串，t的长度等于s的长度
strEmpty:长度为0，值为空
strCompare:长度相等的时候字符相减，长度不相等的时候长度大的大
strLength:
clearStr:如果不为空，free(ch),ch=null length =0
conct(hstring t,s1,s2),t是否为空，不为空释放空间，t的长度等于s1,s2之和，申请ch空间，加上s1，然后加上s2
subStr:(sub,str,pos,len)将str从pos开始截取len长度作为sub的值，判断pos和len是否合适，如果sub不为空，释放空间，如果str为空，字串也为空，
如果不为空，申请ch空间，挨个赋值，长度相等
initStr:length=0.ch=null
index:(s,t,pos)如果s中第pos个字符之后又字符串和t重合，则返回重合开始的下标，否则返回-1，只找到第一个相等的下标
长度=s-t+1，i=pos，开始截取t的长度并i++,如果相等，返回i，
strInsert:(s,pos.t)在s的第pos位置插入t，pos是否合法，如果t的长度不为0，申请ch，pos之后位置向后移动t的长度，然后插入t，再加上t的长度
strDelete:(s,pos,len)在s的第pos个位置开始删除len长度个字符，len是否合法，ch[i]=ch[i+len],长度减去，空间缩减，realoc
strReplace:(s,t,v)用v替换s中与t相等的字符串，t是否为空，循环找下标，删除t，插入v
destroyStr:堆分配的长度无法销毁，
strPrint:
广义表的操作：
initList:*l=null
sever:(str,hstr),将str分成两部分，hstr为第一个，之前的字符串，str为第一个，之后的字符串
c1=, c2=( c3=) n为原str长度，开始执行循环{从0开始截取1个长度的字符串赋给ch,如果ch是（，k+1，如果ch是），k-1,++i}当满足
（i<原str长度并且ch大于，也就是ch为字母，||k!=0,也就是所有括号不匹配）也就是说当等于，和遍历到最后停止
如果存在，给str和hstr值，如果不存在，头=所有，尾清空
createList:（L，s）s为广义表格式的字符串，L为要创建的表，
申请表空间，如果字符串为（），创建空表，tag=list,sublist=null,next = null
如果长度为1，创建原子广义表，tag=atom,atom=ch[0],next=null
其他情况，也就是一般广义表，tag=list，next=null.脱外层括号，分离出头部，加到list中p，如果尾字符串不为空，再次拆分，将head加入尾部p->next,p=p->next
destroyList:如果表不为空，是原子，直接=null，是子表，找出sublist,next分别递归调用，删除L第一个节点。
copyList:(t,l)将l复制得到表t，l为空，t也为空，返回1，否则 给t申请空间，复制tag，如果是原子表，复制原子，否则，递归调用,复制sublist，
如果表尾是空，复制，否则，递归调用,复制表尾
glistLength:如果是空表，返回0，如果是原子表，返回1，如果是一般表，p->tp,元素个数也就是最外层括号内逗号隔开的个数
glistDepth:如果表为空或者表的类型为list但是表的sublist为空，return1，如果tag=0，return0.
否则就是一般表，每次取尾，遍历一次+1，最大dep为max，返回max+1
glistEmpty:如果表不存在或者表为list类型但是sublist为空，
gethead:如果是空表，无表头，否则，申请表空间，复制tag，如果是atom，复制atom值，如果不是，将l->sublist->sublist复制给要返回的值
getTail:如果是空表，无表尾，否则，申请表空间，赋值tag,复制l->sublist->next,表尾是一大块哦，是用哪个截取第一个，之后的后半部分转化成的表
insertFirstList:给第一个元素赋值
deleteFirstList:返回e,如果不为空，e=a.sublist,l->sublist=e->next,e->next=null,如果为空，e=l
traverse_gl:递归遍历gl，如果表不为空，如果是原子，如果为子表，sublist遍历，
createlIstby scanf:输入的所有字符可能是 # 字母 （ ） ， 一个方法有两次输入，第一个输入（，字母，# 因为输入（之后会进入下一个函数的首次输入，所以一#和字母终止
第二次输入 ， ） ）代表nex是null，，代表下一个值开始输入，进入下一个方法第一个输入

广义表和之前伪代码