算法代码备忘录（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<<“占满”<<endl;
return false;
}
s.data[++s.top]=i;
return true;
}
//出栈
bool Pop(Sqstack &s,CharNode* &o){
if (s.top-1){
cout<<“栈空”<<endl;
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<<"{"<data<<"},";
p=p->next;
}
cout<<endl;
}
/2.4打印单循环链表/
void print_CL(LinkList L){
LinkList p=L->next;
while (p!=L){
cout<<"{"<data<<"},";
p=p->next;
}
cout<<endl;
}

/典例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->data<pb->data){pa=pa->next;} else if(pa->data<pb->data){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<<temp->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<data;
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<k){
count++;
} else{
p=p->next;//当两工作指针间隔k时，p也开始移动
}
q=q->next;
}
if (count<k){//count小于k则查找失败
return false;
}
cout<data;
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<<b<<endl;/
//例10：判断双循环链表是否是对称的
/DLinkList Dl=Init_Circulate_List();
bool b=Judg_Symmetry(Dl);
cout<<b;/
//例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<<b;
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”<<endl;
} else{
cout<<“b”<<endl;
}

}

算法代码备忘录（2）相关推荐

刘知远：近年来开源的算法代码、工具包列表
来源:知乎作者:刘知远本文多图,建议阅读5分钟. 本文为你分享刘知远老师和学生整理的三十来项算法代码和工具包列表. 刚花半天功夫整理了最近几年和同学努力开源的三十来项算法代码和工具包列表( htt ...
c 语言乘法代码,C++实现大数乘法算法代码
C++实现大数乘法算法代码 //大数乘法算法 #include #include #include using namespace std; int main() { string num1,num2 ...
LDPC译码算法代码概述
程序说明 V0.0 2015/1/24 LDPC译码算法代码概述概述本文介绍了包括LDPC_Simulation.m, ldpcdecoderbp1.m,ldpcdecoderminsum.m, ...
曼哈顿距离java实现_基于javascript实现获取最短路径算法代码实例
这篇文章主要介绍了基于javascript实现获取最短路径算法代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下代码如下 //A算法自动寻路 ...
运行iDT算法代码及后续特征编码
DT&IDT算法应该算是行为识别领域中经典中的经典了,自从13年提出以来,在HMDB-51和UCF-101等若干个数据库上得到了非常好的效果,虽然DT&IDT算法做不过深度学习,但是由 ...
统计学习方法第六章作业：逻辑斯谛梯度下降法、最大熵模型 IIS / DFP 算法代码实现
逻辑斯谛梯度下降法 import numpy as np import matplotlib.pyplot as pltclass logist:def __init__(self,a=1,c=Non ...
算法代码[置顶] 机器学习实战之KNN算法详解
改章节笔者在深圳喝咖啡的时候突然想到的...之前就有想写几篇关于算法代码的文章,所以回家到以后就奋笔疾书的写出来发表了前一段时间介绍了Kmeans聚类,而KNN这个算法刚好是聚类以后经常使用 ...
java斐波那契查找_详解Java Fibonacci Search斐波那契搜索算法代码实现
一, 斐波那契搜索算法简述斐波那契搜索(Fibonacci search) ,又称斐波那契查找,是区间中单峰函数的搜索技术. 斐波那契搜索采用分而治之的方法,其中我们按照斐波那契数列对元素进行不均等 ...
算法代码_Python进化算法之多目标优化与代码实战
前言自从上三篇博客详细讲解了Python遗传和进化算法工具箱及其在带约束的单目标函数值优化中的应用.利用遗传算法求解有向图的最短路径.利用进化算法优化SVM参数之后,这篇不再局限于单一的进化算法工具 ...

算法代码备忘录（2）

算法代码备忘录（2）相关推荐

最新文章

热门文章