算法代码备忘录（2）

#include
using namespace std;

typedef struct CharNode{//存储字符的链表
char data;
struct CharNode *next;
}CharNode,*CharLinkList;

/工具：栈/
//定义栈
typedef struct Sqstack{
CharNode data[50];
int top=-1;//???
};
//入栈
bool Push(Sqstack &s,CharNode i){
if (s.top49){
cout<<“占满”< return false;
}
s.data[++s.top]=i;
return true;
}
//出栈
bool Pop(Sqstack &s,CharNode* &o){
if (s.top-1){
cout<<“栈空”< return false;
}
o=s.data[s.top–];
return true;
}
//判断栈是否为空
bool IsEmpty(Sqstack &S){
if(S.top==-1){
return true;
}else{
return false;
}
}
//获取栈顶元素
bool GetTop(Sqstack &S,CharNode* &o){
if (S.top==-1){
return false;
}
o=S.data[S.top];
return true;
}

/*1，

• ——————————————————
• 一：线性表线性结构
• ——————————————————
• */
  #define MaxSize 10
  typedef struct {
  int data[MaxSize];
  int length;
  }SqList;

/*2，

• ——————————————————
• 二：线性表链式结构
• ——————————————————
• */
  //单链表
  typedef struct LNode{
  int data;
  struct LNode *next;
  }LNode,LinkList;//别名，强调结点用LNode,强调链表用LinkList
  //双链表
  typedef struct DNode{
  int data;
  struct DNode *prior,*next;
  }DNode,*DLinkList;

/2.1，初始化一个单链表（自定义用于实验）/
LinkList initLinkList(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=1;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=3;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=4;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}

/2.3打印链表/
void print_L(LinkList L){
LinkList p=L->next;
while (p!=NULL){
cout<<"{" p=p->next;
}
cout< }
/2.4打印单循环链表/
void print_CL(LinkList L){
LinkList p=L->next;
while (p!=L){
cout<<"{" p=p->next;
}
cout< }

/典例1:删除Min,max之间的值/

/典例2：逆向输出（回溯）/

/典例3：链表逆置/

/典例3：排序（插入排序）⭐⭐⭐/

/典例4：有序输出⭐⭐⭐/

/典例5：去重⭐⭐⭐/

/典例6[头插尾插法]：头插+尾插混合⭐⭐⭐/
LinkList L_apart(LinkList &A){
//工作指针(头尾公用指针)
LNode *p=A->next;
//B的初始化，及B头插法指针定义;辅助指针r(防断)
LinkList B=(LinkList) malloc(sizeof (LNode));
B->next=NULL;
LNode r;
//A的初始化，及A尾插法指针定义;A头指针ra
LNode ra=A;
while(p!=NULL){
ra->next=p; ra=p; p=p->next;//尾插
if(p!=NULL){
r=p->next; p->next=B->next; B->next=p; p=r;//头插
}
}
ra->next=NULL;//头插必备（最后一个元素指向NULL）
print_L(A);
print_L(B);
return B;
}
/典例7[双链表操作]：两递减归并一递增————！！！链表归并问题（重要)！！！//-----------------------------------------------/
//7.1初始化两个递增链表（用于实验）
LinkList initLinkList1(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=1;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=3;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=5;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=7;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=9;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}
LinkList initLinkList2(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=2;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=4;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=6;
L->next=b;b->next=c;c->next=d;d->next=NULL;
return L;
}
//7.2进行归并
LinkList MergeList(LinkList &La,LinkList &Lb){
LNode *pa=La->next,*pb=Lb->next;//初始化头插la,lb的工作指针
//LNode *ra,*rb;//优化
LNode *r;//初始化头插la,lb的放断指针（只在插入时起作用，若是一次插入一个不是并行使用，那么可以只用一个放断指针）
La->next=NULL;//用la作为归并后的链表
while(pa&&pb){
if (pa->datadata){
r=pa->next;//跟踪下一个（放断）
pa->next=La->next;//把头结点之后放到要插之后
La->next=pa;
pa=r;//工作指针复位（物归原主）
} else{
r=pb->next;//跟踪下一个（放断）
pb->next=La->next;//把头结点之后放到要插之后
La->next=pb;
pb=r;//工作指针复位（物归原主）
}
}
/while(pa){
ra=pa->next;//跟踪下一个（放断）
pa->next=La->next;//把头结点之后放到要插之后
La->next=pa;
pa=ra;//工作指针复位（物归原主）
}/
if (pa) pb=pa;//代码优化

while(pb){
r=pb->next;//跟踪下一个（放断）
pb->next=La->next;//把头结点之后放到要插之后
La->next=pb;
pb=r;//工作指针复位（物归原主）
}
free(Lb);
return La;


}

/典例8[双链表操作]：用A、B的公共元素组合成C————！！！链表归并问题（重要)！！！//-----------------------------------------/
//8.1初始化两个递增链表（用于实验）
LinkList initLinkList3(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=1;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=3;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=4;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}
LinkList initLinkList4(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=2;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=3;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=4;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=9;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=NULL;
return L;
}
//8.2生成C
LinkList Create_Common1(LinkList &La,LinkList &Lb){
//初始C,原序构造用尾插法
LinkList C=(LinkList) malloc(sizeof (LNode));
C->next=NULL;
//尾插：尾指针、工作指针
LNode *rc=C,*pa=La->next,*pb=Lb->next;
while(pa&&pb){
while (pa&&pb&&pa->datadata){
pa=pa->next;
}
if (pa&&pb&&pa->datapb->data){
rc->next=pa;
rc=pa;
pa=pa->next;pb=pb->next;
}
while (pa&&pb&&pa->datadata){
pa=pa->next;
}
if (pa&&pb&&pa->datapb->data){
rc->next=pa;
rc=pa;
pa=pa->next;pb=pb->next;
}
}
rc->next=NULL;
return C;

}
//8.3生成C[->高度优化版<-]
LinkList Create_Common2(LinkList &La,LinkList &Lb){
//初始C,原序构造用尾插法
LinkList C=(LinkList) malloc(sizeof (LNode));
C->next=NULL;
//尾插：尾指针、工作指针；*s复制公共点（防止破坏A、B结构）
LNode *rc=C,*pa=La->next,*pb=Lb->next,*s;
while(pa&&pb){
if (pa->datadata){
pa=pa->next;
} else if(pa->datadata){
pb=pb->next;
} else{
s=(LinkList) malloc(sizeof (LNode));
s->data=pa->data;
rc->next=s;//复制公共结点的值
rc=s;//尾指针后移
pa=pa->next;pb=pb->next;
}
}
rc->next=NULL;
return C;

}
//将公共结点放入A中（即不用考虑结构破坏）
LinkList Create_Common3(LinkList &La,LinkList &Lb){

//尾插：尾指针、工作指针
LNode *pa=La->next,*pb=Lb->next,*s;
La->next=NULL;
LNode *ra=La;
while(pa&&pb){
if (pa->datadata){
pa=pa->next;
} else if(pa->datadata){
pb=pb->next;
} else{
ra->next=pa;//复制公共结点的值
ra=pa;//尾指针后移
pa=pa->next;pb=pb->next;
}
}
ra->next=NULL;
return La;


}

/典例9[单链表子序列]：判断B是否是A的子序列————！！！类KPL，子序列匹配（重要)！！！//--------------------------------------/
LinkList initLinkList5(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=2;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=3;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=4;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}
LinkList initLinkList6(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=2;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=3;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=4;
/*LNode e=(LinkList) malloc(sizeof (LNode));
e->data=9;/
L->next=b;b->next=c;c->next=d;/d->next=e;/d->next=NULL;
return L;
}
bool Judg_Subset(LinkList &La,LinkList &Lb){
//遍历La、Lb的工作指针；tmep记录上次a开始的位置，再次比较时从上次开始(temp)位置的下一个位置开始
LNode *pa=La->next,*temp=La->next,*pb=Lb->next;
while (pa&&pb){
if (pb->data!=pa->data){
pa=temp->next;//若比较失败则从上次a开始位置的下一个位置开始
temp=pa;
pb=Lb->next;//b每次都从开头开始比较
} else {
pa=pa->next;
pb=pb->next;//只有相同时b才会指向下一个；只有b全部相同时，pb指向了最后一个下一个才会为空
}
}
if (pb==NULL)
return true;
return false;
}
/典例9.1：2012真题公共后缀/

CharLinkList Common_char(){
//头结点
CharNode *str1=(CharLinkList) malloc(sizeof (CharNode));
CharNode *str2=(CharLinkList) malloc(sizeof (CharNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点load
CharNode *a=(CharLinkList) malloc(sizeof (CharNode));
a->data=‘l’;
CharNode *b=(CharLinkList) malloc(sizeof (CharNode));
b->data=‘o’;
CharNode *c=(CharLinkList) malloc(sizeof (CharNode));
c->data=‘a’;
CharNode *d=(CharLinkList) malloc(sizeof (CharNode));
d->data=‘d’;
str1->next=a;a->next=b;b->next=c;c->next=d;

//数据结点be
CharNode *a1=(CharLinkList) malloc(sizeof (CharNode));
a1->data='b';
CharNode *b1=(CharLinkList) malloc(sizeof (CharNode));
b1->data='e';
a1->next=b1;
str1->next=a;str2->next=a1;
//定义公共结点ing
CharNode *a2=(CharLinkList) malloc(sizeof (CharNode));
a2->data='i';
CharNode *b2=(CharLinkList) malloc(sizeof (CharNode));
b2->data='n';
CharNode *c2=(CharLinkList) malloc(sizeof (CharNode));
c2->data='g';
a2->next=b2;b2->next=c2;c2->next=NULL;
d->next=a2;b1->next=a2;
//定义两链表工作指针
CharNode *p1=str1->next,*p2=str2->next;
CharNode *temp=p1;//存储str开始的结点
CharNode *t=p1;//标记最后一个相同开始点
CharNode *t2=str2->next;//标记str2开始结点
while (p2){
p1=str1->next;
temp=p1;if (p1->data!=p2->data){
p1=temp->next;//比较失败则再从上一次开始地方的下一个地方开始
p2=t2;//失败了则p2从头开始
temp=p1;
}else{
p1=p1->next;
p2=p2->next;
}
}
t2=t2->next;
if (p1==NULL&&p2==NULL){
cout<data;
}
}


/典例10[循环双链表]：判循环链表是否对称//--------------------------------------/
//10.1定义一个循环双链表
DLinkList Init_Circulate_List(){
//头结点
DNode *L=(DLinkList) malloc(sizeof (DNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
DNode *b=(DLinkList) malloc(sizeof (DNode));
b->data=3;
DNode *c=(DLinkList) malloc(sizeof (DNode));
c->data=2;
DNode *d=(DLinkList) malloc(sizeof (DNode));
d->data=1;
DNode *x=(DLinkList) malloc(sizeof (DNode));
x->data=0;
DNode *e=(DLinkList) malloc(sizeof (DNode));
e->data=1;
DNode *f=(DLinkList) malloc(sizeof (DNode));
f->data=2;
DNode *g=(DLinkList) malloc(sizeof (DNode));
g->data=3;
L->next=b;b->next=c;c->next=d;d->next=x;x->next=e;e->next=f;f->next=g;g->next=L;
L->prior=g;b->prior=L;c->prior=b;d->prior=c;x->prior=d;e->prior=x;f->prior=e;g->prior=f;
return L;
}
bool Judg_Symmetry(DLinkList &L){
//正向工作指针，逆向工作指针
DNode *p=L->next,*q=L->prior;
while (p->prior!=q&&p!=q){
if (p->data==q->data){
p=p->next;
q=q->prior;
}else{
return false;
}
}
return true;
}

/典例11[循环单链表]：两循环单链表合并//--------------------------------------/
LinkList initLinkList7(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=1;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=3;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=4;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=L;
return L;
}
LinkList initLinkList8(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=6;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=7;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=8;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=9;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=10;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=L;
return L;
}
LinkList Merge_Cri_List(LinkList &h1,LinkList &h2){
//h1、h2工作指针
LNode *p1=h1,*p2=h2;
while(p1->next!=h1){
p1=p1->next;
} //寻找h1的尾结点
p1->next=h2->next;
while(p2->next!=h2){
p2=p2->next;
}//寻找h2的尾结点
p2->next=h1;
return h1;
}

/典例12[循环单链表]：单循环链表增序输出//--------------------------------------/
LinkList initLinkList9(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=3;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=7;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=9;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=2;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=L;
return L;
}
//每次循环输出并删除单链表最小值
void Del_All(LinkList &L){
//工作指针
LNode *pre=L,*p=pre->next;
//最小值存储模块
LNode *minpre,*minp;//最小值指针
while (L->next!=L){
pre=L,p=pre->next;
minpre=L,minp=minpre->next;
while (p!=L){//将当前最小值存起来
if (minp->data>p->data){
minpre=pre;
minp=p;
}
pre=pre->next;
p=pre->next;
}
minpre->next=minp->next;
cout free(minp);
}

}

/典例13[单链表逆遍历]：找到倒数第k个结点的值//--------------------------------------/
bool Search_K(LinkList &L,int k) {
//两个工作指针
LNode *p=L->next,*q=L->next;
int count=0;
while (q!=NULL){
if (count count++;
} else{
p=p->next;//当两工作指针间隔k时，p也开始移动
}
q=q->next;
}
if (count return false;
}
cout return true;
}
//14、删除公共元素
LinkList initLinkList11(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=1;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=3;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=4;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}
LinkList initLinkList22(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=0;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=3;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=4;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}
LinkList initLinkList33(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=1;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=3;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=4;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=5;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}
void deletecommon(LinkList &a,LinkList &b,LinkList &c){
//工作指针
LNode *pre=a,*pa=pre->next,*pb=b->next,*pc=c->next,*temp;
while(pa){
while(pa->data>pb->data){
pb=pb->next;
}
if (pa->datapb->data){
//去c里找是否存在该元素
while (pa->data>pc->data){
pc=pc->next;
}
if (pa->datapc->data){
//bc都存在则删除
temp=pa;
pre->next=pa->next;
//删除操作已经将a前移了不用再移动了
pa=pa->next;
free(temp);
} else{
pre=pre->next;pa=pre->next;
}
} else{
pre=pre->next;pa=pre->next;
}
}
}
//15、无序去重
LinkList initLinkList10(){
//头结点
LNode *L=(LinkList) malloc(sizeof (LNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点
LNode *b=(LinkList) malloc(sizeof (LNode));
b->data=1;
LNode *c=(LinkList) malloc(sizeof (LNode));
c->data=2;
LNode *d=(LinkList) malloc(sizeof (LNode));
d->data=1;
LNode *e=(LinkList) malloc(sizeof (LNode));
e->data=3;
LNode *f=(LinkList) malloc(sizeof (LNode));
f->data=1;
L->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=NULL;
return L;
}
void deleteNode(LinkList &L){
LNode *p=L->next,*q,*pre;
q=p->next;pre=p;
while (p->next){
while (q){
if (p->dataq->data){
pre->next=q->next;
free(q);
} else{
pre=pre->next;
}
q=pre->next;
}
p=p->next;
pre=p;
q=pre->next;
}
}
//16、括号匹配
CharLinkList initCharList(){
//头结点
CharNode *str1=(CharLinkList) malloc(sizeof (CharNode));
//L->data=NULL;//头结点data不用管，只让->next=NULL；就行
//数据结点load
CharNode *a=(CharLinkList) malloc(sizeof (CharNode));
a->data=’[’;
CharNode *b=(CharLinkList) malloc(sizeof (CharNode));
b->data=’{’;
CharNode *c=(CharLinkList) malloc(sizeof (CharNode));
c->data=’(’;
CharNode *d=(CharLinkList) malloc(sizeof (CharNode));
d->data=‘1’;
CharNode *e=(CharLinkList) malloc(sizeof (CharNode));
e->data=’)’;
CharNode *f=(CharLinkList) malloc(sizeof (CharNode));
f->data=’}’;
CharNode *g=(CharLinkList) malloc(sizeof (CharNode));
g->data=’]’;
str1->next=a;a->next=b;b->next=c;c->next=d;d->next=e;e->next=f;f->next=g;g->next=str1;
return str1;
};
bool judge(CharLinkList &cl){
Sqstack sq;CharLinkList l=cl;
CharNode *q=l->next,*p;
while (q!=l){
char c=q->data;
if(c’[’||c==’{’||c==’(’){
Push(sq,q);
}else if ((!IsEmpty(sq))&&(c==’]’||c==’}’||c==’)’)){
GetTop(sq,p);
if ((p->data==’[’&&c==’]’)||(p->data==’{’&&c==’}’)||(p->data==’(’&&c==’)’)){
Pop(sq,p);
}
}
q=q->next;
}
if (IsEmpty(sq)){
return true;
}
return false;
}

int main() {
//例6：奇、偶分别用头插、尾插（头插+尾插混合）(单链表处理)
/LinkList L=initLinkList();
print_L(L);
L_apart(L);/
//例7：两递增归并一递减(两链表处理)
/LinkList L1=initLinkList1();
print_L(L1);
LinkList L2=initLinkList2();
print_L(L2);
LinkList L3=MergeList(L1,L2);
print_L(L3);/
//例8：用A、B的公共元素组合成C(两链表处理)
/LinkList L3=initLinkList3();
print_L(L3);
LinkList L4=initLinkList4();
print_L(L4);
LinkList C=Create_Common3(L3,L4);
print_L©;/
//例9：判断B是否是A的子序列
/LinkList L5=initLinkList5();
print_L(L5);
LinkList L6=initLinkList6();
print_L(L6);
bool b=Judg_Subset(L5,L6);
cout</
//例10：判断双循环链表是否是对称的
/DLinkList Dl=Init_Circulate_List();
bool b=Judg_Symmetry(Dl);
cout</
//例11：拼接两单循环链表
/LinkList L7=initLinkList7();
print_CL(L7);
LinkList L8=initLinkList8();
print_CL(L8);
LinkList L=Merge_Cri_List(L7,L8);
print_CL(L);/
//例12：增序输出
/LinkList L9=initLinkList9();
print_CL(L9);
Del_All(L9);/
//例13:
/LinkList L3=initLinkList3();
print_L(L3);
bool b=Search_K(L3,6);
cout< Common_char();/
//删除公共元素
/LinkList l1=initLinkList11();
LinkList l2=initLinkList22();
LinkList l3=initLinkList33();
deletecommon(l1,l2,l3);
print_L(l1);/
//无序去重
/* LinkList l1=initLinkList10();
print_L(l1);
deleteNode(l1);
print_L(l1);*/
//括号匹配
CharLinkList l=initCharList();
bool b=judge(l);
if (b){
cout<<“a”< } else{
cout<<“b”< }

}