算法代码备忘录（1）

#include
#include <windows.h>
using namespace std;

/*1??

• ???
• ???
• ???
• */
  //定义树节点
  typedef struct BiTNode{
  int data;//???
  struct BiTNode *lchild,*rchild;
  }BiTNode,*BiTree;

//定义链表节点
typedef struct LNoded{
BiTNode *data;
struct LNode *next;
}LNoded,*LinkedList;

//定义栈
typedef struct Sqstack{
BiTNode data[50];
int top;//???
};
//入栈
bool Push(Sqstack &s,BiTNode i){
if (s.top49){
cout<<"???"<<endl;
return false;
}
s.data[++s.top]=i;
return true;
}
//出栈
bool Pop(Sqstack &s,BiTNode* &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,BiTNode* &o){
if (S.top==-1){
return false;
}
o=S.data[S.top];
return true;
}

//定义队列
typedef struct {
BiTNode data[30];
int front,rear;//???
}SqQueue;
//进队
bool EnQueue(SqQueue &Q,BiTNode i){
if ((Q.rear+1)%30Q.front){return false;}
Q.data[Q.rear]=i;
Q.rear=(Q.rear+1)%30;
return true;
}
//出队
bool DeQueue(SqQueue &Q,BiTNode* &i){
if (Q.rearQ.front){return false;}
i=Q.data[Q.front];
Q.front=(Q.front+1)%30;
return true;
}
//判断队列是否为空
bool isempty(SqQueue Q){
if (Q.rear==Q.front){
return true;//???true
} else{
return false;
}
}

BiTree InitTree(){
//树的初始化
BiTNode *a;
a=(BiTree) malloc(sizeof (BiTNode));
a->data=1;
BiTNode *b;
b=(BiTree) malloc(sizeof (BiTNode));
b->data=2;
BiTNode *c;
c=(BiTree) malloc(sizeof (BiTNode));
c->data=3;
BiTNode *d;
d=(BiTree) malloc(sizeof (BiTNode));
d->data=4;
BiTNode *e;
e=(BiTree) malloc(sizeof (BiTNode));
e->data=5;
BiTNode *f;
f=(BiTree) malloc(sizeof (BiTNode));
f->data=7;
BiTNode *g;
g=(BiTree) malloc(sizeof (BiTNode));
g->data=10;
BiTNode *h;
h=(BiTree) malloc(sizeof (BiTNode));
h->data=11;

//??????
a->lchild=b;    a->rchild=c;
b->lchild=d;    b->rchild=e;
c->rchild=f;    e->lchild=g;
e->rchild=h;

d->rchild=d->lchild=g->rchild=g->lchild=c->lchild=f->lchild=f->rchild=h->lchild=h->rchild=NULL;
return a;

}
/???1???/
void visit(BiTNode *b){
if (b!=NULL){
cout<data<<",";
}
}
//???(???)
void PreOrder(BiTree T){
if (T!=NULL){
visit(T);
PreOrder(T->lchild);
PreOrder(T->rchild);
}
}
//???n???(???)
int i=1;
int PreOrder(BiTree T,int k){
if(TNULL){
return ‘#’;
}
if (ik){
return T->data;
}
i++;
int ch=PreOrder(T->lchild,k);
if(ch!=’#’){
return ch;
}
ch=PreOrder(T->rchild,k);
if(ch!=’#’){
return ch;
}

}

//???
void InOrder(BiTree T){
if (T!=NULL){
InOrder(T->lchild);
visit(T);
InOrder(T->rchild);
}
}//???
void PostOrder(BiTree T){
if (T!=NULL){
PostOrder(T->lchild);
PostOrder(T->rchild);
visit(T);
}
}

/???2???/
//???(???)
//前序非递归
void PreOrder1(BiTree T){
//???P
Sqstack s;BiTNode *p=T;
s.top=-1;
while(p||!IsEmpty(s)){
if §{//???
visit§;//???
Push(s,p);
p=p->lchild;
} else{
Pop(s,p);
p=p->rchild;
}
}
}
//???
void InOrder1(BiTree T){
//???P
Sqstack s;BiTNode *p=T;
s.top=-1;
while (p||!IsEmpty(s)){
if §{
Push(s,p);
p=p->lchild;
} else{
Pop(s,p);
visit§;
p=p->rchild;
}
}

}
//???
void PostOrder1(BiTree T){//???,???r???
Sqstack s;BiTNode *p=T;BiTNode *r=NULL;
s.top=-1;
//???P???
while(p||!IsEmpty(s)){
if §{//??? //???
Push(s,p);
p=p->lchild;
}//???
else{ //???
GetTop(s,p);
if (p->rchild&&p->rchild!=r){//???
p=p->rchild;//???
Push(s,p);//???
p=p->lchild;//???
} else{//???
Pop(s,p);
visit§;
r=p;
p=NULL;
}
}
}//while

}
/???3???/
//1,???2???3???
void LevelOrder(BiTree T){
//???
SqQueue s;
s.front=s.rear=0;
EnQueue(s,T);
//???p
BiTNode p;
while (!isempty(s)){
DeQueue(s,p);
visit§;
if (p->lchild){
EnQueue(s,p->lchild);
}
if (p->rchild){
EnQueue(s,p->rchild);
}
}
}
/???4???*/
int DeepMax(BiTree T){
if (T==NULL){return 0;}
int l=DeepMax(T->lchild);
int r=DeepMax(T->rchild);
return l>r?1+l:1+r;
}

/???1???x???2015???/
bool DeleTNode(BiTree &T,int k){
//???X???
SqQueue s;
s.front=s.rear=0;//???s
//???
SqQueue s1;
s1.front=s1.rear=0;//???s
EnQueue(s,T);
//???p
BiTNode p;
while (!isempty(s)){
DeQueue(s,p);
if (p->data==k){
break;
}
if (p->lchild){
EnQueue(s,p->lchild);
}
if (p->rchild){
EnQueue(s,p->rchild);
}
}
EnQueue(s1,p);
BiTree temp=p;
while (!isempty(s1)){
DeQueue(s1,p);
if (p->lchild){
EnQueue(s1,p->lchild);
}
if (p->rchild){
EnQueue(s1,p->rchild);
}
if (p!=temp){
cout<data<<endl;
free§;
}
}
temp->rchild=temp->lchild=NULL;
return true;
}
/???2???*/
//1,???
//2,???x???x???
void PrintAncestor(BiTree &T,int x){
//1,???
SqQueue s; s.front=s.rear=0;//???s
Sqstack sq; sq.top=-1; //???sq
//2,???p,???q,??k???r
BiTNode *p=T,q,r=NULL;
//3,???
EnQueue(s,p);
while(!isempty(s)){
DeQueue(s,p);
//???
if(p->datax){ r=p;
break;
}
//???
Push(sq,p);
if (p->lchild){EnQueue(s,p->lchild);}
if (p->rchild){EnQueue(s,p->rchild);}
}
//4,???
while (!IsEmpty(sq)&&r!=NULL){
Pop(sq,q);
if (q->rchildr||q->lchild==r){
visit(q);
r=q;
}
}
}
/???3???/
Sqstack PrintAncestor1(BiTree &T,int x){
//1,???
SqQueue s; s.front=s.rear=0;//???s
Sqstack sq; sq.top=-1; //???sq
Sqstack rsq; rsq.top=-1; //???sq

//2,???????p,????????q,??k???????r
BiTNode *p=T,*q,*r=NULL;
//3,?????????
EnQueue(s,p);
while(!isempty(s)){
    DeQueue(s,p);
    //??????????????????????????
    if(p->data==x){ r=p;
        break;
    }
    //??????????
    Push(sq,p);
    if (p->lchild){EnQueue(s,p->lchild);}
    if (p->rchild){EnQueue(s,p->rchild);}
}
//4,?????????
while (!IsEmpty(sq)&&r!=NULL){
    Pop(sq,q);
    if (q->rchild==r||q->lchild==r){
        //visit(q);
        Push(rsq,q);
        r=q;
    }
}
return rsq;

}
//???
void commonAncestor(BiTree &T,int x1,int x2){
Sqstack sq1=PrintAncestor1(T,x1);
Sqstack sq2=PrintAncestor1(T,x2);
BiTNode p,q;
int j = 0;
for (int i =0 ; i<=sq1.top; i++) {
for (j=0; j <= sq2.top; j++) {
if (sq1.data[i]->data == sq2.data[j]->data) {
cout << “???” << sq1.data[i]->data << endl;
break;
}
}
if (sq1.data[i]->data == sq2.data[j]->data) {break;}
}
}
/???4???/
typedef struct{
BiTree data[30];
int level[30];
int front,rear;
}Qu;
bool EnQueue1(Qu &Q,BiTNode* i){
if ((Q.rear+1)%30Q.front){return false;}
Q.data[Q.rear]=i;
Q.rear=(Q.rear+1)%30;
return true;
}
//???
bool DeQueue1(Qu &Q,BiTNode* &i){
if (Q.rearQ.front){return false;}
i=Q.data[Q.front];
Q.front=(Q.front+1)%30;
return true;
}
//???
bool isempty1(Qu Q){
if (Q.rear==Q.front){
return true;//???true
} else{
return false;
}
}
void MaxWidth(BiTree &T){
BiTNode *p;
int k,max,i,n;
Qu qu;
qu.front=qu.rear=-1;
qu.rear++;//???1
qu.data[qu.rear]=T;
qu.level[qu.rear]=1;
while(!isempty1(qu)){
//???
qu.front++;
p=qu.data[qu.front];
k=qu.level[qu.front];
if (p->lchild){
qu.rear++;//???1
qu.data[qu.rear]=p->lchild;
qu.level[qu.rear]=k+1;//???k+1
}
if (p->rchild){
qu.rear++;//???1
qu.data[qu.rear]=p->rchild;
qu.level[qu.rear]=k+1;//???k+1
}
}
//???
max=0;i=0;
k=1;//???
while (i<=qu.rear){
n=0;//n???k???
while(i<=qu.rear&&qu.level[i]==k){
n++;
k++;
}
k=qu.level[i];
if (n>max){max=n;}
}

cout<<max;

}
/???5???/
BiTNode head,pre=NULL;//pre???
void InOrder2(BiTree &t){
if(t!=NULL) {
InOrder2(t->lchild);
if (t->lchildNULL && t->rchildNULL) {
if (pre == NULL) {
head = t;
pre = t;
} else {
pre->rchild = t;
pre = t;
}
}
InOrder2(t->rchild);
pre->rchild = NULL;
}
}
/???6???WPL/
int level=0;
int WPL=0;
void PreOrder3(BiTree T,int level){
if (T){
if (T->lchildNULL&&T->rchildNULL){
cout<<“level:”<<level<<";data:"<data<<"; leveldata="<datalevel<<endl;
WPL+=T->datalevel;
}
PreOrder3(T->lchild,level+1);
PreOrder3(T->rchild,level+1);//???–???++???
}
}
/???6???*/
//???
typedef struct BiTNode1{
char data;//???
struct BiTNode1 *lchild,*rchild;
}BiTNode1,*BiTree1;
BiTree1 InitTree1(){
//???
BiTNode1 a;
a=(BiTree1) malloc(sizeof (BiTNode1));
a->data=’’;
BiTNode1 *b;
b=(BiTree1) malloc(sizeof (BiTNode1));
b->data=’+’;
BiTNode1 c;
c=(BiTree1) malloc(sizeof (BiTNode1));
c->data=’’;
BiTNode1 *d;
d=(BiTree1) malloc(sizeof (BiTNode1));
d->data=‘a’;
BiTNode1 *e;
e=(BiTree1) malloc(sizeof (BiTNode1));
e->data=‘b’;
BiTNode1 *f;
f=(BiTree1) malloc(sizeof (BiTNode1));
f->data=‘c’;
BiTNode1 *g;
g=(BiTree1) malloc(sizeof (BiTNode1));
g->data=’-’;
BiTNode1 *h;
h=(BiTree1) malloc(sizeof (BiTNode1));
h->data=‘d’;
//???
a->lchild=b;a->rchild=c;b->lchild=d;b->rchild=e;c->lchild=f;c->rchild=g;g->rchild=h;
d->lchild=d->rchild=e->lchild=e->rchild=f->lchild=f->rchild=g->lchild=h->lchild=h->rchild=NULL;
return a;
}
void BtreeToExp(BiTree1 t,int deep){
if (t){
if (t->lchildNULL&&t->rchildNULL){
cout<data;
} else{
if (deep>1){
cout<<"(";
}
BtreeToExp(t->lchild,deep+1);
cout<data;
BtreeToExp(t->rchild,deep+1);
cout<<")";
}
}
}
//斐波那契数列,时间复杂度2^n
int f(int n){
if(n0||n1){return n;}
return f(n-1)+f(n-2);
}
int f1(int n){
int count=0,min=0,max=1;
if(n0){return 0;}
if(n1){return 1;}
while (i!=n){
count=min+max;
max=count;
min=max;
i++;
}
return count;
}

int main() {
system(“chcp 65001 > nul”);
//1,???
BiTree t=InitTree();
/PreOrder(t);
cout<<endl;
InOrder(t);
cout<<endl;
PostOrder(t);/
//2,???
/BiTree t=InitTree();
PreOrder1(t);
cout<<endl;
InOrder1(t);
cout<<endl;
PostOrder1(t);/
//3,???
/BiTree t=InitTree();
LevelOrder(t);/
//4,???
/BiTree t=InitTree();
int d=DeepMax(t);
cout<<d;/
//5,???n???
/BiTree t=InitTree();
cout<<PreOrder(t,5)<<endl;/
//6,???x???
/BiTree t=InitTree();
DeleTNode(t,2);/
//7,???
/PrintAncestor(t,7);/
//8,???
/commonAncestor(t,5,7);/
//9,???
/MaxWidth(t);/
//10,???
/InOrder2(t);
while (head){
cout<data<<",";
head=head->rchild;
}/
//11,??WPL
/PreOrder3(t,0);
cout<<“WPL:”<<WPL<<endl;/
//12,???
/BiTree1 t1=InitTree1();
BtreeToExp(t1,1);/
/string str;
getline(cin,str);
cout<<str.size()<<endl;
printf(“输入字符长度为%d,第2个字符为%c”,str.size(),str[1]);/
/*char a[]=“1sd”;
cout<<a[0];
if(a[0]<=‘9’&&a[0]>=‘0’){

    cout<<"sd";
}

*/
cout<<f(8);
return 0;
}