├── .gitignore ├── 2-1-List.c ├── 2-2-1.c ├── 2-2-10.c ├── 2-2-11.c ├── 2-2-12.c ├── 2-2-2.c ├── 2-2-3.c ├── 2-2-4.c ├── 2-2-6.c ├── 2-2-7.c ├── 2-2-8.c ├── 2-2-9.c ├── 2-3-1.c ├── 2-3-10.cpp ├── 2-3-11.cpp ├── 2-3-12.cpp ├── 2-3-13.cpp ├── 2-3-14.cpp ├── 2-3-15.cpp ├── 2-3-16.cpp ├── 2-3-17.cpp ├── 2-3-18.cpp ├── 2-3-19.cpp ├── 2-3-2.c ├── 2-3-2.cpp ├── 2-3-20.cpp ├── 2-3-21.cpp ├── 2-3-22.cpp ├── 2-3-23.cpp ├── 2-3-3.cpp ├── 2-3-4.cpp ├── 2-3-5.cpp ├── 2-3-6.cpp ├── 2-3-7.cpp ├── 2-3-8.cpp ├── 2-3-9.cpp ├── 2-3-Double-List.cpp ├── 2-3-LinkList-M.cpp ├── 2-3-List.c ├── 2-3-TwoLinkList-M.cpp ├── 3-1-3.cpp ├── 3-1-4.cpp ├── 3-1-5.cpp ├── 3-1-SqStack.cpp ├── 3-2-1.cpp ├── 3-2-2.cpp ├── 3-2-3.cpp ├── 3-3-1.cpp ├── 3-3-2.cpp ├── 3-3-3.cpp ├── 3-3-4.cpp ├── 4-2-5-BTree-Seq.cpp ├── 4-3-10.cpp ├── 4-3-11.cpp ├── 4-3-12.cpp ├── 4-3-13.cpp ├── 4-3-14.cpp ├── 4-3-15.cpp ├── 4-3-16.cpp ├── 4-3-17.cpp ├── 4-3-18.cpp ├── 4-3-19.cpp ├── 4-3-20.cpp ├── 4-3-3.cpp ├── 4-3-4.cpp ├── 4-3-5.cpp ├── 4-3-6.cpp ├── 4-3-7.cpp ├── 4-3-8.cpp ├── 4-3-9.cpp ├── 4-4-5.cpp ├── 4-4-6.cpp ├── 4-4-7-ans.cpp ├── 4-4-7.cpp ├── 4-5-10.cpp ├── 4-5-11.cpp ├── 4-5-12-ans.cpp ├── 4-5-12.cpp ├── 4-5-6-ans.cpp ├── 4-5-6.cpp ├── 4-5-7.cpp ├── 4-5-8.cpp ├── 4-5-9.cpp ├── 4-BST.cpp ├── 4-BiTree.cpp ├── 4-HuffmanTree.cpp ├── 4-Tree.cpp ├── 5-2-3.cpp ├── 5-3-2.cpp ├── 5-3-3.cpp ├── 5-3-4.cpp ├── 5-3-5.cpp ├── 5-graph.cpp ├── 5-graph.txt └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | -------------------------------------------------------------------------------- /2-1-List.c: -------------------------------------------------------------------------------- 1 | #define Maxsize 50 2 | typedef struct{ 3 | int data[Maxsize]; 4 | int length; 5 | }SqList; 6 | -------------------------------------------------------------------------------- /2-2-1.c: -------------------------------------------------------------------------------- 1 | #include 2 | int fun(int List[],int length); 3 | int main(){ 4 | int List[5]={5,3,2,6,7}; 5 | printf("%d\n",fun(List,5)); 6 | for(int i=0;i<5;i++){ 7 | printf("%d ",List[i]); 8 | } 9 | return 0; 10 | } 11 | 12 | int fun(int L[],int len){ 13 | if(len==0){ 14 | printf("error\n"); 15 | return 0; 16 | } 17 | int min=L[0]; 18 | int j=0; 19 | for(int i=0;iL[i]){ 21 | min=L[i]; 22 | j=i; 23 | } 24 | } 25 | L[j]=L[len-1]; 26 | L[len-1]='\0'; 27 | return min; 28 | } 29 | -------------------------------------------------------------------------------- /2-2-10.c: -------------------------------------------------------------------------------- 1 | #include 2 | int fun(int l[],int m,int n){ 3 | int mid=(m+n)/2; 4 | for(int i=0;i<=(n-m)/2;i++){ // m+i<=n-i 5 | int tmp=l[n-i]; 6 | l[n-i]=l[m+i]; 7 | l[m+i]=tmp; 8 | } 9 | return 0; 10 | 11 | } 12 | int main(){ 13 | int p=3; 14 | int List[6]={4,1,7,5,6,9}; 15 | fun(List,0,p-1); 16 | fun(List,p,5); 17 | fun(List,0,5); 18 | for(int i=0;i<6;i++){ 19 | printf("%d ",List[i]); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /2-2-11.c: -------------------------------------------------------------------------------- 1 | #include 2 | int fun(int l1[],int l2[],int m,int n){ 3 | int i=0,j=0,k=0; 4 | int mid=0; 5 | int tmp=0; 6 | if((m+n)%2==0){ 7 | mid=(m+n)/2; 8 | }else{ 9 | mid=(m+n)/2+1; 10 | } 11 | while(il2[j]){ 20 | k++; 21 | if(k==mid){ 22 | tmp=l2[j]; 23 | break; 24 | } 25 | j++; 26 | } 27 | } 28 | while(i 2 | int fun(int l[],int n){ 3 | int tmp=l[0]; 4 | int count=0; 5 | for(int i=0;i0){ 10 | count--; 11 | }else{ 12 | count++; 13 | tmp=l[i]; 14 | } 15 | } 16 | } 17 | count=0; 18 | for(int i=0;in/2)return tmp; 24 | else return -1; 25 | } 26 | int main(){ 27 | int p=3; 28 | int List[6]={4,0,1,1,1,1}; 29 | p=fun(List,6); 30 | // for(int i=0;i<6;i++){ 31 | printf("%d ",p); 32 | // } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /2-2-2.c: -------------------------------------------------------------------------------- 1 | #include 2 | int fun(int List[],int length); 3 | int main(){ 4 | int List[6]={5,3,8,2,6,7}; 5 | printf("%d\n",fun(List,6)); 6 | for(int i=0;i<6;i++){ 7 | printf("%d ",List[i]); 8 | } 9 | return 0; 10 | } 11 | 12 | int fun(int L[],int len){ 13 | int tmp; 14 | int i=0; 15 | int j=len-1; 16 | for(;j>i;i++,j--){ 17 | tmp=L[j]; 18 | L[j]=L[i]; 19 | L[i]=tmp; 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /2-2-3.c: -------------------------------------------------------------------------------- 1 | #include 2 | int fun(int List[],int length,int val); 3 | int main(){ 4 | int List[6]={5,3,8,2,8,7}; 5 | //printf("%d\n",fun(List,6)); 6 | fun(List,6,8); 7 | for(int i=0;i<6;i++){ 8 | printf("%d ",List[i]); 9 | } 10 | return 0; 11 | } 12 | 13 | int fun(int L[],int len,int val){ 14 | int tmp; 15 | int i=0; 16 | int j=0; 17 | for(;i 2 | int fun(int List[],int length,int s,int t); 3 | int main(){ 4 | int List[6]={1,5,4,5,6,1}; 5 | //printf("%d\n",fun(List,6)); 6 | fun(List,6,5,9); 7 | for(int i=0;i<6;i++){ 8 | printf("%d ",List[i]); 9 | } 10 | return 0; 11 | } 12 | 13 | int fun(int L[],int len,int s,int t){ 14 | if(len==0||s>=t){ 15 | printf("error"); 16 | return 0; 17 | } 18 | int tmp; 19 | int i=0; 20 | int j=0; 21 | int k=0; 22 | for(i=0;i 2 | int fun(int List[],int length,int s,int t); 3 | int main(){ 4 | int List[6]={4,4,4,5,6,6}; 5 | //printf("%d\n",fun(List,6)); 6 | fun(List,6,5,9); 7 | for(int i=0;i<6;i++){ 8 | printf("%d ",List[i]); 9 | } 10 | return 0; 11 | } 12 | 13 | int fun(int L[],int len,int s,int t){ 14 | if(len==0||s>=t){ 15 | printf("error"); 16 | return 0; 17 | } 18 | int i=0; 19 | int j=0; 20 | int k=0; 21 | for(i=0;i 2 | #include 3 | int* merge(int l1[],int len1,int l2[],int len2){ 4 | int i=0,j=0,k=0; 5 | int *L=(int *)malloc((len1+len2)*sizeof(int)); //指针必须要赋值。 6 | if(!L){ 7 | return 0; 8 | } 9 | while(il2[j]){ 15 | L[k++]=l2[j]; 16 | j++; 17 | 18 | } 19 | } 20 | while(i 2 | int fun(int l[],int m,int n){ 3 | int i=0,j=0,k=0; 4 | int tmp=0; 5 | 6 | for(;i0;j--){ 9 | l[j]=l[j-1]; 10 | } 11 | l[0]=tmp; 12 | 13 | } 14 | return 0; 15 | 16 | } 17 | int main(){ 18 | int List[6]={4,1,7,5,6,9}; 19 | fun(List,3,3); 20 | for(int i=0;i<6;i++){ 21 | printf("%d ",List[i]); 22 | } 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /2-2-9.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define false 0 3 | #define true 1 4 | #define Maxsize 10 5 | #define length 6 6 | int fun(int l[],int left,int right,int x){ 7 | int i=0,j=0,k=0; 8 | int mid=(left+right)/2; 9 | if(left==right){ 10 | // printf("%d\n",left); 11 | if(l[left]x)return left-1; 13 | } 14 | // printf("%d\n",mid); 15 | if(l[mid]==x){ 16 | return mid; 17 | } 18 | if(l[mid]x){ 22 | return fun(l,left,mid-1,x); 23 | } 24 | } 25 | int main(){ 26 | int List[length+1]={1,2,3,5,6,9,0}; 27 | int x=0; 28 | scanf("%d",&x); 29 | if(x>=List[length-1]){ 30 | List[length]=x; 31 | }else if(x0;i--){ 33 | List[i]=List[i-1]; 34 | } 35 | List[0]=x; 36 | }else{ 37 | int pos=fun(List,0,length-1,x); 38 | printf("%d\n",pos); 39 | if(List[pos]==x){ 40 | int tmp=List[pos+1]; 41 | List[pos+1]=x; 42 | List[pos]=tmp; 43 | }else{ 44 | for(int j=length;j>pos+1;j--){ 45 | List[j]=List[j-1]; 46 | } 47 | List[pos+1]=x; 48 | } 49 | } 50 | for(int i=0;i 2 | #include 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | LinkList fun(LinkList L,int x){ 9 | if(L){ 10 | if(L->data==x){ 11 | LinkList p; 12 | L->next=fun(L->next, x); 13 | p=L; //注意内存泄露！！！ 14 | L=L->next; 15 | free(p); 16 | }else{ 17 | L->next=fun(L->next,x); 18 | } 19 | } 20 | return L; 21 | } 22 | int main(){ 23 | //////////////////////////////////////////////////////////// 24 | ////////////////////建立链表//////////////////////////////// 25 | LinkList L,s; 26 | int x=0; 27 | L=(LinkList)malloc(sizeof(LNode)); 28 | L->next=NULL; 29 | scanf("%d",&x); 30 | while(x!=9999){ 31 | s=(LinkList)malloc(sizeof(LNode)); 32 | s->data=x; 33 | s->next=L->next; 34 | L->next=s; 35 | scanf("%d",&x); 36 | } 37 | //带头结点： 38 | //s=L->next; 39 | //不带头结点： 40 | L=L->next; 41 | s=L; 42 | //////////////////////////////////////////////////////////// 43 | 44 | //函数调用：返回链表 45 | scanf("%d",&x); 46 | L=fun(L,x); 47 | s=L; 48 | 49 | 50 | //打印链表： 51 | while(s){ 52 | printf("%d ",s->data); 53 | s=s->next; 54 | } 55 | free(s); 56 | free(L); 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /2-3-10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L,LinkList &La,LinkList &Lb){ 8 | int count=0; 9 | LinkList lasta=La,lastb=Lb; 10 | while(L->next){ 11 | count++; 12 | if((count%2)==1){ 13 | lasta->next=L->next; 14 | lasta=lasta->next; 15 | L->next=L->next->next; 16 | }else{ 17 | lastb->next=L->next; 18 | lastb=lastb->next; 19 | L->next=L->next->next; 20 | } 21 | } 22 | lasta->next=NULL; 23 | lastb->next=NULL; 24 | } 25 | void fun_start(LinkList &L){ 26 | LinkList s=L->next; 27 | LinkList La=(LinkList)malloc(sizeof(LNode)); 28 | LinkList Lb=(LinkList)malloc(sizeof(LNode)); 29 | LinkList q; 30 | fun(L,La,Lb); 31 | while(La->next){ 32 | cout<next->data<<" "; 33 | q=La->next; 34 | La->next=q->next; 35 | free(q); 36 | } 37 | cout<next){ 39 | cout<next->data<<" "; 40 | q=Lb->next; 41 | Lb->next=q->next; 42 | free(q); 43 | } 44 | cout<next=NULL; 97 | cin>>x; 98 | while(x!=9999){ 99 | s=(LinkList)malloc(sizeof(LNode)); 100 | s->data=x; 101 | s->next=L->next; 102 | L->next=s; 103 | cin>>x; 104 | } 105 | LinkList tmp,pre,now; 106 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 107 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 108 | //now迭代为tmp 109 | pre=NULL; 110 | now=L->next; 111 | while(now){ 112 | tmp=now->next; 113 | now->next=pre; 114 | pre=now; 115 | now=tmp; 116 | 117 | } 118 | //带头结点 119 | L->next=pre; 120 | fun_start(L); 121 | //打印链表 122 | //不带头结点 123 | s=L->next; 124 | while(s){ 125 | cout<data<<" "; 126 | s=s->next; 127 | } 128 | cout<next; 134 | free(p); 135 | } 136 | 137 | return 0; 138 | } 139 | ////////////////////////////////////////////////////// 140 | ////////////////////////////////////////////////////// 141 | -------------------------------------------------------------------------------- /2-3-11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L,LinkList &hc){ 8 | LinkList p=L->next,q; 9 | while(p){ 10 | q=p->next; 11 | p->next=q->next; 12 | p=p->next; 13 | q->next=hc->next; 14 | hc->next=q; 15 | } 16 | } 17 | void fun_start(LinkList &L){ 18 | LinkList s=L->next; 19 | LinkList La=(LinkList)malloc(sizeof(LNode)); 20 | La->next=NULL; 21 | LinkList q; 22 | fun(L,La); 23 | while(La->next){ 24 | cout<next->data<<" "; 25 | q=La->next; 26 | La->next=q->next; 27 | free(q); 28 | } 29 | cout<next=NULL; 82 | cin>>x; 83 | while(x!=9999){ 84 | s=(LinkList)malloc(sizeof(LNode)); 85 | s->data=x; 86 | s->next=L->next; 87 | L->next=s; 88 | cin>>x; 89 | } 90 | LinkList tmp,pre,now; 91 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 92 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 93 | //now迭代为tmp 94 | pre=NULL; 95 | now=L->next; 96 | while(now){ 97 | tmp=now->next; 98 | now->next=pre; 99 | pre=now; 100 | now=tmp; 101 | 102 | } 103 | //带头结点 104 | L->next=pre; 105 | fun_start(L); 106 | //打印链表 107 | //不带头结点 108 | s=L->next; 109 | while(s){ 110 | cout<data<<" "; 111 | s=s->next; 112 | } 113 | cout<next; 119 | free(p); 120 | } 121 | 122 | return 0; 123 | } 124 | ////////////////////////////////////////////////////// 125 | ////////////////////////////////////////////////////// 126 | -------------------------------------------------------------------------------- /2-3-12.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L){ 8 | LinkList p=L->next,pre=L,q; 9 | while(p){ 10 | if(p->data==pre->data){ 11 | q=p; 12 | p=p->next; 13 | pre->next=p; 14 | free(q); 15 | }else{ 16 | pre=p; 17 | p=p->next; 18 | } 19 | } 20 | } 21 | void fun_start(LinkList &L){ 22 | LinkList s=L->next; 23 | fun(s); 24 | } 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | ////////////////////main 68 | ////////////////////// 69 | //////////////////// 70 | int main(){ 71 | ////////////////////建立链表//////////////////////////////// 72 | LinkList L,s; 73 | int x=0; 74 | L=(LinkList)malloc(sizeof(LNode)); 75 | L->next=NULL; 76 | cin>>x; 77 | while(x!=9999){ 78 | s=(LinkList)malloc(sizeof(LNode)); 79 | s->data=x; 80 | s->next=L->next; 81 | L->next=s; 82 | cin>>x; 83 | } 84 | LinkList tmp,pre,now; 85 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 86 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 87 | //now迭代为tmp 88 | pre=NULL; 89 | now=L->next; 90 | while(now){ 91 | tmp=now->next; 92 | now->next=pre; 93 | pre=now; 94 | now=tmp; 95 | 96 | } 97 | //带头结点 98 | L->next=pre; 99 | fun_start(L); 100 | //打印链表 101 | //不带头结点 102 | s=L->next; 103 | while(s){ 104 | cout<data<<" "; 105 | s=s->next; 106 | } 107 | cout<next; 113 | free(p); 114 | } 115 | 116 | return 0; 117 | } 118 | ////////////////////////////////////////////////////// 119 | ////////////////////////////////////////////////////// 120 | -------------------------------------------------------------------------------- /2-3-13.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L,LinkList &L1,LinkList &L2){ 8 | LinkList p1=L1->next,p2=L2->next;//扫描指针 9 | LinkList tmp; 10 | while(p1&&p2){ 11 | if(p1->datadata){ 12 | tmp=p1->next; 13 | p1->next=L->next; 14 | L->next=p1; 15 | p1=tmp; 16 | }else{ 17 | tmp=p2->next; 18 | p2->next=L->next; 19 | L->next=p2; 20 | p2=tmp; 21 | } 22 | } 23 | while(p1){ 24 | tmp=p1->next; 25 | p1->next=L->next; 26 | L->next=p1; 27 | p1=tmp; 28 | } 29 | while(p2){ 30 | tmp=p2->next; 31 | p2->next=L->next; 32 | L->next=p2; 33 | p2=tmp; 34 | } 35 | } 36 | void fun_start(LinkList &L,LinkList &L1,LinkList &L2){ 37 | fun(L,L1,L2); 38 | } 39 | void build_list(LinkList &L){ 40 | LinkList s; 41 | int x=0; 42 | L=(LinkList)malloc(sizeof(LNode)); 43 | L->next=NULL; 44 | cin>>x; 45 | //头插法 懒得改尾插 46 | while(x!=9999){ 47 | s=(LinkList)malloc(sizeof(LNode)); 48 | s->data=x; 49 | s->next=L->next; 50 | L->next=s; 51 | cin>>x; 52 | } 53 | LinkList tmp,pre,now; 54 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 55 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 56 | //now迭代为tmp 57 | pre=NULL; 58 | now=L->next; 59 | while(now){ 60 | tmp=now->next; 61 | now->next=pre; 62 | pre=now; 63 | now=tmp; 64 | 65 | } 66 | //带头结点 67 | L->next=pre; 68 | } 69 | 70 | void print_list(LinkList &L){ 71 | //打印链表 72 | //带头结点 73 | LinkList s=L->next; 74 | while(s){ 75 | cout<data<<" "; 76 | s=s->next; 77 | } 78 | cout<next; 83 | free(p); 84 | } 85 | } 86 | //////////////////////////////////////////////////// 87 | int main(){ 88 | LinkList l1,l2; 89 | build_list(l1); 90 | build_list(l2); 91 | LinkList L=(LinkList)malloc(sizeof(LNode)); 92 | L->next=NULL; 93 | fun(L,l1,l2); 94 | print_list(L); 95 | print_list(l1); 96 | print_list(l2); 97 | return 0; 98 | } 99 | ///////////////////////////////////////////////// 100 | -------------------------------------------------------------------------------- /2-3-14.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | // p为L的尾指针用于尾插法，初始时为L 9 | void fun(LinkList &L,LinkList &L1,LinkList &L2){ 10 | LinkList p=L,p1=L1->next,p2=L2->next;//扫描指针 11 | LinkList tmp; 12 | // bug 笔记：这里不能改为 if() if() 的形式，因为if(A) A会被执行 13 | // 如 if(p1->data) 如果之前p1递增了 p1->next为空了，这里就会访问错误 14 | // 尽管if条件可能不成立，但if条件却被执行了 15 | // 需要用 else if 用 else if 16 | while(p1&&p2){ 17 | if(p1->datadata){ 18 | p1=p1->next; 19 | }else if(p1->data>p2->data){ 20 | p2=p2->next; 21 | }else if(p1->data==p2->data){ 22 | p->next=(LinkList)malloc(sizeof(LNode)); 23 | p=p->next; 24 | p->data=p1->data; 25 | p1=p1->next; 26 | p2=p2->next; 27 | } 28 | } 29 | p->next=NULL; 30 | } 31 | void fun_start(LinkList &L,LinkList &L1,LinkList &L2){ 32 | fun(L,L1,L2); 33 | } 34 | void build_list(LinkList &L){ 35 | LinkList s; 36 | int x=0; 37 | L=(LinkList)malloc(sizeof(LNode)); 38 | L->next=NULL; 39 | cin>>x; 40 | //头插法 懒得改尾插 41 | while(x!=9999){ 42 | s=(LinkList)malloc(sizeof(LNode)); 43 | s->data=x; 44 | s->next=L->next; 45 | L->next=s; 46 | cin>>x; 47 | } 48 | LinkList tmp,pre,now; 49 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 50 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 51 | //now迭代为tmp 52 | pre=NULL; 53 | now=L->next; 54 | while(now){ 55 | tmp=now->next; 56 | now->next=pre; 57 | pre=now; 58 | now=tmp; 59 | 60 | } 61 | //带头结点 62 | L->next=pre; 63 | } 64 | 65 | void print_list(LinkList &L){ 66 | //打印链表 67 | //带头结点 68 | LinkList s=L->next; 69 | while(s){ 70 | cout<data<<" "; 71 | s=s->next; 72 | } 73 | cout<next; 78 | free(p); 79 | } 80 | } 81 | //////////////////////////////////////////////////// 82 | int main(){ 83 | LinkList l1,l2; 84 | build_list(l1); 85 | build_list(l2); 86 | LinkList L=(LinkList)malloc(sizeof(LNode)); 87 | L->next=NULL; 88 | fun_start(L,l1,l2); 89 | print_list(L); 90 | print_list(l1); 91 | print_list(l2); 92 | return 0; 93 | } 94 | ///////////////////////////////////////////////// 95 | -------------------------------------------------------------------------------- /2-3-15.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | // p为L的尾指针用于尾插法，初始时为L 9 | void fun(LinkList &L1,LinkList &L2){ 10 | LinkList p=L1,p1=L1->next,p2=L2->next,q;//扫描指针 11 | LinkList tmp; 12 | // bug 笔记：这里不能改为 if() if() 的形式，因为if(A) A会被执行 13 | // 如 if(p1->data) 如果之前p1递增了 p1->next为空了，这里就会访问错误 14 | // 尽管if条件可能不成立，但if条件却被执行了 15 | // 需要用 else if 用 else if 16 | while(p1&&p2){ 17 | if(p1->datadata){ 18 | q=p1; 19 | p1=p1->next; 20 | free(q); 21 | }else if(p1->data>p2->data){ 22 | p2=p2->next; 23 | }else if(p1->data==p2->data){ 24 | p->next=p1; 25 | p=p1; 26 | p1=p1->next; 27 | p2=p2->next; 28 | } 29 | } 30 | p->next=NULL; 31 | } 32 | void fun_start(LinkList &L1,LinkList &L2){ 33 | fun(L1,L2); 34 | } 35 | void build_list(LinkList &L){ 36 | LinkList s; 37 | int x=0; 38 | L=(LinkList)malloc(sizeof(LNode)); 39 | L->next=NULL; 40 | cin>>x; 41 | //头插法 懒得改尾插 42 | while(x!=9999){ 43 | s=(LinkList)malloc(sizeof(LNode)); 44 | s->data=x; 45 | s->next=L->next; 46 | L->next=s; 47 | cin>>x; 48 | } 49 | LinkList tmp,pre,now; 50 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 51 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 52 | //now迭代为tmp 53 | pre=NULL; 54 | now=L->next; 55 | while(now){ 56 | tmp=now->next; 57 | now->next=pre; 58 | pre=now; 59 | now=tmp; 60 | 61 | } 62 | //带头结点 63 | L->next=pre; 64 | } 65 | 66 | void print_list(LinkList &L){ 67 | //打印链表 68 | //带头结点 69 | LinkList s=L->next; 70 | while(s){ 71 | cout<data<<" "; 72 | s=s->next; 73 | } 74 | cout<next; 79 | free(p); 80 | } 81 | } 82 | //////////////////////////////////////////////////// 83 | int main(){ 84 | LinkList l1,l2; 85 | build_list(l1); 86 | build_list(l2); 87 | fun_start(l1,l2); 88 | print_list(l1); 89 | print_list(l2); 90 | return 0; 91 | } 92 | ///////////////////////////////////////////////// 93 | -------------------------------------------------------------------------------- /2-3-16.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | //写复杂了 8 | int fun(LinkList &L1,LinkList &L2,int m,int n){ 9 | LinkList p1=L1->next,p2=L2->next,q;//扫描指针 10 | int count=0,tmp=0; 11 | if(mdata!=p2->data);p1=p1->next)count++; 14 | if(!p1)return 0; 15 | q=p1; 16 | for(;p1&&p2&&(p1->data==p2->data);p1=p1->next,p2=p2->next)tmp++; 17 | if(tmp==n){ 18 | cout<next; 24 | p2=L2->next; 25 | } 26 | return 0; 27 | } 28 | void fun_start(LinkList &L1,LinkList &L2){ 29 | LinkList tmp; 30 | int m=0,n=0; 31 | for(tmp=L1->next;tmp!=NULL;tmp=tmp->next)m++; 32 | for(tmp=L2->next;tmp!=NULL;tmp=tmp->next)n++; 33 | cout<<(fun(L1,L2,m,n)?"true":"false")<next=NULL; 40 | cin>>x; 41 | //头插法 懒得改尾插 42 | while(x!=9999){ 43 | s=(LinkList)malloc(sizeof(LNode)); 44 | s->data=x; 45 | s->next=L->next; 46 | L->next=s; 47 | cin>>x; 48 | } 49 | LinkList tmp,pre,now; 50 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 51 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 52 | //now迭代为tmp 53 | pre=NULL; 54 | now=L->next; 55 | while(now){ 56 | tmp=now->next; 57 | now->next=pre; 58 | pre=now; 59 | now=tmp; 60 | 61 | } 62 | //带头结点 63 | L->next=pre; 64 | } 65 | 66 | void print_list(LinkList &L){ 67 | //打印链表 68 | //带头结点 69 | LinkList s=L->next; 70 | while(s){ 71 | cout<data<<" "; 72 | s=s->next; 73 | } 74 | cout<next; 79 | free(p); 80 | } 81 | } 82 | //////////////////////////////////////////////////// 83 | int main(){ 84 | LinkList l1,l2; 85 | build_list(l1); 86 | build_list(l2); 87 | fun_start(l1,l2); 88 | print_list(l1); 89 | print_list(l2); 90 | return 0; 91 | } 92 | ///////////////////////////////////////////////// 93 | -------------------------------------------------------------------------------- /2-3-17.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* prior; 6 | struct LNode* next; 7 | }LNode, *LinkList; 8 | int fun(LinkList L,LinkList rear){ 9 | LinkList p=L->next,q=L->prior; 10 | rear=q; 11 | //bug 笔记： 此处应用与 如果是或的话死循环！ 12 | //因为：或运算的条件恒成立 跳出循环条件是或的 13 | //因为这是带头结点的双链表（懒得改）仅用rear!=p就成立 14 | //（会循环一轮） 15 | while(rear!=p&&rear->prior!=p){ 16 | if(rear->data==p->data){ 17 | p=p->next; 18 | rear=rear->prior; 19 | }else{ 20 | return 0; 21 | } 22 | } 23 | if((rear->prior==p)&&(rear->data==p->data))return 1; 24 | if(rear==p)return 1; 25 | return 0; 26 | } 27 | void fun_start(LinkList &L1,LinkList &rear){ 28 | cout<<(fun(L1,rear)?"true":"false")<next=NULL; 36 | rear=L; 37 | cin>>x; 38 | //头插法 懒得改尾插 39 | while(x!=9999){ 40 | s=(LinkList)malloc(sizeof(LNode)); 41 | s->data=x; 42 | rear->next=s; 43 | /////双链表 44 | s->prior=rear; 45 | ///// 46 | rear=rear->next; 47 | cin>>x; 48 | } 49 | //循环双链表 50 | rear->next=L; 51 | L->prior=rear; 52 | } 53 | 54 | void print_list(LinkList &L){ 55 | //打印链表 56 | //带头结点 57 | LinkList s=L->next; 58 | //while(s){ 59 | //双链表 60 | while(s!=L){ 61 | cout<data<<" "; 62 | s=s->next; 63 | } 64 | cout<next; 69 | free(p); 70 | } 71 | } 72 | //////////////////////////////////////////////////// 73 | int main(){ 74 | LinkList l1,l2,rear1,rear2; 75 | build_list(l1,rear1); 76 | // build_list(l2); 77 | fun_start(l1,rear1); 78 | print_list(l1); 79 | // print_list(l2); 80 | return 0; 81 | } 82 | ///////////////////////////////////////////////// 83 | -------------------------------------------------------------------------------- /2-3-18.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | // struct LNode* prior; 6 | struct LNode* next; 7 | }LNode, *LinkList; 8 | void fun(LinkList &L1,LinkList &L2){ 9 | LinkList p=L1->next; 10 | while(p->next!=L2){ 11 | if(p->next==L1){ 12 | p->next=L2->next; 13 | } 14 | p=p->next; 15 | } 16 | p->next=L1; 17 | } 18 | void fun_start(LinkList &L1,LinkList &L2){ 19 | fun(L1,L2); 20 | } 21 | //带头结点 22 | void build_list(LinkList &L,LinkList &rear){ 23 | LinkList s; 24 | int x=0; 25 | L=(LinkList)malloc(sizeof(LNode)); 26 | L->next=NULL; 27 | rear=L; 28 | cin>>x; 29 | while(x!=9999){ 30 | s=(LinkList)malloc(sizeof(LNode)); 31 | s->data=x; 32 | rear->next=s; 33 | /////双链表 34 | // s->prior=rear; 35 | ///// 36 | rear=s; 37 | cin>>x; 38 | } 39 | //循环单链表 40 | rear->next=L; 41 | // L->prior=rear; 42 | } 43 | 44 | void print_list(LinkList &L){ 45 | //打印链表 46 | //带头结点 47 | LinkList s=L->next; 48 | //while(s){ 49 | //双链表 50 | while(s!=L){ 51 | cout<data<<" "; 52 | s=s->next; 53 | } 54 | cout<next; 59 | free(p); 60 | } 61 | } 62 | void test(LinkList L,LinkList rear){ 63 | //测试前后 64 | LinkList p=L->next; 65 | cout<<"test1:front"<data<<" "; 68 | p=p->next; 69 | } 70 | cout<data<<" "; 73 | // rear=rear->prior; 74 | // } 75 | cout< 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | // struct LNode* prior; 6 | struct LNode* next; 7 | }LNode, *LinkList; 8 | void fun(LinkList &L){ 9 | LinkList p=L->next,pre=L,minp=pre,tmp; 10 | int minv=p->data; 11 | //表不为空时 12 | //使用双指针扫一遍链表找到最小值，记录 13 | //然后删除最小值结点 输出 要注意输出后要重置各项 14 | while(L->next!=L){ 15 | while(p!=L&&pre->next!=L){ 16 | if(p->datadata; 18 | minp=pre; 19 | } 20 | p=p->next; 21 | pre=pre->next; 22 | } 23 | tmp=minp->next; 24 | minp->next=tmp->next; 25 | cout<next; 29 | minv=p->data; 30 | minp=pre; 31 | } 32 | free(L); 33 | cout<next=NULL; 44 | rear=L; 45 | cin>>x; 46 | while(x!=9999){ 47 | s=(LinkList)malloc(sizeof(LNode)); 48 | s->data=x; 49 | rear->next=s; 50 | /////双链表 51 | // s->prior=rear; 52 | ///// 53 | rear=s; 54 | cin>>x; 55 | } 56 | //循环单链表 57 | rear->next=L; 58 | // L->prior=rear; 59 | } 60 | 61 | void print_list(LinkList &L){ 62 | //打印链表 63 | //带头结点 64 | LinkList s=L->next; 65 | //while(s){ 66 | //双链表 67 | while(s!=L){ 68 | cout<data<<" "; 69 | s=s->next; 70 | } 71 | cout<next; 76 | free(p); 77 | } 78 | } 79 | void test(LinkList L,LinkList rear){ 80 | //测试前后 81 | LinkList p=L->next; 82 | cout<<"test1:front"<data<<" "; 85 | p=p->next; 86 | } 87 | cout<data<<" "; 90 | // rear=rear->prior; 91 | // } 92 | cout< 2 | #include 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | LinkList fun(LinkList L,int x){ 9 | if(L){ 10 | if(L->data==x){ 11 | LinkList p; 12 | L->next=fun(L->next, x); 13 | p=L; //注意内存泄露！！！ 14 | L=L->next; 15 | free(p); 16 | }else{ 17 | L->next=fun(L->next,x); 18 | } 19 | return L; 20 | } 21 | return NULL; 22 | } 23 | int main(){ 24 | //////////////////////////////////////////////////////////// 25 | ////////////////////建立链表//////////////////////////////// 26 | LinkList L,s; 27 | int x=0; 28 | L=(LinkList)malloc(sizeof(LNode)); 29 | L->next=NULL; 30 | scanf("%d",&x); 31 | while(x!=9999){ 32 | s=(LinkList)malloc(sizeof(LNode)); 33 | s->data=x; 34 | s->next=L->next; 35 | L->next=s; 36 | scanf("%d",&x); 37 | } 38 | //带头结点： 39 | s=L->next; 40 | //不带头结点： 41 | //L=L->next; 42 | //s=L; 43 | //////////////////////////////////////////////////////////// 44 | 45 | //函数调用：返回链表 46 | scanf("%d",&x); 47 | L->next=fun(L->next,x); 48 | s=L->next; 49 | 50 | 51 | //打印链表： 52 | while(s){ 53 | printf("%d ",s->data); 54 | s=s->next; 55 | } 56 | free(s); 57 | free(L); 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /2-3-2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | void fun(LinkList &L,int x){ 9 | LinkList p=L->next,pre=L,q; 10 | while(p){ 11 | if(p->data==x){ 12 | q=p; 13 | p=p->next; 14 | pre->next=p; 15 | free(q); 16 | }else{ 17 | pre=p; 18 | p=p->next; 19 | } 20 | } 21 | } 22 | int main(){ 23 | //////////////////////////////////////////////////////////// 24 | ////////////////////建立链表//////////////////////////////// 25 | LinkList L,s; 26 | int x=0; 27 | L=(LinkList)malloc(sizeof(LNode)); 28 | L->next=NULL; 29 | cin>>x; 30 | while(x!=9999){ 31 | s=(LinkList)malloc(sizeof(LNode)); 32 | s->data=x; 33 | s->next=L->next; 34 | L->next=s; 35 | cin>>x; 36 | } 37 | //带头结点： 38 | s=L->next; 39 | //不带头结点： 40 | //L=L->next; 41 | //s=L; 42 | //////////////////////////////////////////////////////////// 43 | 44 | //函数调用：返回链表 45 | cin>>x; 46 | fun(L,x); 47 | s=L->next; 48 | 49 | 50 | //打印链表： 51 | while(s){ 52 | cout<data<<" "; 53 | s=s->next; 54 | } 55 | cout< 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | int freq; 6 | struct LNode* prior; 7 | struct LNode* next; 8 | }LNode, *LinkList; 9 | int Locate(LinkList &L,int x){ 10 | LinkList p=L->next,q;//q保存插入的前结点 11 | for(;p&&p->data!=x;p=p->next); 12 | if(p){ 13 | p->freq++; 14 | for(q=p->prior;q!=L&&q->freq<=p->freq;q=q->prior); 15 | //删除p 16 | p->prior->next=p->next; 17 | if(p->next){ 18 | p->next->prior=p->prior; 19 | } 20 | //插入p 21 | p->next=q->next; 22 | q->next->prior=p; 23 | p->prior=q; 24 | q->next=p; 25 | return 0; 26 | } 27 | return 1; 28 | } 29 | void fun_start(LinkList &L1,LinkList &rear){ 30 | int x; 31 | cin>>x; 32 | while(x!=9999){ 33 | Locate(L1,x); 34 | cin>>x; 35 | } 36 | } 37 | //带头结点 38 | void build_list(LinkList &L,LinkList &rear){ 39 | LinkList s; 40 | int x=0; 41 | L=(LinkList)malloc(sizeof(LNode)); 42 | L->next=NULL; 43 | rear=L; 44 | cin>>x; 45 | //尾插 46 | while(x!=9999){ 47 | s=(LinkList)malloc(sizeof(LNode)); 48 | s->data=x; 49 | s->freq=0; 50 | rear->next=s; 51 | /////双链表 52 | s->prior=rear; 53 | ///// 54 | rear=rear->next; 55 | cin>>x; 56 | } 57 | rear->next=NULL; 58 | L->prior=NULL; 59 | //循环双链表 60 | //rear->next=L; 61 | //L->prior=rear; 62 | } 63 | 64 | void print_list(LinkList &L){ 65 | //打印链表 66 | //带头结点 67 | LinkList s=L->next; 68 | //while(s){ 69 | //双链表 70 | while(s){ 71 | cout<data<<":"<freq<<" "; 72 | s=s->next; 73 | } 74 | cout<next; 79 | free(p); 80 | } 81 | } 82 | //////////////////////////////////////////////////// 83 | int main(){ 84 | LinkList l1,l2,rear1,rear2; 85 | build_list(l1,rear1); 86 | // build_list(l2); 87 | fun_start(l1,rear1); 88 | print_list(l1); 89 | // print_list(l2); 90 | return 0; 91 | } 92 | ///////////////////////////////////////////////// 93 | -------------------------------------------------------------------------------- /2-3-21.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | int fun(LinkList &L,int x){ 8 | LinkList p=L->next,pre=L,q; 9 | int count=0; 10 | for(p=L->next;p!=NULL;p=p->next)count++; 11 | if(countnext;p&&count>x;count--){ 13 | p=p->next; 14 | } 15 | if(!p){ 16 | return 0; 17 | } 18 | cout<data<next; 23 | int k; 24 | cin>>k; 25 | fun(L,k); 26 | } 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | ////////////////////main 70 | ////////////////////// 71 | //////////////////// 72 | int main(){ 73 | ////////////////////建立链表//////////////////////////////// 74 | LinkList L,s; 75 | int x=0; 76 | L=(LinkList)malloc(sizeof(LNode)); 77 | L->next=NULL; 78 | cin>>x; 79 | while(x!=9999){ 80 | s=(LinkList)malloc(sizeof(LNode)); 81 | s->data=x; 82 | s->next=L->next; 83 | L->next=s; 84 | cin>>x; 85 | } 86 | LinkList tmp,pre,now; 87 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 88 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 89 | //now迭代为tmp 90 | pre=NULL; 91 | now=L->next; 92 | while(now){ 93 | tmp=now->next; 94 | now->next=pre; 95 | pre=now; 96 | now=tmp; 97 | 98 | } 99 | //带头结点 100 | L->next=pre; 101 | fun_start(L); 102 | //打印链表 103 | //不带头结点 104 | s=L->next; 105 | while(s){ 106 | cout<data<<" "; 107 | s=s->next; 108 | } 109 | cout<next; 115 | free(p); 116 | } 117 | 118 | return 0; 119 | } 120 | ////////////////////////////////////////////////////// 121 | ////////////////////////////////////////////////////// 122 | -------------------------------------------------------------------------------- /2-3-22.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | int fun(LinkList &L1,LinkList &L2,int m,int n){ 8 | LinkList p1=L1->next,p2=L2->next,q;//扫描指针 9 | int count=0; 10 | if(m>n){ 11 | for(count=0;countnext; 12 | for(;p1&&p2&&p1!=p2;p1=p1->next,p2=p2->next)count++; 13 | if(p1)return count+1; 14 | return -1; 15 | }else{ 16 | for(count=0;countnext; 17 | for(;p1&&p2&&p1!=p2;p1=p1->next,p2=p2->next)count++; 18 | if(p2)return count+1; 19 | return -1; 20 | } 21 | 22 | } 23 | void fun_start(LinkList &L1,LinkList &L2){ 24 | LinkList tmp; 25 | int m=0,n=0; 26 | for(tmp=L1->next;tmp!=NULL;tmp=tmp->next)m++; 27 | for(tmp=L2->next;tmp!=NULL;tmp=tmp->next)n++; 28 | cout<next; 32 | for(;p->next;p=p->next); 33 | p->next=L3->next; 34 | } 35 | void build_list(LinkList &L){ 36 | LinkList s; 37 | int x=0; 38 | L=(LinkList)malloc(sizeof(LNode)); 39 | L->next=NULL; 40 | cin>>x; 41 | //头插法 懒得改尾插 42 | while(x!=9999){ 43 | s=(LinkList)malloc(sizeof(LNode)); 44 | s->data=x; 45 | s->next=L->next; 46 | L->next=s; 47 | cin>>x; 48 | } 49 | LinkList tmp,pre,now; 50 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 51 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 52 | //now迭代为tmp 53 | pre=NULL; 54 | now=L->next; 55 | while(now){ 56 | tmp=now->next; 57 | now->next=pre; 58 | pre=now; 59 | now=tmp; 60 | 61 | } 62 | //带头结点 63 | L->next=pre; 64 | } 65 | 66 | void print_list(LinkList &L){ 67 | //打印链表 68 | //带头结点 69 | LinkList s=L->next; 70 | while(s){ 71 | cout<data<<" "; 72 | s=s->next; 73 | } 74 | cout<next; 79 | free(p); 80 | } 81 | } 82 | //////////////////////////////////////////////////// 83 | int main(){ 84 | LinkList l1,l2,l3; 85 | build_list(l1); 86 | build_list(l2); 87 | build_list(l3); 88 | merge_list(l1,l3); 89 | merge_list(l2,l3); 90 | fun_start(l1,l2); 91 | print_list(l1); 92 | print_list(l2); 93 | print_list(l3); 94 | return 0; 95 | } 96 | ///////////////////////////////////////////////// 97 | -------------------------------------------------------------------------------- /2-3-23.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAXSIZE 100 3 | using namespace std; 4 | typedef struct LNode{ 5 | int data; 6 | struct LNode* next; 7 | }LNode, *LinkList; 8 | int tag[MAXSIZE]; 9 | void fun(LinkList &L){ 10 | LinkList p=L->next,pre=L,q; 11 | while(p){ 12 | if(tag[abs(p->data)]){ 13 | q=p; 14 | p=p->next; 15 | pre->next=p; 16 | free(q); 17 | }else{ 18 | tag[abs(p->data)]=1; 19 | pre=p; 20 | p=p->next; 21 | } 22 | } 23 | } 24 | void fun_start(LinkList &L){ 25 | LinkList s=L->next; 26 | int count=0; 27 | while(s){ 28 | count++; 29 | s=s->next; 30 | } 31 | int n=0; 32 | cin>>n; 33 | for(int i=0;inext=NULL; 87 | cin>>x; 88 | while(x!=9999){ 89 | s=(LinkList)malloc(sizeof(LNode)); 90 | s->data=x; 91 | s->next=L->next; 92 | L->next=s; 93 | cin>>x; 94 | } 95 | LinkList tmp,pre,now; 96 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 97 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 98 | //now迭代为tmp 99 | pre=NULL; 100 | now=L->next; 101 | while(now){ 102 | tmp=now->next; 103 | now->next=pre; 104 | pre=now; 105 | now=tmp; 106 | 107 | } 108 | //带头结点 109 | L->next=pre; 110 | fun_start(L); 111 | //打印链表 112 | //不带头结点 113 | s=L->next; 114 | while(s){ 115 | cout<data<<" "; 116 | s=s->next; 117 | } 118 | cout<next; 124 | free(p); 125 | } 126 | 127 | return 0; 128 | } 129 | ////////////////////////////////////////////////////// 130 | ////////////////////////////////////////////////////// 131 | -------------------------------------------------------------------------------- /2-3-3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | void fun(LinkList L){ 9 | if(L==NULL){ 10 | return; 11 | }else{ 12 | fun(L->next); 13 | cout<data<<" "; 14 | } 15 | } 16 | int main(){ 17 | //////////////////////////////////////////////////////////// 18 | ////////////////////建立链表//////////////////////////////// 19 | LinkList L,s; 20 | int x=0; 21 | L=(LinkList)malloc(sizeof(LNode)); 22 | L->next=NULL; 23 | cin>>x; 24 | while(x!=9999){ 25 | s=(LinkList)malloc(sizeof(LNode)); 26 | s->data=x; 27 | s->next=L->next; 28 | L->next=s; 29 | cin>>x; 30 | } 31 | //带头结点： 32 | s=L->next; 33 | //不带头结点： 34 | //L=L->next; 35 | //s=L; 36 | //////////////////////////////////////////////////////////// 37 | 38 | //函数调用：返回链表 39 | //cin>>x; 40 | fun(L->next); 41 | s=L->next; 42 | 43 | 44 | //打印链表： 45 | //while(s){ 46 | // cout<data<<" "; 47 | // s=s->next; 48 | //} 49 | cout<next; 55 | free(q); 56 | } 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /2-3-4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | void fun(LinkList &L,int x){ 9 | LinkList p=L->next,pre=L,q; 10 | while(p){ 11 | if(p->data==x){ 12 | q=p; 13 | p=p->next; 14 | pre->next=p; 15 | free(q); 16 | }else{ 17 | pre=p; 18 | p=p->next; 19 | } 20 | } 21 | } 22 | int main(){ 23 | //////////////////////////////////////////////////////////// 24 | ////////////////////建立链表//////////////////////////////// 25 | LinkList L,s; 26 | int x=0; 27 | L=(LinkList)malloc(sizeof(LNode)); 28 | L->next=NULL; 29 | cin>>x; 30 | while(x!=9999){ 31 | s=(LinkList)malloc(sizeof(LNode)); 32 | s->data=x; 33 | s->next=L->next; 34 | L->next=s; 35 | cin>>x; 36 | } 37 | //带头结点： 38 | s=L->next; 39 | //不带头结点： 40 | //L=L->next; 41 | //s=L; 42 | //////////////////////////////////////////////////////////// 43 | 44 | //函数调用：返回链表 45 | //cin>>x; 46 | if(s)x=s->data;else return 1; 47 | while(s){ 48 | if(x>s->data)x=s->data; 49 | s=s->next; 50 | } 51 | fun(L,x); 52 | s=L->next; 53 | 54 | 55 | //打印链表： 56 | while(s){ 57 | cout<data<<" "; 58 | s=s->next; 59 | } 60 | cout<next; 66 | free(p); 67 | } 68 | 69 | return 0; 70 | } 71 | -------------------------------------------------------------------------------- /2-3-5.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | void fun(LinkList &L,int x){ 9 | LinkList p=L->next,pre=L,q; 10 | while(p){ 11 | if(p->data==x){ 12 | q=p; 13 | p=p->next; 14 | pre->next=p; 15 | free(q); 16 | }else{ 17 | pre=p; 18 | p=p->next; 19 | } 20 | } 21 | } 22 | int main(){ 23 | //////////////////////////////////////////////////////////// 24 | ////////////////////建立链表//////////////////////////////// 25 | LinkList L,s; 26 | int x=0; 27 | L=(LinkList)malloc(sizeof(LNode)); 28 | L->next=NULL; 29 | cin>>x; 30 | while(x!=9999){ 31 | s=(LinkList)malloc(sizeof(LNode)); 32 | s->data=x; 33 | s->next=L->next; 34 | L->next=s; 35 | cin>>x; 36 | } 37 | //带头结点： 38 | s=L->next; 39 | //不带头结点： 40 | //L=L->next; 41 | //s=L; 42 | //////////////////////////////////////////////////////////// 43 | 44 | //函数调用：返回链表 45 | //cin>>x; 46 | LinkList tmp,pre,now; 47 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 48 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 49 | //now迭代为tmp 50 | pre=NULL; 51 | now=L->next; 52 | while(now){ 53 | tmp=now->next; 54 | now->next=pre; 55 | pre=now; 56 | now=tmp; 57 | 58 | } 59 | L->next=pre; 60 | //fun(L,x); 61 | s=L->next; 62 | 63 | 64 | //打印链表： 65 | while(s){ 66 | cout<data<<" "; 67 | s=s->next; 68 | } 69 | cout<next; 75 | free(p); 76 | } 77 | 78 | return 0; 79 | } 80 | -------------------------------------------------------------------------------- /2-3-6.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L,int n){ 8 | LinkList p=L->next,pre=L,q; 9 | int tmp=0,i=1; 10 | while(n){ 11 | p=L->next; 12 | pre=L; 13 | i=1; 14 | while(idatadata){ 16 | tmp=p->data; 17 | p->data=pre->data; 18 | pre->data=tmp; 19 | } 20 | pre=p; 21 | p=p->next; 22 | i++; 23 | } 24 | n--; 25 | } 26 | } 27 | void fun_start(LinkList &L){ 28 | LinkList s=L->next; 29 | int count=0; 30 | while(s){ 31 | count++; 32 | s=s->next; 33 | } 34 | fun(L->next,count); 35 | } 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | ////////////////////main 79 | ////////////////////// 80 | //////////////////// 81 | int main(){ 82 | ////////////////////建立链表//////////////////////////////// 83 | LinkList L,s; 84 | int x=0; 85 | L=(LinkList)malloc(sizeof(LNode)); 86 | L->next=NULL; 87 | cin>>x; 88 | while(x!=9999){ 89 | s=(LinkList)malloc(sizeof(LNode)); 90 | s->data=x; 91 | s->next=L->next; 92 | L->next=s; 93 | cin>>x; 94 | } 95 | LinkList tmp,pre,now; 96 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 97 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 98 | //now迭代为tmp 99 | pre=NULL; 100 | now=L->next; 101 | while(now){ 102 | tmp=now->next; 103 | now->next=pre; 104 | pre=now; 105 | now=tmp; 106 | 107 | } 108 | //带头结点 109 | L->next=pre; 110 | fun_start(L); 111 | //打印链表 112 | //不带头结点 113 | s=L->next; 114 | while(s){ 115 | cout<data<<" "; 116 | s=s->next; 117 | } 118 | cout<next; 124 | free(p); 125 | } 126 | 127 | return 0; 128 | } 129 | ////////////////////////////////////////////////////// 130 | ////////////////////////////////////////////////////// 131 | -------------------------------------------------------------------------------- /2-3-7.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L,int x,int y){ 8 | LinkList p=L->next,pre=L,q; 9 | while(p){ 10 | if(p->data<=y && p->data>=x){ 11 | q=p; 12 | p=p->next; 13 | pre->next=p; 14 | free(q); 15 | }else{ 16 | pre=p; 17 | p=p->next; 18 | } 19 | } 20 | } 21 | void fun_start(LinkList &L){ 22 | LinkList s=L->next; 23 | int count=0; 24 | while(s){ 25 | count++; 26 | s=s->next; 27 | } 28 | int x=0,y=0; 29 | cin>>x>>y; 30 | fun(L->next,min(x,y),max(x,y)); 31 | } 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | ////////////////////main 75 | ////////////////////// 76 | //////////////////// 77 | int main(){ 78 | ////////////////////建立链表//////////////////////////////// 79 | LinkList L,s; 80 | int x=0; 81 | L=(LinkList)malloc(sizeof(LNode)); 82 | L->next=NULL; 83 | cin>>x; 84 | while(x!=9999){ 85 | s=(LinkList)malloc(sizeof(LNode)); 86 | s->data=x; 87 | s->next=L->next; 88 | L->next=s; 89 | cin>>x; 90 | } 91 | LinkList tmp,pre,now; 92 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 93 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 94 | //now迭代为tmp 95 | pre=NULL; 96 | now=L->next; 97 | while(now){ 98 | tmp=now->next; 99 | now->next=pre; 100 | pre=now; 101 | now=tmp; 102 | 103 | } 104 | //带头结点 105 | L->next=pre; 106 | fun_start(L); 107 | //打印链表 108 | //不带头结点 109 | s=L->next; 110 | while(s){ 111 | cout<data<<" "; 112 | s=s->next; 113 | } 114 | cout<next; 120 | free(p); 121 | } 122 | 123 | return 0; 124 | } 125 | ////////////////////////////////////////////////////// 126 | ////////////////////////////////////////////////////// 127 | -------------------------------------------------------------------------------- /2-3-8.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | int fun(LinkList &L1,LinkList &L2,int m,int n){ 8 | LinkList p1=L1->next,p2=L2->next,q;//扫描指针 9 | int count=0; 10 | if(m>n){ 11 | for(count=0;countnext; 12 | for(;p1&&p2&&p1!=p2;p1=p1->next,p2=p2->next)count++; 13 | if(p1)return count+1; 14 | return -1; 15 | }else{ 16 | for(count=0;countnext; 17 | for(;p1&&p2&&p1!=p2;p1=p1->next,p2=p2->next)count++; 18 | if(p2)return count+1; 19 | return -1; 20 | } 21 | 22 | } 23 | void fun_start(LinkList &L1,LinkList &L2){ 24 | LinkList tmp; 25 | int m=0,n=0; 26 | for(tmp=L1->next;tmp!=NULL;tmp=tmp->next)m++; 27 | for(tmp=L2->next;tmp!=NULL;tmp=tmp->next)n++; 28 | cout<next; 32 | for(;p->next;p=p->next); 33 | p->next=L3->next; 34 | } 35 | void build_list(LinkList &L){ 36 | LinkList s; 37 | int x=0; 38 | L=(LinkList)malloc(sizeof(LNode)); 39 | L->next=NULL; 40 | cin>>x; 41 | //头插法 懒得改尾插 42 | while(x!=9999){ 43 | s=(LinkList)malloc(sizeof(LNode)); 44 | s->data=x; 45 | s->next=L->next; 46 | L->next=s; 47 | cin>>x; 48 | } 49 | LinkList tmp,pre,now; 50 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 51 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 52 | //now迭代为tmp 53 | pre=NULL; 54 | now=L->next; 55 | while(now){ 56 | tmp=now->next; 57 | now->next=pre; 58 | pre=now; 59 | now=tmp; 60 | 61 | } 62 | //带头结点 63 | L->next=pre; 64 | } 65 | 66 | void print_list(LinkList &L){ 67 | //打印链表 68 | //带头结点 69 | LinkList s=L->next; 70 | while(s){ 71 | cout<data<<" "; 72 | s=s->next; 73 | } 74 | cout<next; 79 | free(p); 80 | } 81 | } 82 | //////////////////////////////////////////////////// 83 | int main(){ 84 | LinkList l1,l2,l3; 85 | build_list(l1); 86 | build_list(l2); 87 | build_list(l3); 88 | merge_list(l1,l3); 89 | merge_list(l2,l3); 90 | fun_start(l1,l2); 91 | print_list(l1); 92 | print_list(l2); 93 | print_list(l3); 94 | return 0; 95 | } 96 | ///////////////////////////////////////////////// 97 | -------------------------------------------------------------------------------- /2-3-9.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L){ 8 | LinkList p=L->next,pre=L,q,premin; 9 | int minx=p->data; 10 | while(L->next){ 11 | pre=L; 12 | p=L->next; 13 | premin=pre; 14 | minx=p->data; 15 | while(p){ 16 | if(p->datadata; 19 | } 20 | pre=p; 21 | p=p->next; 22 | } 23 | q=premin->next; 24 | premin->next=q->next; 25 | cout<next; 32 | fun(L); 33 | } 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | int main(){ 58 | LinkList L,s; 59 | int x=0; 60 | L=(LinkList)malloc(sizeof(LNode)); 61 | L->next=NULL; 62 | cin>>x; 63 | while(x!=9999){ 64 | s=(LinkList)malloc(sizeof(LNode)); 65 | s->data=x; 66 | s->next=L->next; 67 | L->next=s; 68 | cin>>x; 69 | } 70 | LinkList tmp,pre,now; 71 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 72 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 73 | //now迭代为tmp 74 | pre=NULL; 75 | now=L->next; 76 | while(now){ 77 | tmp=now->next; 78 | now->next=pre; 79 | pre=now; 80 | now=tmp; 81 | 82 | } 83 | //带头结点 84 | L->next=pre; 85 | fun_start(L); 86 | //打印链表 87 | //不带头结点 88 | return 0; 89 | } 90 | ////////////////////////////////////////////////////// 91 | ////////////////////////////////////////////////////// 92 | -------------------------------------------------------------------------------- /2-3-Double-List.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* prior; 6 | struct LNode* next; 7 | }LNode, *LinkList; 8 | void fun(LinkList &L,int x){ 9 | LinkList p=L->next,pre=L,q; 10 | while(p){ 11 | if(p->data==x){ 12 | q=p; 13 | p=p->next; 14 | pre->next=p; 15 | free(q); 16 | }else{ 17 | pre=p; 18 | p=p->next; 19 | } 20 | } 21 | } 22 | void fun_start(LinkList &L1,LinkList &rear){ 23 | // fun(L1); 24 | } 25 | //带头结点 26 | void build_list(LinkList &L,LinkList &rear){ 27 | LinkList s; 28 | int x=0; 29 | L=(LinkList)malloc(sizeof(LNode)); 30 | L->next=NULL; 31 | rear=L; 32 | cin>>x; 33 | while(x!=9999){ 34 | s=(LinkList)malloc(sizeof(LNode)); 35 | s->data=x; 36 | rear->next=s; 37 | /////双链表 38 | s->prior=rear; 39 | ///// 40 | rear=rear->next; 41 | cin>>x; 42 | } 43 | //循环双链表 44 | rear->next=L; 45 | L->prior=rear; 46 | } 47 | 48 | void print_list(LinkList &L){ 49 | //打印链表 50 | //带头结点 51 | LinkList s=L->next; 52 | //while(s){ 53 | //双链表 54 | while(s!=L){ 55 | cout<data<<" "; 56 | s=s->next; 57 | } 58 | cout<next; 63 | free(p); 64 | } 65 | } 66 | void test(LinkList L,LinkList rear){ 67 | //测试前后 68 | LinkList p=L->next; 69 | cout<<"test1:front"<data<<" "; 72 | p=p->next; 73 | } 74 | cout<data<<" "; 77 | rear=rear->prior; 78 | } 79 | cout< 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L,int x){ 8 | LinkList p=L->next,pre=L,q; 9 | while(p){ 10 | if(p->data==x){ 11 | q=p; 12 | p=p->next; 13 | pre->next=p; 14 | free(q); 15 | }else{ 16 | pre=p; 17 | p=p->next; 18 | } 19 | } 20 | } 21 | void fun_start(LinkList &L){ 22 | LinkList s=L->next; 23 | //fun(); 24 | } 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | ////////////////////main 68 | ////////////////////// 69 | //////////////////// 70 | int main(){ 71 | ////////////////////建立链表//////////////////////////////// 72 | LinkList L,s; 73 | int x=0; 74 | L=(LinkList)malloc(sizeof(LNode)); 75 | L->next=NULL; 76 | cin>>x; 77 | while(x!=9999){ 78 | s=(LinkList)malloc(sizeof(LNode)); 79 | s->data=x; 80 | s->next=L->next; 81 | L->next=s; 82 | cin>>x; 83 | } 84 | LinkList tmp,pre,now; 85 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 86 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 87 | //now迭代为tmp 88 | pre=NULL; 89 | now=L->next; 90 | while(now){ 91 | tmp=now->next; 92 | now->next=pre; 93 | pre=now; 94 | now=tmp; 95 | 96 | } 97 | //带头结点 98 | L->next=pre; 99 | fun_start(L); 100 | //打印链表 101 | //不带头结点 102 | s=L->next; 103 | while(s){ 104 | cout<data<<" "; 105 | s=s->next; 106 | } 107 | cout<next; 113 | free(p); 114 | } 115 | 116 | return 0; 117 | } 118 | ////////////////////////////////////////////////////// 119 | ////////////////////////////////////////////////////// 120 | -------------------------------------------------------------------------------- /2-3-List.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | 8 | int main(){ 9 | LinkList L,s; 10 | int x=0; 11 | L=(LinkList)malloc(sizeof(LNode)); 12 | L->next=NULL; 13 | scanf("%d",&x); 14 | while(x!=9999){ 15 | s=(LinkList)malloc(sizeof(LNode)); 16 | s->data=x; 17 | s->next=L->next; 18 | L->next=s; 19 | scanf("%d",&x); 20 | } 21 | s=L->next; 22 | while(s){ 23 | printf("%d ",s->data); 24 | s=s->next; 25 | } 26 | free(s); 27 | free(L); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /2-3-TwoLinkList-M.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | typedef struct LNode{ 4 | int data; 5 | struct LNode* next; 6 | }LNode, *LinkList; 7 | void fun(LinkList &L,int x){ 8 | LinkList p=L->next,pre=L,q; 9 | while(p){ 10 | if(p->data==x){ 11 | q=p; 12 | p=p->next; 13 | pre->next=p; 14 | free(q); 15 | }else{ 16 | pre=p; 17 | p=p->next; 18 | } 19 | } 20 | } 21 | void fun_start(LinkList &L1,LinkList &L2){ 22 | //fun(); 23 | } 24 | //带头结点 25 | void build_list(LinkList &L){ 26 | LinkList s; 27 | int x=0; 28 | L=(LinkList)malloc(sizeof(LNode)); 29 | L->next=NULL; 30 | cin>>x; 31 | //头插法 懒得改尾插 32 | while(x!=9999){ 33 | s=(LinkList)malloc(sizeof(LNode)); 34 | s->data=x; 35 | s->next=L->next; 36 | L->next=s; 37 | cin>>x; 38 | } 39 | LinkList tmp,pre,now; 40 | //原地逆转算法：pre置初值NULL，now为当前节点,为头结点下一节点，迭代。 41 | //分析单个节点情况，tmp保存当前节点next，当前now的next指向pre,pre迭代为当前节点now 42 | //now迭代为tmp 43 | pre=NULL; 44 | now=L->next; 45 | while(now){ 46 | tmp=now->next; 47 | now->next=pre; 48 | pre=now; 49 | now=tmp; 50 | 51 | } 52 | //带头结点 53 | L->next=pre; 54 | } 55 | 56 | void print_list(LinkList &L){ 57 | //打印链表 58 | //带头结点 59 | LinkList s=L->next; 60 | while(s){ 61 | cout<data<<" "; 62 | s=s->next; 63 | } 64 | cout<next; 69 | free(p); 70 | } 71 | } 72 | //////////////////////////////////////////////////// 73 | int main(){ 74 | LinkList l1,l2; 75 | build_list(l1); 76 | build_list(l2); 77 | fun_start(l1,l2); 78 | print_list(l1); 79 | print_list(l2); 80 | return 0; 81 | } 82 | ///////////////////////////////////////////////// 83 | -------------------------------------------------------------------------------- /3-1-3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int main(){ 4 | char x; 5 | cin>>x; 6 | int count=0; 7 | while(x!='q'){ 8 | switch(x){ 9 | case 'I': 10 | count++; 11 | break; 12 | case 'O': 13 | count--; 14 | break; 15 | default: 16 | cout<<"error"; 17 | return 1; 18 | } 19 | if(count<0){ 20 | cout<<"false"<>x; 24 | } 25 | if(count){ 26 | cout<<"false"< 2 | #include"3-1-SqStack.cpp" 3 | using namespace std; 4 | typedef struct LNode{ 5 | int data; 6 | struct LNode* next; 7 | }LNode, *LinkList; 8 | //bug 笔记:因为在SqStack31中没有用引用型参数 9 | //导致top没有值，出现莫名其妙的访问错误 10 | //所以，访问错误也可能是由于未赋值的变量引起的 11 | void fun(LinkList L,SqStack &s){ 12 | LinkList p=L->next; 13 | int x=0; 14 | for(;p!=NULL;p=p->next){ 15 | if(push(s,p->data)){ 16 | //bug笔记：由于top无值，报栈满 17 | }else{ 18 | cout<<"error:push"<next;p;p=p->next){ 23 | if(pop(s,x)){ 24 | if(x!=p->data){ 25 | cout<<"false"<next=NULL; 45 | rear=L; 46 | cin>>x; 47 | while(x!=9999){ 48 | s=(LinkList)malloc(sizeof(LNode)); 49 | s->data=x; 50 | rear->next=s; 51 | rear=rear->next; 52 | cin>>x; 53 | } 54 | rear->next=NULL; 55 | } 56 | 57 | void print_list(LinkList &L){ 58 | //打印链表 59 | //带头结点 60 | LinkList s=L->next; 61 | //while(s){ 62 | //双链表 63 | while(s){ 64 | cout<data<<" "; 65 | s=s->next; 66 | } 67 | cout<next; 72 | free(p); 73 | } 74 | } 75 | //////////////////////////////////////////////////// 76 | int main(){ 77 | LinkList l1,l2,rear1,rear2; 78 | SqStack s; 79 | InitStack(s); 80 | build_list(l1,rear1); 81 | // build_list(l2); 82 | fun_start(l1,rear1,s); 83 | print_list(l1); 84 | // print_list(l2); 85 | return 0; 86 | } 87 | ///////////////////////////////////////////////// 88 | -------------------------------------------------------------------------------- /3-1-5.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAXSIZE 10 4 | #define ELEMTYPE int 5 | typedef struct{ 6 | ELEMTYPE data[MAXSIZE]; 7 | int top1; 8 | int top2; 9 | }SharedStack; 10 | bool InitStack(SharedStack &s){ 11 | s.top1=0; 12 | s.top2=MAXSIZE-1; 13 | } 14 | bool push1(SharedStack &s,ELEMTYPE x){ 15 | if(s.top1<=s.top2){ 16 | s.data[s.top1++]=x; 17 | return true; 18 | } 19 | cout<<"error:push1"<=s.top1){ 24 | s.data[s.top2--]=x; 25 | return true; 26 | } 27 | cout<<"error:push2"<>x; 50 | while(x!=9999){ 51 | push1(s,x); 52 | cin>>x; 53 | } 54 | cin>>x; 55 | while(x!=9999){ 56 | push2(s,x); 57 | cin>>x; 58 | } 59 | while(pop1(s,x))cout< 2 | using namespace std; 3 | #define MAXSIZE 10 4 | #define ELEMTYPE int 5 | typedef struct{ 6 | ELEMTYPE data[MAXSIZE]; 7 | int top; //top 指针 8 | }SqStack; 9 | void InitStack(SqStack &stk){ 10 | stk.top=0; 11 | } 12 | bool StackEmpty(SqStack stk){ 13 | if(!stk.top)return true; 14 | return false; 15 | } 16 | //注意：一定要加引用型！ 17 | bool push(SqStack &stk,ELEMTYPE x){ 18 | //MAXIZE 19 | if(stk.top0){ 27 | x=stk.data[--stk.top]; 28 | return true; 29 | } 30 | return false; 31 | } 32 | bool gettop(SqStack stk,ELEMTYPE &x){ 33 | if(stk.top){ 34 | x=stk.data[stk.top-1]; 35 | return true; 36 | } 37 | return false; 38 | } 39 | -------------------------------------------------------------------------------- /3-2-1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAXSIZE 10 3 | using namespace std; 4 | #define ELEMTYPE int 5 | typedef struct{ 6 | ELEMTYPE data[MAXSIZE]; 7 | int front; 8 | int rear; 9 | int tag; 10 | }Queue; 11 | void InitQue(Queue &q){ 12 | q.front=0; 13 | q.rear=0; 14 | q.tag=0; 15 | } 16 | bool EnQueue(Queue &q,ELEMTYPE x){ 17 | if(q.front==q.rear&&q.tag==1){ 18 | cout<<"error:enq"<>x; 45 | while(x!=9999){ 46 | EnQueue(q,x); 47 | cin>>x; 48 | } 49 | while(DeQueue(q,x)){ 50 | cout< 2 | #include"3-1-SqStack.cpp" 3 | #define MAXSIZE 10 4 | //注意MAXSIZE与3-1冲突 5 | using namespace std; 6 | #define ELEMTYPE int 7 | typedef struct{ 8 | ELEMTYPE data[MAXSIZE]; 9 | int front; 10 | int rear; 11 | int tag; 12 | }Queue; 13 | void InitQue(Queue &q){ 14 | q.front=0; 15 | q.rear=0; 16 | q.tag=0; 17 | } 18 | bool EnQueue(Queue &q,ELEMTYPE x){ 19 | if(q.front==q.rear&&q.tag==1){ 20 | cout<<"error:enq"<>x; 58 | while(x!=9999){ 59 | EnQueue(q,x); 60 | cin>>x; 61 | } 62 | fun(q,s); 63 | while(DeQueue(q,x)){ 64 | cout< 2 | using namespace std; 3 | #define MAXSIZE 10 4 | #define ELEMTYPE int 5 | typedef struct{ 6 | ELEMTYPE data[MAXSIZE]; 7 | int top1; 8 | int top2; 9 | }SharedStack; 10 | bool InitStack(SharedStack &s){ 11 | s.top1=0; 12 | s.top2=MAXSIZE-1; 13 | } 14 | bool push1(SharedStack &s,ELEMTYPE x){ 15 | if(s.top1<=s.top2){ 16 | s.data[s.top1++]=x; 17 | return true; 18 | } 19 | cout<<"error:push1"<=s.top1){ 24 | s.data[s.top2--]=x; 25 | return true; 26 | } 27 | cout<<"error:push2"<>x; 72 | while(x!=9999){ 73 | EnQueue(s,x); 74 | cin>>x; 75 | } 76 | while(DeQueue(s,x))cout< 2 | using namespace std; 3 | #define MAXSIZE 10 4 | #define ELEMTYPE char 5 | typedef struct{ 6 | ELEMTYPE data[MAXSIZE]; 7 | int top; //top 指针 8 | }SqStack; 9 | void InitStack(SqStack &stk){ 10 | stk.top=0; 11 | } 12 | bool StackEmpty(SqStack stk){ 13 | if(!stk.top)return true; 14 | return false; 15 | } 16 | //注意：一定要加引用型！ 17 | bool push(SqStack &stk,ELEMTYPE x){ 18 | //MAXIZE 19 | if(stk.top0){ 27 | x=stk.data[--stk.top]; 28 | return true; 29 | } 30 | return false; 31 | } 32 | bool gettop(SqStack stk,ELEMTYPE &x){ 33 | if(stk.top){ 34 | x=stk.data[stk.top-1]; 35 | return true; 36 | } 37 | return false; 38 | } 39 | int main(){ 40 | SqStack s; 41 | InitStack(s); 42 | char x,tmp; 43 | cin>>x; 44 | while(x!='q'){ 45 | switch(x){ 46 | case '{': 47 | push(s,x); 48 | break; 49 | case '}': 50 | if(!pop(s,tmp))return 1; 51 | if(tmp!='{'){ 52 | cout<<"error:}"<>x; 81 | } 82 | if(StackEmpty){ 83 | cout<<"error:last"< 2 | using namespace std; 3 | #define MAXSIZE 10 4 | #define ELEMTYPE char 5 | typedef struct{ 6 | ELEMTYPE data[MAXSIZE]; 7 | int top; //top 指针 8 | }SqStack; 9 | void InitStack(SqStack &stk){ 10 | stk.top=0; 11 | } 12 | bool StackEmpty(SqStack stk){ 13 | if(!stk.top)return true; 14 | return false; 15 | } 16 | //注意：一定要加引用型！ 17 | bool push(SqStack &stk,ELEMTYPE x){ 18 | //MAXIZE 19 | if(stk.top0){ 27 | x=stk.data[--stk.top]; 28 | return true; 29 | } 30 | return false; 31 | } 32 | bool gettop(SqStack stk,ELEMTYPE &x){ 33 | if(stk.top){ 34 | x=stk.data[stk.top-1]; 35 | return true; 36 | } 37 | return false; 38 | } 39 | 40 | int main(){ 41 | SqStack s; 42 | InitStack(s); 43 | char x; 44 | cin>>x; 45 | while(x!='q'){ 46 | switch(x){ 47 | case 'H': 48 | push(s,x); 49 | break; 50 | case 'S': 51 | cout<>x; 54 | } 55 | while(pop(s,x))cout< 2 | using namespace std; 3 | #define MAXSIZE 10 4 | #define ELEMTYPE node 5 | typedef struct{ 6 | int p; 7 | int no; 8 | }node; 9 | typedef struct{ 10 | ELEMTYPE data[MAXSIZE]; 11 | int top; //top 指针 12 | }SqStack; 13 | void InitStack(SqStack &stk){ 14 | stk.top=0; 15 | } 16 | bool StackEmpty(SqStack stk){ 17 | if(!stk.top)return true; 18 | return false; 19 | } 20 | //注意：一定要加引用型！ 21 | bool push(SqStack &stk,ELEMTYPE x){ 22 | //MAXIZE 23 | if(stk.top0){ 31 | x=stk.data[--stk.top]; 32 | return true; 33 | } 34 | return false; 35 | } 36 | bool gettop(SqStack stk,ELEMTYPE &x){ 37 | if(stk.top){ 38 | x=stk.data[stk.top-1]; 39 | return true; 40 | } 41 | return false; 42 | } 43 | 44 | int main(){ 45 | SqStack s; 46 | InitStack(s); 47 | int x,n,p,t; 48 | cout<<"x: "; 49 | cin>>x; 50 | cout<<"n: "; 51 | cin>>n; 52 | t=n; 53 | ELEMTYPE nd,tmp; 54 | for(;n>=2;n--){ 55 | nd.no=n; 56 | push(s,nd); 57 | } 58 | int p0=1,p1=2*x; 59 | while(pop(s,tmp)){ 60 | p=2*x*p1-2*(tmp.no-1)*p0; 61 | // cout<<"p"<1)cout< 2 | #define MAXSIZE 50 3 | using namespace std; 4 | #define ELEMTYPE int 5 | typedef struct{ 6 | ELEMTYPE data[MAXSIZE]; 7 | int front; 8 | int rear; 9 | int tag; 10 | }Queue; 11 | void InitQue(Queue &q){ 12 | q.front=0; 13 | q.rear=0; 14 | q.tag=0; 15 | } 16 | bool EnQueue(Queue &q,ELEMTYPE x){ 17 | if(q.front==q.rear&&q.tag==1){ 18 | cout<<"error:enq"<>x; 52 | while(x!=9999){ 53 | EnQueue(q1,x); 54 | cin>>x; 55 | } 56 | cout<<"货车:"; 57 | cin>>x; 58 | while(x!=9999){ 59 | EnQueue(q2,x); 60 | cin>>x; 61 | } 62 | int n=0,count=0; 63 | while(!QueueEmpty(q1)||!QueueEmpty(q2)){ 64 | n=0; 65 | while(n<10&&(!QueueEmpty(q1)||!QueueEmpty(q2))){ 66 | if(count<4&&!QueueEmpty(q1)){ 67 | DeQueue(q1,x); 68 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | using namespace std; 5 | typedef struct{ 6 | ELEMTYPE treelsit[MAXSIZE]; 7 | int nums; 8 | }BiTree; 9 | int fun(BiTree* T,int i,int j){ 10 | if(inums&&jnums){ 11 | while(i!=j){ 12 | if(itreelsit[i]; 16 | } 17 | cout<<"error"<>x; 24 | T->nums=x; 25 | //顺序存储的二叉树初始化 26 | for(int i=0;inums;i++){ 27 | cin>>x; 28 | T->treelsit[i]=x; 29 | } 30 | int m,n; 31 | cout<<"input i,j:"<>m>>n; 33 | cout<<"result:"<nums;i++){ 35 | cout<treelsit[i]<<" "; 36 | } 37 | free(T); 38 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | int fun(BiTree &T,int &k){ 19 | if(T){ 20 | k--; 21 | if(k==0){ 22 | cout<data<lchild,k); 25 | fun(T->rchild,k); 26 | } 27 | } 28 | return END; 29 | } 30 | 31 | 32 | 33 | 34 | 35 | 36 | //不使用第一项 37 | void InitList(List L[]){ 38 | int x=0,y=0,n=0; 39 | ELEMTYPE d; 40 | L[0]={0,0,0}; 41 | cout<<"input numbers of tree node:"<>n; 43 | for(int i=1;n>x>>y>>d; 45 | L[i].lchild=x; 46 | L[i].rchild=y; 47 | L[i].data=d; 48 | } 49 | } 50 | void InitTreeWithList(BiTree &T,List L[],int index){ 51 | if(index!=NOP){ 52 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 53 | nd->data=L[index].data; 54 | T=nd; 55 | InitTreeWithList(T->lchild,L,L[index].lchild); 56 | InitTreeWithList(T->rchild,L,L[index].rchild); 57 | }else{ 58 | T=NULL; 59 | } 60 | } 61 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 62 | void PrintTree(BiTree T,int x){ 63 | if(T){ 64 | if(x==1){ 65 | cout<data<<" "; 66 | } 67 | PrintTree(T->lchild,x); 68 | if(x==2){ 69 | cout<data<<" "; 70 | } 71 | PrintTree(T->rchild,x); 72 | if(x==3){ 73 | cout<data<<" "; 74 | } 75 | free(T); 76 | } 77 | } 78 | void fun_start(BiTree &T){ 79 | //以下是一个预置的初始化数组 80 | //不使用第一项 81 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 82 | List L[MAXSIZE]; 83 | //InitList(L); 84 | InitTreeWithList(T,L0,1); 85 | int k=0; 86 | cin>>k; 87 | fun(T,k); 88 | PrintTree(T,1); 89 | } 90 | 91 | 92 | 93 | int main(){ 94 | BiTree T; 95 | fun_start(T); 96 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | void FreeTree(BiTree &T){ 17 | if(T){ 18 | FreeTree(T->lchild); 19 | FreeTree(T->rchild); 20 | free(T); 21 | } 22 | } 23 | void fun_start(BiTree &T); 24 | void fun(BiTree &T,int k){ 25 | if(T){ 26 | if(T->data==k){ 27 | FreeTree(T); 28 | T=NULL; 29 | } 30 | else{ 31 | fun(T->lchild,k); 32 | fun(T->rchild,k); 33 | } 34 | } 35 | } 36 | 37 | 38 | 39 | 40 | 41 | 42 | //不使用第一项 43 | void InitList(List L[]){ 44 | int x=0,y=0,n=0; 45 | ELEMTYPE d; 46 | L[0]={0,0,0}; 47 | cout<<"input numbers of tree node:"<>n; 49 | for(int i=1;n>x>>y>>d; 51 | L[i].lchild=x; 52 | L[i].rchild=y; 53 | L[i].data=d; 54 | } 55 | } 56 | void InitTreeWithList(BiTree &T,List L[],int index){ 57 | if(index!=NOP){ 58 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 59 | nd->data=L[index].data; 60 | T=nd; 61 | InitTreeWithList(T->lchild,L,L[index].lchild); 62 | InitTreeWithList(T->rchild,L,L[index].rchild); 63 | }else{ 64 | T=NULL; 65 | } 66 | } 67 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 68 | void PrintTree(BiTree T,int x,int tag){ 69 | if(T){ 70 | if(x==1){ 71 | cout<data<<" "; 72 | } 73 | PrintTree(T->lchild,x,tag); 74 | if(x==2){ 75 | cout<data<<" "; 76 | } 77 | PrintTree(T->rchild,x,tag); 78 | if(x==3){ 79 | cout<data<<" "; 80 | } 81 | if(tag)free(T); 82 | } 83 | } 84 | void fun_start(BiTree &T){ 85 | //以下是一个预置的初始化数组 86 | //不使用第一项 87 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 88 | List L[MAXSIZE]; 89 | //InitList(L); 90 | InitTreeWithList(T,L0,1); 91 | PrintTree(T,1,0); 92 | int k=0; 93 | cin>>k; 94 | fun(T,k); 95 | PrintTree(T,1,1); 96 | } 97 | 98 | 99 | 100 | int main(){ 101 | BiTree T; 102 | fun_start(T); 103 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | void fun(BiTree &T,BiTree (&stk)[MAXSIZE],int &top,int k){ 19 | BiTree p,last=NULL,sn; 20 | for(p=T;p;p=p->lchild){ 21 | stk[top++]=p; 22 | } 23 | while(top){ 24 | sn=stk[top-1]; 25 | if(!sn->rchild||sn->rchild==last){ 26 | p=stk[--top]; 27 | if(p->data==k)break; 28 | last=p; 29 | }else{ 30 | p=sn->rchild; 31 | for(;p;p=p->lchild){ 32 | stk[top++]=p; 33 | } 34 | } 35 | } 36 | } 37 | 38 | 39 | 40 | 41 | 42 | 43 | //不使用第一项 44 | void InitList(List L[]){ 45 | int x=0,y=0,n=0; 46 | ELEMTYPE d; 47 | L[0]={0,0,0}; 48 | cout<<"input numbers of tree node:"<>n; 50 | for(int i=1;n>x>>y>>d; 52 | L[i].lchild=x; 53 | L[i].rchild=y; 54 | L[i].data=d; 55 | } 56 | } 57 | void InitTreeWithList(BiTree &T,List L[],int index){ 58 | if(index!=NOP){ 59 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 60 | nd->data=L[index].data; 61 | T=nd; 62 | InitTreeWithList(T->lchild,L,L[index].lchild); 63 | InitTreeWithList(T->rchild,L,L[index].rchild); 64 | }else{ 65 | T=NULL; 66 | } 67 | } 68 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 69 | void PrintTree(BiTree T,int x){ 70 | if(T){ 71 | if(x==1){ 72 | cout<data<<" "; 73 | } 74 | PrintTree(T->lchild,x); 75 | if(x==2){ 76 | cout<data<<" "; 77 | } 78 | PrintTree(T->rchild,x); 79 | if(x==3){ 80 | cout<data<<" "; 81 | } 82 | free(T); 83 | } 84 | } 85 | void fun_start(BiTree &T){ 86 | //以下是一个预置的初始化数组 87 | //不使用第一项 88 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 89 | // List L[MAXSIZE]; 90 | // InitList(L); 91 | InitTreeWithList(T,L0,1); 92 | cout<<"fun:"<>k; 95 | BiTree stk[MAXSIZE]; 96 | int top=0; 97 | fun(T,stk,top,k); 98 | while(--top>=0)cout<data<<" "; 99 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | void fun_start(BiTree &T); 17 | void fun(BiTree &T,BiTree (&stk)[MAXSIZE],int &top,BiTree q){ 18 | BiTree p,last=NULL,sn; 19 | for(p=T;p;p=p->lchild){ 20 | stk[top++]=p; 21 | } 22 | while(top){ 23 | sn=stk[top-1]; 24 | if(!sn->rchild||sn->rchild==last){ 25 | p=stk[--top]; 26 | if(p==q)break; 27 | last=p; 28 | }else{ 29 | p=sn->rchild; 30 | for(;p;p=p->lchild){ 31 | stk[top++]=p; 32 | } 33 | } 34 | } 35 | } 36 | //不使用第一项 37 | void InitList(List L[]){ 38 | int x=0,y=0,n=0; 39 | ELEMTYPE d; 40 | L[0]={0,0,0}; 41 | cout<<"input numbers of tree node:"<>n; 43 | for(int i=1;n>x>>y>>d; 45 | L[i].lchild=x; 46 | L[i].rchild=y; 47 | L[i].data=d; 48 | } 49 | } 50 | void InitTreeWithList(BiTree &T,List L[],int index){ 51 | if(index!=NOP){ 52 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 53 | nd->data=L[index].data; 54 | T=nd; 55 | InitTreeWithList(T->lchild,L,L[index].lchild); 56 | InitTreeWithList(T->rchild,L,L[index].rchild); 57 | }else{ 58 | T=NULL; 59 | } 60 | } 61 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 62 | void PrintTree(BiTree T,int x){ 63 | if(T){ 64 | if(x==1){ 65 | cout<data<<" "; 66 | } 67 | PrintTree(T->lchild,x); 68 | if(x==2){ 69 | cout<data<<" "; 70 | } 71 | PrintTree(T->rchild,x); 72 | if(x==3){ 73 | cout<data<<" "; 74 | } 75 | free(T); 76 | } 77 | } 78 | BiTree FindPointer(BiTree T,ELEMTYPE x){ 79 | if(T){ 80 | if(T->data==x)return T; 81 | BiTree p1,p2; 82 | p1=FindPointer(T->lchild,x); 83 | if(p1)return p1; 84 | p2=FindPointer(T->rchild,x); 85 | if(p2)return p2; 86 | } 87 | return NULL; 88 | } 89 | void fun_start(BiTree &T){ 90 | //以下是一个预置的初始化数组 91 | //不使用第一项 92 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 93 | // List L[MAXSIZE]; 94 | // InitList(L); 95 | InitTreeWithList(T,L0,1); 96 | cout<<"fun:input p,q:"<>p>>q; 99 | BiTree p1,p2; 100 | p1=FindPointer(T,p); 101 | p2=FindPointer(T,q); 102 | BiTree stk1[MAXSIZE]; 103 | BiTree stk2[MAXSIZE]; 104 | int top1=0,top2=0; 105 | fun(T,stk1,top1,p1); 106 | fun(T,stk2,top2,p2); 107 | for(int i=0;idata<<" "; 108 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | BiTree q[MAXSIZE]; 17 | int front=0,rear=0; 18 | bool EnQueue(BiTree p){ 19 | if((rear+1)%MAXSIZE!=front){ 20 | q[rear]=p; 21 | rear=(rear+1)%MAXSIZE; 22 | return true; 23 | }else return false; 24 | } 25 | bool DeQueue(BiTree &p){ 26 | if(front!=rear){ 27 | p=q[front]; 28 | front=(front+1)%MAXSIZE; 29 | return true; 30 | }else return false; 31 | } 32 | bool IsQueueEmpty(){ 33 | if(front==rear)return true; 34 | return false; 35 | } 36 | void fun_start(BiTree &T); 37 | int fun(BiTree &T){ 38 | BiTree p; 39 | int prewidth=0,nextwidth=0,maxwidth=0; 40 | if(T){ 41 | EnQueue(T); 42 | int i=0; 43 | prewidth=1; 44 | while(!IsQueueEmpty()){ 45 | DeQueue(p); 46 | i++; 47 | if(p->lchild){ 48 | EnQueue(p->lchild); 49 | nextwidth++; 50 | } 51 | if(p->rchild){ 52 | EnQueue(p->rchild); 53 | nextwidth++; 54 | } 55 | if(i==prewidth){ 56 | prewidth=nextwidth; 57 | maxwidth=max(maxwidth,prewidth); 58 | nextwidth=0; 59 | i=0; 60 | } 61 | } 62 | } 63 | return maxwidth; 64 | } 65 | //不使用第一项 66 | void InitList(List L[]){ 67 | int x=0,y=0,n=0; 68 | ELEMTYPE d; 69 | L[0]={0,0,0}; 70 | cout<<"input numbers of tree node:"<>n; 72 | for(int i=1;n>x>>y>>d; 74 | L[i].lchild=x; 75 | L[i].rchild=y; 76 | L[i].data=d; 77 | } 78 | } 79 | void InitTreeWithList(BiTree &T,List L[],int index){ 80 | if(index!=NOP){ 81 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 82 | nd->data=L[index].data; 83 | T=nd; 84 | InitTreeWithList(T->lchild,L,L[index].lchild); 85 | InitTreeWithList(T->rchild,L,L[index].rchild); 86 | }else{ 87 | T=NULL; 88 | } 89 | } 90 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 91 | void PrintTree(BiTree T,int x){ 92 | if(T){ 93 | if(x==1){ 94 | cout<data<<" "; 95 | } 96 | PrintTree(T->lchild,x); 97 | if(x==2){ 98 | cout<data<<" "; 99 | } 100 | PrintTree(T->rchild,x); 101 | if(x==3){ 102 | cout<data<<" "; 103 | } 104 | free(T); 105 | } 106 | } 107 | void fun_start(BiTree &T){ 108 | //以下是一个预置的初始化数组 109 | //不使用第一项 110 | List L0[11]={{0,0,0},{2,3,11},{4,5,12},{6,10,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19},{NOP,NOP,20}}; 111 | // List L[MAXSIZE]; 112 | // InitList(L); 113 | InitTreeWithList(T,L0,1); 114 | cout<<"fun:width:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | void fun_start(BiTree &T); 17 | void fun(ELEMTYPE A[],ELEMTYPE B[],int astart,int bstart,int n){ 18 | if(n>0){ 19 | int rt=(n-1)/2; 20 | fun(A,B,astart+1,bstart,rt); 21 | fun(A,B,astart+rt+1,bstart+rt,rt); 22 | B[bstart+n-1]=A[astart]; 23 | } 24 | } 25 | //不使用第一项 26 | void InitList(List L[]){ 27 | int x=0,y=0,n=0; 28 | ELEMTYPE d; 29 | L[0]={0,0,0}; 30 | cout<<"input numbers of tree node:"<>n; 32 | for(int i=1;n>x>>y>>d; 34 | L[i].lchild=x; 35 | L[i].rchild=y; 36 | L[i].data=d; 37 | } 38 | } 39 | void InitTreeWithList(BiTree &T,List L[],int index){ 40 | if(index!=NOP){ 41 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 42 | nd->data=L[index].data; 43 | T=nd; 44 | InitTreeWithList(T->lchild,L,L[index].lchild); 45 | InitTreeWithList(T->rchild,L,L[index].rchild); 46 | }else{ 47 | T=NULL; 48 | } 49 | } 50 | ELEMTYPE A[MAXSIZE]; 51 | int ai=0; 52 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 53 | void PrintTree(BiTree T,int x){ 54 | if(T){ 55 | if(x==1){ 56 | cout<data<<" "; 57 | A[ai++]=T->data; 58 | } 59 | PrintTree(T->lchild,x); 60 | if(x==2){ 61 | cout<data<<" "; 62 | } 63 | PrintTree(T->rchild,x); 64 | if(x==3){ 65 | cout<data<<" "; 66 | } 67 | if(x==3)free(T); 68 | } 69 | } 70 | void fun_start(BiTree &T){ 71 | //以下是一个预置的初始化数组 72 | //不使用第一项 73 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,7,13},{NOP,NOP,14},{NOP,NOP,15},{NOP,NOP,16},{NOP,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 74 | //List L[MAXSIZE]; 75 | //InitList(L); 76 | InitTreeWithList(T,L0,1); 77 | cout<<"tree:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | //可以直接用全局变量指针，没必要用队列 18 | BiTree Queue[MAXSIZE]; 19 | int index=0; 20 | void fun_start(BiTree &T); 21 | void fun(BiTree &T){ 22 | if(T){ 23 | if(!T->lchild&&!T->rchild){ 24 | Queue[index++]=T; 25 | } 26 | if(T->lchild)fun(T->lchild); 27 | if(T->rchild)fun(T->rchild); 28 | } 29 | } 30 | 31 | 32 | 33 | 34 | 35 | 36 | //不使用第一项 37 | void InitList(List L[]){ 38 | int x=0,y=0,n=0; 39 | ELEMTYPE d; 40 | L[0]={0,0,0}; 41 | cout<<"input numbers of tree node:"<>n; 43 | for(int i=1;n>x>>y>>d; 45 | L[i].lchild=x; 46 | L[i].rchild=y; 47 | L[i].data=d; 48 | } 49 | } 50 | void InitTreeWithList(BiTree &T,List L[],int index){ 51 | if(index!=NOP){ 52 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 53 | nd->data=L[index].data; 54 | T=nd; 55 | InitTreeWithList(T->lchild,L,L[index].lchild); 56 | InitTreeWithList(T->rchild,L,L[index].rchild); 57 | }else{ 58 | T=NULL; 59 | } 60 | } 61 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 62 | void PrintTree(BiTree T,int x){ 63 | if(T){ 64 | if(x==1){ 65 | cout<data<<" "; 66 | } 67 | PrintTree(T->lchild,x); 68 | if(x==2){ 69 | cout<data<<" "; 70 | } 71 | PrintTree(T->rchild,x); 72 | if(x==3){ 73 | cout<data<<" "; 74 | } 75 | free(T); 76 | } 77 | } 78 | void fun_start(BiTree &T){ 79 | //以下是一个预置的初始化数组 80 | //不使用第一项 81 | List L0[11]={{0,0,0},{2,3,11},{4,5,12},{6,10,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19},{NOP,NOP,20}}; 82 | List L[MAXSIZE]; 83 | //InitList(L); 84 | BiTree head,rear; 85 | InitTreeWithList(T,L0,1); 86 | cout<<"fun:"<rchild=Queue[index]; 93 | rear=rear->rchild; 94 | } 95 | for(rear=head;rear;rear=rear->rchild)cout<data<<" "; 96 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | bool fun(BiTree &T1,BiTree &T2){ 19 | if(!T1&&!T2){ 20 | return true; 21 | }else if((!T1&&T2)||(T1&&!T2))return false; 22 | else{ 23 | return fun(T1->lchild,T2->lchild)&&fun(T1->rchild,T2->rchild); 24 | } 25 | } 26 | 27 | 28 | 29 | 30 | 31 | 32 | //不使用第一项 33 | void InitList(List L[]){ 34 | int x=0,y=0,n=0; 35 | ELEMTYPE d; 36 | L[0]={0,0,0}; 37 | cout<<"input numbers of tree node:"<>n; 39 | for(int i=1;n>x>>y>>d; 41 | L[i].lchild=x; 42 | L[i].rchild=y; 43 | L[i].data=d; 44 | } 45 | } 46 | void InitTreeWithList(BiTree &T,List L[],int index){ 47 | if(index!=NOP){ 48 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 49 | nd->data=L[index].data; 50 | T=nd; 51 | InitTreeWithList(T->lchild,L,L[index].lchild); 52 | InitTreeWithList(T->rchild,L,L[index].rchild); 53 | }else{ 54 | T=NULL; 55 | } 56 | } 57 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 58 | void PrintTree(BiTree T,int x){ 59 | if(T){ 60 | if(x==1){ 61 | cout<data<<" "; 62 | } 63 | PrintTree(T->lchild,x); 64 | if(x==2){ 65 | cout<data<<" "; 66 | } 67 | PrintTree(T->rchild,x); 68 | if(x==3){ 69 | cout<data<<" "; 70 | } 71 | free(T); 72 | } 73 | } 74 | void fun_start(BiTree &T1){ 75 | //以下是一个预置的初始化数组 76 | //不使用第一项 77 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 78 | List L1[MAXSIZE],L2[MAXSIZE]; 79 | InitList(L1); 80 | InitList(L2); 81 | BiTree T2; 82 | InitTreeWithList(T1,L1,1); 83 | InitTreeWithList(T2,L2,1); 84 | cout<<(fun(T1,T2)?"true":"false")< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | int ltag,rtag; 11 | }BiNode,*BiTree; 12 | typedef struct ListNode{ 13 | int lchild; 14 | int rchild; 15 | ELEMTYPE data; 16 | }List; 17 | //中序线索化 18 | void InThread(BiTree &p,BiTree &pre){ 19 | if(p){ 20 | if(p->lchild)InThread(p->lchild,pre); 21 | else{ 22 | p->lchild=pre; 23 | p->ltag=1; 24 | } 25 | if(pre&&!pre->rchild){ 26 | pre->rtag=1; 27 | pre->rchild=p; 28 | } 29 | pre=p; 30 | if(p->rchild)InThread(p->rchild,pre); 31 | } 32 | } 33 | BiTree FirstNode(BiTree T){ 34 | if(T){ 35 | while(!T->ltag)T=T->lchild; 36 | } 37 | return T; 38 | } 39 | BiTree NextNode(BiTree T){ 40 | if(T){ 41 | if(!T->rtag)return FirstNode(T->rchild); 42 | else return T->rchild; 43 | } 44 | return NULL; 45 | } 46 | void InOrder(BiTree T){ 47 | BiTree p; 48 | for(p=FirstNode(T);p;p=NextNode(p)){ 49 | cout<data<<" "; 50 | } 51 | cout<>n; 60 | for(int i=1;n>x>>y>>d; 62 | L[i].lchild=x; 63 | L[i].rchild=y; 64 | L[i].data=d; 65 | } 66 | } 67 | void InitTreeWithList(BiTree &T,List L[],int index){ 68 | if(index!=NOP){ 69 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 70 | nd->data=L[index].data; 71 | nd->ltag=0; 72 | nd->rtag=0; 73 | T=nd; 74 | InitTreeWithList(T->lchild,L,L[index].lchild); 75 | InitTreeWithList(T->rchild,L,L[index].rchild); 76 | }else{ 77 | T=NULL; 78 | } 79 | } 80 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 81 | void PrintTree(BiTree T,int x){ 82 | if(T){ 83 | if(x==1){ 84 | cout<data<<" "; 85 | } 86 | if(!T->ltag)PrintTree(T->lchild,x); 87 | if(x==2){ 88 | cout<data<<" "; 89 | } 90 | if(!T->rtag)PrintTree(T->rchild,x); 91 | if(x==3){ 92 | cout<data<<" "; 93 | } 94 | free(T); 95 | } 96 | } 97 | BiTree FindPointer(BiTree T,ELEMTYPE x){ 98 | if(T){ 99 | if(T->data==x)return T; 100 | BiTree p1=NULL,p2=NULL; 101 | if(!T->ltag)p1=FindPointer(T->lchild,x); 102 | if(p1)return p1; 103 | if(!T->rtag)p2=FindPointer(T->rchild,x); 104 | if(p2)return p2; 105 | } 106 | return NULL; 107 | } 108 | BiTree fun(BiTree &T,BiTree p){ 109 | if(p){ 110 | if(!p->rtag)return p->rchild; 111 | else if(!p->ltag){ 112 | p=p->lchild; 113 | }else{ 114 | while(p&&p->ltag){ 115 | p=p->lchild; 116 | } 117 | if(p)return p->lchild; 118 | } 119 | } 120 | return p; 121 | } 122 | void fun_start(BiTree &T){ 123 | //以下是一个预置的初始化数组 124 | //不使用第一项 125 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 126 | //List L[MAXSIZE]; 127 | //InitList(L); 128 | InitTreeWithList(T,L0,1); 129 | cout<<"InOrder:"<rtag=1; 134 | p->rchild=NULL; 135 | } 136 | InOrder(T); 137 | int x; 138 | cout<<"fun:input x"<>x; 140 | p=FindPointer(T,x); 141 | q=fun(T,p); 142 | if(p&&q)cout<<"previous,present:"<data<<" "<data< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | int WPL=0; 18 | void fun_start(BiTree &T); 19 | void fun(BiTree &T,int depth){ 20 | if(T){ 21 | WPL+=(T->data)*depth; 22 | if(T->lchild)fun(T->lchild,depth+1); 23 | if(T->rchild)fun(T->rchild,depth+1); 24 | } 25 | } 26 | 27 | 28 | 29 | 30 | 31 | 32 | //不使用第一项 33 | void InitList(List L[]){ 34 | int x=0,y=0,n=0; 35 | ELEMTYPE d; 36 | L[0]={0,0,0}; 37 | cout<<"input numbers of tree node:"<>n; 39 | for(int i=1;n>x>>y>>d; 41 | L[i].lchild=x; 42 | L[i].rchild=y; 43 | L[i].data=d; 44 | } 45 | } 46 | void InitTreeWithList(BiTree &T,List L[],int index){ 47 | if(index!=NOP){ 48 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 49 | nd->data=L[index].data; 50 | T=nd; 51 | InitTreeWithList(T->lchild,L,L[index].lchild); 52 | InitTreeWithList(T->rchild,L,L[index].rchild); 53 | }else{ 54 | T=NULL; 55 | } 56 | } 57 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 58 | void PrintTree(BiTree T,int x){ 59 | if(T){ 60 | if(x==1){ 61 | cout<data<<" "; 62 | } 63 | PrintTree(T->lchild,x); 64 | if(x==2){ 65 | cout<data<<" "; 66 | } 67 | PrintTree(T->rchild,x); 68 | if(x==3){ 69 | cout<data<<" "; 70 | } 71 | free(T); 72 | } 73 | } 74 | void fun_start(BiTree &T){ 75 | //以下是一个预置的初始化数组 76 | //不使用第一项 77 | List L0[10]={{0,0,0},{2,3,2},{4,5,1},{6,NOP,3},{NOP,7,1},{NOP,8,1},{NOP,NOP,2},{9,NOP,6},{NOP,NOP,2},{NOP,NOP,1}}; 78 | List L[MAXSIZE]; 79 | //InitList(L); 80 | InitTreeWithList(T,L0,1); 81 | fun(T,1); 82 | cout< 2 | #define ELEMTYPE char 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | string fun(BiTree &T){ 19 | if(!T->lchild&&!T->rchild){ 20 | if(T)return string(1,T->data); 21 | }else{ 22 | if(T){ 23 | string str="",tmp=""; 24 | if(T->lchild)tmp=fun(T->lchild); 25 | str+="("+tmp+string(1,T->data); 26 | if(T->rchild)tmp=fun(T->rchild); 27 | str+=tmp+")"; 28 | return str; 29 | } 30 | } 31 | return ""; 32 | } 33 | 34 | 35 | 36 | 37 | 38 | //不使用第一项 39 | void InitList(List L[]){ 40 | int x=0,y=0,n=0; 41 | ELEMTYPE d; 42 | L[0]={0,0,0}; 43 | cout<<"input numbers of tree node:"<>n; 45 | for(int i=1;n>x>>y>>d; 47 | L[i].lchild=x; 48 | L[i].rchild=y; 49 | L[i].data=d; 50 | } 51 | } 52 | void InitTreeWithList(BiTree &T,List L[],int index){ 53 | if(index!=NOP){ 54 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 55 | nd->data=L[index].data; 56 | T=nd; 57 | InitTreeWithList(T->lchild,L,L[index].lchild); 58 | InitTreeWithList(T->rchild,L,L[index].rchild); 59 | }else{ 60 | T=NULL; 61 | } 62 | } 63 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 64 | void PrintTree(BiTree T,int x){ 65 | if(T){ 66 | if(x==1){ 67 | cout<data<<" "; 68 | } 69 | PrintTree(T->lchild,x); 70 | if(x==2){ 71 | cout<data<<" "; 72 | } 73 | PrintTree(T->rchild,x); 74 | if(x==3){ 75 | cout<data<<" "; 76 | } 77 | free(T); 78 | } 79 | } 80 | void fun_start(BiTree &T){ 81 | //以下是一个预置的初始化数组 82 | //不使用第一项 83 | List L0[10]={{0,0,0},{2,3,'+'},{4,5,'*'},{NOP,6,'-'},{NOP,NOP,'a'},{NOP,NOP,'b'},{7,8,'-'},{NOP,NOP,'c'},{NOP,NOP,'d'},{NOP,NOP,19}}; 84 | List L[MAXSIZE]; 85 | //InitList(L); 86 | InitTreeWithList(T,L0,1); 87 | string str=fun(T); 88 | for(int i=1;i<(str.size()-1);i++){ 89 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | void fun(BiTree &T){ 19 | struct SNode{BiTree node;bool rvisited;}stk[MAXSIZE]; 20 | int top=0; 21 | BiTree p; 22 | struct SNode sn; 23 | for(p=T;p;p=p->lchild){ 24 | stk[top].node=p; 25 | stk[top].rvisited=false; 26 | top++; 27 | } 28 | // int count=0; 29 | while(top){ 30 | sn=stk[top-1]; 31 | // count++; 32 | // if(count==8)break; 33 | // cout<data<<"|"<<(sn.rvisited?"true":"false")<<" "<rchild==NULL)||sn.rvisited){ //注意右子树为空 35 | p=stk[--top].node; 36 | cout<data<<" "; 37 | }else{ 38 | //bug笔记：stk[top-1]不能写成sn，因为这是sn是表示结构的变量，不是指针 39 | stk[top-1].rvisited=true; 40 | for(p=sn.node->rchild;p;p=p->lchild){ 41 | stk[top].node=p; 42 | stk[top].rvisited=false; 43 | // cout<data<<":"<>n; 62 | for(int i=1;n>x>>y>>d; 64 | L[i].lchild=x; 65 | L[i].rchild=y; 66 | L[i].data=d; 67 | } 68 | } 69 | void InitTreeWithList(BiTree &T,List L[],int index){ 70 | if(index!=NOP){ 71 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 72 | nd->data=L[index].data; 73 | T=nd; 74 | InitTreeWithList(T->lchild,L,L[index].lchild); 75 | InitTreeWithList(T->rchild,L,L[index].rchild); 76 | }else{ 77 | T=NULL; 78 | } 79 | } 80 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 81 | void PrintTree(BiTree T,int x){ 82 | if(T){ 83 | if(x==1){ 84 | cout<data<<" "; 85 | } 86 | PrintTree(T->lchild,x); 87 | if(x==2){ 88 | cout<data<<" "; 89 | } 90 | PrintTree(T->rchild,x); 91 | if(x==3){ 92 | cout<data<<" "; 93 | } 94 | free(T); 95 | } 96 | } 97 | void fun_start(BiTree &T){ 98 | //以下是一个预置的初始化数组 99 | //不使用第一项 100 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 101 | // List L[MAXSIZE]; 102 | // InitList(L); 103 | InitTreeWithList(T,L0,1); 104 | cout<<"fun:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | BiTree q[MAXSIZE]; 18 | int front=0,rear=0; 19 | bool EnQueue(BiTree p){ 20 | if((rear+1)%MAXSIZE!=front){ 21 | q[rear]=p; 22 | rear=(rear+1)%MAXSIZE; 23 | return true; 24 | }else return false; 25 | } 26 | bool DeQueue(BiTree &p){ 27 | if(front!=rear){ 28 | p=q[front]; 29 | front=(front+1)%MAXSIZE; 30 | return true; 31 | }else return false; 32 | } 33 | bool IsQueueEmpty(){ 34 | if(front==rear)return true; 35 | return false; 36 | } 37 | void fun_start(BiTree &T); 38 | void fun(BiTree &T){ 39 | BiTree stk[MAXSIZE]; 40 | BiTree p; 41 | int top=0; 42 | if(T){ 43 | EnQueue(T); 44 | while(!IsQueueEmpty()){ 45 | DeQueue(p); 46 | stk[top++]=p; 47 | if(p->lchild)EnQueue(p->lchild); 48 | if(p->rchild)EnQueue(p->rchild); 49 | } 50 | while(--top>=0)cout<data<<" "; 51 | } 52 | } 53 | 54 | 55 | 56 | 57 | 58 | 59 | //不使用第一项 60 | void InitList(List L[]){ 61 | int x=0,y=0,n=0; 62 | ELEMTYPE d; 63 | L[0]={0,0,0}; 64 | cout<<"input numbers of tree node:"<>n; 66 | for(int i=1;n>x>>y>>d; 68 | L[i].lchild=x; 69 | L[i].rchild=y; 70 | L[i].data=d; 71 | } 72 | } 73 | void InitTreeWithList(BiTree &T,List L[],int index){ 74 | if(index!=NOP){ 75 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 76 | nd->data=L[index].data; 77 | T=nd; 78 | InitTreeWithList(T->lchild,L,L[index].lchild); 79 | InitTreeWithList(T->rchild,L,L[index].rchild); 80 | }else{ 81 | T=NULL; 82 | } 83 | } 84 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 85 | void PrintTree(BiTree T,int x){ 86 | if(T){ 87 | if(x==1){ 88 | cout<data<<" "; 89 | } 90 | PrintTree(T->lchild,x); 91 | if(x==2){ 92 | cout<data<<" "; 93 | } 94 | PrintTree(T->rchild,x); 95 | if(x==3){ 96 | cout<data<<" "; 97 | } 98 | free(T); 99 | } 100 | } 101 | void fun_start(BiTree &T){ 102 | //以下是一个预置的初始化数组 103 | //不使用第一项 104 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 105 | List L[MAXSIZE]; 106 | //InitList(L); 107 | InitTreeWithList(T,L0,1); 108 | cout<<"fun:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | BiTree q[MAXSIZE]; 18 | int front=0,rear=0; 19 | bool EnQueue(BiTree p){ 20 | if((rear+1)%MAXSIZE!=front){ 21 | q[rear]=p; 22 | rear=(rear+1)%MAXSIZE; 23 | return true; 24 | }else return false; 25 | } 26 | bool DeQueue(BiTree &p){ 27 | if(front!=rear){ 28 | p=q[front]; 29 | front=(front+1)%MAXSIZE; 30 | return true; 31 | }else return false; 32 | } 33 | bool IsQueueEmpty(){ 34 | if(front==rear)return true; 35 | return false; 36 | } 37 | void fun_start(BiTree &T); 38 | int fun(BiTree &T){ 39 | BiTree p; 40 | int height=0,prewidth=0,nextwidth=0; 41 | if(T){ 42 | EnQueue(T); 43 | int i=0; 44 | prewidth=1; 45 | while(!IsQueueEmpty()){ 46 | DeQueue(p); 47 | i++; 48 | if(p->lchild){ 49 | EnQueue(p->lchild); 50 | nextwidth++; 51 | } 52 | if(p->rchild){ 53 | EnQueue(p->rchild); 54 | nextwidth++; 55 | } 56 | if(i==prewidth){ 57 | i=0; 58 | prewidth=nextwidth; 59 | nextwidth=0; 60 | height++; 61 | } 62 | } 63 | } 64 | return height; 65 | } 66 | 67 | 68 | 69 | 70 | 71 | 72 | //不使用第一项 73 | void InitList(List L[]){ 74 | int x=0,y=0,n=0; 75 | ELEMTYPE d; 76 | L[0]={0,0,0}; 77 | cout<<"input numbers of tree node:"<>n; 79 | for(int i=1;n>x>>y>>d; 81 | L[i].lchild=x; 82 | L[i].rchild=y; 83 | L[i].data=d; 84 | } 85 | } 86 | void InitTreeWithList(BiTree &T,List L[],int index){ 87 | if(index!=NOP){ 88 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 89 | nd->data=L[index].data; 90 | T=nd; 91 | InitTreeWithList(T->lchild,L,L[index].lchild); 92 | InitTreeWithList(T->rchild,L,L[index].rchild); 93 | }else{ 94 | T=NULL; 95 | } 96 | } 97 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 98 | void PrintTree(BiTree T,int x){ 99 | if(T){ 100 | if(x==1){ 101 | cout<data<<" "; 102 | } 103 | PrintTree(T->lchild,x); 104 | if(x==2){ 105 | cout<data<<" "; 106 | } 107 | PrintTree(T->rchild,x); 108 | if(x==3){ 109 | cout<data<<" "; 110 | } 111 | free(T); 112 | } 113 | } 114 | void fun_start(BiTree &T){ 115 | //以下是一个预置的初始化数组 116 | //不使用第一项 117 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 118 | List L[MAXSIZE]; 119 | InitList(L); 120 | InitTreeWithList(T,L,1); 121 | cout<<"fun:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | void fun(BiTree &T,ELEMTYPE A[],ELEMTYPE B[],int astart,int bstart,int n){ 19 | if(n==0){ 20 | T=NULL; 21 | }else{ 22 | T=(BiTree)malloc(sizeof(BiNode)); 23 | int i=0; 24 | for(i=0;A[astart]!=B[bstart+i];i++); 25 | if(i>n){ 26 | cout<<"error:A!=B"<data=A[astart]; 29 | fun(T->lchild,A,B,astart+1,bstart,i); //建立左子树 从astart+1和bstart开始的i项 30 | fun(T->rchild,A,B,astart+i+1,bstart+i+1,n-1-i); //建立右子树 从astart+i+1和bstart+i+1开始的n-1-i项 31 | } 32 | } 33 | 34 | 35 | 36 | 37 | 38 | 39 | //不使用第一项 40 | void InitList(List L[]){ 41 | int x=0,y=0,n=0; 42 | ELEMTYPE d; 43 | L[0]={0,0,0}; 44 | cout<<"input numbers of tree node:"<>n; 46 | for(int i=1;n>x>>y>>d; 48 | L[i].lchild=x; 49 | L[i].rchild=y; 50 | L[i].data=d; 51 | } 52 | } 53 | void InitTreeWithList(BiTree &T,List L[],int index){ 54 | if(index!=NOP){ 55 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 56 | nd->data=L[index].data; 57 | T=nd; 58 | InitTreeWithList(T->lchild,L,L[index].lchild); 59 | InitTreeWithList(T->rchild,L,L[index].rchild); 60 | }else{ 61 | T=NULL; 62 | } 63 | } 64 | ELEMTYPE A[MAXSIZE]; 65 | int ai=0; 66 | ELEMTYPE B[MAXSIZE]; 67 | int bi=0; 68 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 69 | void PrintTree(BiTree T,int x){ 70 | if(T){ 71 | if(x==1){ 72 | cout<data<<" "; 73 | A[ai++]=T->data; 74 | } 75 | PrintTree(T->lchild,x); 76 | if(x==2){ 77 | cout<data<<" "; 78 | B[bi++]=T->data; 79 | } 80 | PrintTree(T->rchild,x); 81 | if(x==3){ 82 | cout<data<<" "; 83 | } 84 | if(x==2)free(T); 85 | } 86 | } 87 | void fun_start(BiTree &T){ 88 | //以下是一个预置的初始化数组 89 | //不使用第一项 90 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 91 | List L[MAXSIZE]; 92 | //InitList(L); 93 | InitTreeWithList(T,L0,1); 94 | cout<<"previous tree:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | BiTree q[MAXSIZE]; 18 | int front=0,rear=0; 19 | bool EnQueue(BiTree p){ 20 | if((rear+1)%MAXSIZE!=front){ 21 | q[rear]=p; 22 | rear=(rear+1)%MAXSIZE; 23 | return true; 24 | }else return false; 25 | } 26 | bool DeQueue(BiTree &p){ 27 | if(front!=rear){ 28 | p=q[front]; 29 | front=(front+1)%MAXSIZE; 30 | return true; 31 | }else return false; 32 | } 33 | bool IsQueueEmpty(){ 34 | if(front==rear)return true; 35 | return false; 36 | } 37 | void fun_start(BiTree &T); 38 | bool fun(BiTree &T){ 39 | BiTree p; 40 | if(T){ 41 | EnQueue(T); 42 | while(!IsQueueEmpty()){ 43 | DeQueue(p); 44 | if(p){ 45 | EnQueue(p->lchild); 46 | EnQueue(p->rchild); 47 | }else{ 48 | while(!IsQueueEmpty()){ 49 | DeQueue(p); 50 | if(p)return false; 51 | } 52 | } 53 | } 54 | } 55 | return true; 56 | } 57 | 58 | 59 | 60 | 61 | 62 | 63 | //不使用第一项 64 | void InitList(List L[]){ 65 | int x=0,y=0,n=0; 66 | ELEMTYPE d; 67 | L[0]={0,0,0}; 68 | cout<<"input numbers of tree node:"<>n; 70 | for(int i=1;n>x>>y>>d; 72 | L[i].lchild=x; 73 | L[i].rchild=y; 74 | L[i].data=d; 75 | } 76 | } 77 | void InitTreeWithList(BiTree &T,List L[],int index){ 78 | if(index!=NOP){ 79 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 80 | nd->data=L[index].data; 81 | T=nd; 82 | InitTreeWithList(T->lchild,L,L[index].lchild); 83 | InitTreeWithList(T->rchild,L,L[index].rchild); 84 | }else{ 85 | T=NULL; 86 | } 87 | } 88 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 89 | void PrintTree(BiTree T,int x){ 90 | if(T){ 91 | if(x==1){ 92 | cout<data<<" "; 93 | } 94 | PrintTree(T->lchild,x); 95 | if(x==2){ 96 | cout<data<<" "; 97 | } 98 | PrintTree(T->rchild,x); 99 | if(x==3){ 100 | cout<data<<" "; 101 | } 102 | free(T); 103 | } 104 | } 105 | void fun_start(BiTree &T){ 106 | //以下是一个预置的初始化数组 107 | //不使用第一项 108 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 109 | List L[MAXSIZE]; 110 | InitList(L); 111 | InitTreeWithList(T,L,1); 112 | cout<<"fun:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | BiTree q[MAXSIZE]; 18 | int front=0,rear=0; 19 | bool EnQueue(BiTree p){ 20 | if((rear+1)%MAXSIZE!=front){ 21 | q[rear]=p; 22 | rear=(rear+1)%MAXSIZE; 23 | return true; 24 | }else return false; 25 | } 26 | bool DeQueue(BiTree &p){ 27 | if(front!=rear){ 28 | p=q[front]; 29 | front=(front+1)%MAXSIZE; 30 | return true; 31 | }else return false; 32 | } 33 | bool IsQueueEmpty(){ 34 | if(front==rear)return true; 35 | return false; 36 | } 37 | void fun_start(BiTree &T); 38 | int fun(BiTree &T){ 39 | BiTree p; 40 | int count=0; 41 | if(T){ 42 | EnQueue(T); 43 | while(!IsQueueEmpty()){ 44 | DeQueue(p); 45 | if(p->lchild)EnQueue(p->lchild); 46 | if(p->rchild)EnQueue(p->rchild); 47 | if(p->lchild&&p->rchild)count++; 48 | } 49 | } 50 | return count; 51 | } 52 | 53 | 54 | 55 | 56 | 57 | 58 | //不使用第一项 59 | void InitList(List L[]){ 60 | int x=0,y=0,n=0; 61 | ELEMTYPE d; 62 | L[0]={0,0,0}; 63 | cout<<"input numbers of tree node:"<>n; 65 | for(int i=1;n>x>>y>>d; 67 | L[i].lchild=x; 68 | L[i].rchild=y; 69 | L[i].data=d; 70 | } 71 | } 72 | void InitTreeWithList(BiTree &T,List L[],int index){ 73 | if(index!=NOP){ 74 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 75 | nd->data=L[index].data; 76 | T=nd; 77 | InitTreeWithList(T->lchild,L,L[index].lchild); 78 | InitTreeWithList(T->rchild,L,L[index].rchild); 79 | }else{ 80 | T=NULL; 81 | } 82 | } 83 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 84 | void PrintTree(BiTree T,int x){ 85 | if(T){ 86 | if(x==1){ 87 | cout<data<<" "; 88 | } 89 | PrintTree(T->lchild,x); 90 | if(x==2){ 91 | cout<data<<" "; 92 | } 93 | PrintTree(T->rchild,x); 94 | if(x==3){ 95 | cout<data<<" "; 96 | } 97 | free(T); 98 | } 99 | } 100 | void fun_start(BiTree &T){ 101 | //以下是一个预置的初始化数组 102 | //不使用第一项 103 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 104 | List L[MAXSIZE]; 105 | //InitList(L); 106 | InitTreeWithList(T,L0,1); 107 | cout<<"fun:"< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | void fun(BiTree &T){ 19 | if(T){ 20 | fun(T->lchild); 21 | fun(T->rchild); 22 | BiTree tmp; 23 | tmp=T->lchild; 24 | T->lchild=T->rchild; 25 | T->rchild=tmp; 26 | } 27 | } 28 | 29 | 30 | 31 | 32 | 33 | 34 | //不使用第一项 35 | void InitList(List L[]){ 36 | int x=0,y=0,n=0; 37 | ELEMTYPE d; 38 | L[0]={0,0,0}; 39 | cout<<"input numbers of tree node:"<>n; 41 | for(int i=1;n>x>>y>>d; 43 | L[i].lchild=x; 44 | L[i].rchild=y; 45 | L[i].data=d; 46 | } 47 | } 48 | void InitTreeWithList(BiTree &T,List L[],int index){ 49 | if(index!=NOP){ 50 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 51 | nd->data=L[index].data; 52 | T=nd; 53 | InitTreeWithList(T->lchild,L,L[index].lchild); 54 | InitTreeWithList(T->rchild,L,L[index].rchild); 55 | }else{ 56 | T=NULL; 57 | } 58 | } 59 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 60 | void PrintTree(BiTree T,int x){ 61 | if(T){ 62 | if(x==1){ 63 | cout<data<<" "; 64 | } 65 | PrintTree(T->lchild,x); 66 | if(x==2){ 67 | cout<data<<" "; 68 | } 69 | PrintTree(T->rchild,x); 70 | if(x==3){ 71 | cout<data<<" "; 72 | } 73 | free(T); 74 | } 75 | } 76 | void fun_start(BiTree &T){ 77 | //以下是一个预置的初始化数组 78 | //不使用第一项 79 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 80 | List L[MAXSIZE]; 81 | //InitList(L); 82 | InitTreeWithList(T,L0,1); 83 | fun(T); 84 | PrintTree(T,1); 85 | } 86 | 87 | 88 | 89 | int main(){ 90 | BiTree T; 91 | fun_start(T); 92 | cout< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct TreeNode{ 8 | ELEMTYPE data; 9 | struct TreeNode *firstchild,*nextsibling; 10 | }TreeNode,*Tree; 11 | typedef struct ListNode{ 12 | int firstchild; 13 | int nextsibling; 14 | ELEMTYPE data; 15 | }List; 16 | int fun(Tree T){ 17 | if(T){ 18 | int tmp; 19 | if(T->firstchild)tmp=fun(T->firstchild); 20 | else tmp=1; 21 | tmp+=fun(T->nextsibling); 22 | return tmp; 23 | } 24 | return 0; 25 | } 26 | void InitTreeWithList(Tree &T,List L[],int index); 27 | void PrintTree(Tree T,int x); 28 | void InitList(List L[]); 29 | int main(){ 30 | Tree T; 31 | //以下是一个预置的初始化数组 32 | //不使用第一项 33 | List L0[12]={{0,0,0},{2,NOP,11},{NOP,3,12},{6,4,13},{8,5,14},{NOP,NOP,15},{NOP,7,16},{9,NOP,17},{NOP,NOP,18},{NOP,10,19},{NOP,11,20},{NOP,NOP,21}}; 34 | List L[MAXSIZE]; 35 | //InitList(L); 36 | InitTreeWithList(T,L0,1); 37 | cout<<"count:"<>n; 49 | for(int i=1;n>x>>y>>d; 51 | L[i].firstchild=x; 52 | L[i].nextsibling=y; 53 | L[i].data=d; 54 | } 55 | } 56 | void InitTreeWithList(Tree &T,List L[],int index){ 57 | if(index!=NOP){ 58 | Tree nd=(Tree)malloc(sizeof(TreeNode)); 59 | nd->data=L[index].data; 60 | T=nd; 61 | InitTreeWithList(T->firstchild,L,L[index].firstchild); 62 | InitTreeWithList(T->nextsibling,L,L[index].nextsibling); 63 | }else{ 64 | T=NULL; 65 | } 66 | } 67 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 68 | void PrintTree(Tree T,int x){ 69 | if(T){ 70 | if(x==1){ 71 | cout<data<<" "; 72 | } 73 | PrintTree(T->firstchild,x); 74 | if(x==2){ 75 | cout<data<<" "; 76 | } 77 | PrintTree(T->nextsibling,x); 78 | if(x==3){ 79 | cout<data<<" "; 80 | } 81 | free(T); 82 | } 83 | } 84 | 85 | -------------------------------------------------------------------------------- /4-4-6.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct TreeNode{ 8 | ELEMTYPE data; 9 | struct TreeNode *firstchild,*nextsibling; 10 | }TreeNode,*Tree; 11 | typedef struct ListNode{ 12 | int firstchild; 13 | int nextsibling; 14 | ELEMTYPE data; 15 | }List; 16 | int fun(Tree T){ 17 | if(T){ 18 | int tmp1,tmp2; 19 | if(T->firstchild)tmp1=1+fun(T->firstchild); 20 | else tmp1=0; 21 | tmp2=fun(T->nextsibling); 22 | return max(tmp1,tmp2); 23 | } 24 | return 1; 25 | } 26 | void InitTreeWithList(Tree &T,List L[],int index); 27 | void PrintTree(Tree T,int x); 28 | void InitList(List L[]); 29 | int main(){ 30 | Tree T; 31 | //以下是一个预置的初始化数组 32 | //不使用第一项 33 | List L0[13]={{0,0,0},{2,NOP,11},{NOP,3,12},{6,4,13},{8,5,14},{NOP,NOP,15},{NOP,7,16},{9,NOP,17},{NOP,NOP,18},{NOP,10,19},{12,11,20},{NOP,NOP,21},{NOP,NOP,22}}; 34 | List L[MAXSIZE]; 35 | //InitList(L); 36 | InitTreeWithList(T,L0,1); 37 | cout<<"count:"<>n; 49 | for(int i=1;n>x>>y>>d; 51 | L[i].firstchild=x; 52 | L[i].nextsibling=y; 53 | L[i].data=d; 54 | } 55 | } 56 | void InitTreeWithList(Tree &T,List L[],int index){ 57 | if(index!=NOP){ 58 | Tree nd=(Tree)malloc(sizeof(TreeNode)); 59 | nd->data=L[index].data; 60 | T=nd; 61 | InitTreeWithList(T->firstchild,L,L[index].firstchild); 62 | InitTreeWithList(T->nextsibling,L,L[index].nextsibling); 63 | }else{ 64 | T=NULL; 65 | } 66 | } 67 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 68 | void PrintTree(Tree T,int x){ 69 | if(T){ 70 | if(x==1){ 71 | cout<data<<" "; 72 | } 73 | PrintTree(T->firstchild,x); 74 | if(x==2){ 75 | cout<data<<" "; 76 | } 77 | PrintTree(T->nextsibling,x); 78 | if(x==3){ 79 | cout<data<<" "; 80 | } 81 | free(T); 82 | } 83 | } 84 | 85 | -------------------------------------------------------------------------------- /4-4-7-ans.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct TreeNode{ 8 | ELEMTYPE data; 9 | struct TreeNode *firstchild,*nextsibling; 10 | }TreeNode,*Tree; 11 | typedef struct ListNode{ 12 | int firstchild; 13 | int nextsibling; 14 | ELEMTYPE data; 15 | }List; 16 | typedef struct DegreeList{ 17 | int degree; 18 | ELEMTYPE data; 19 | }DegNode; 20 | void fun(Tree &T,DegNode tl[],int length){ 21 | Tree Pointer[length]; 22 | int i,j,d,k=1; 23 | for(i=1;idata=tl[i].data; 26 | Pointer[i]->firstchild=NULL; 27 | Pointer[i]->nextsibling=NULL; 28 | } 29 | for(i=1;ifirstchild=Pointer[k]; 34 | for(j=2;j<=d;j++){ 35 | k++; 36 | Pointer[k-1]->nextsibling=Pointer[k]; 37 | } 38 | } 39 | } 40 | T=Pointer[1]; 41 | } 42 | void InitTreeWithList(Tree &T,List L[],int index); 43 | void PrintTree(Tree T,int x); 44 | void InitList(List L[]); 45 | int main(){ 46 | Tree T1; 47 | Tree T2; 48 | //以下是一个预置的初始化数组 49 | //不使用第一项 50 | List L0[12]={{0,0,0},{2,NOP,11},{NOP,3,12},{6,4,13},{8,5,14},{NOP,NOP,15},{NOP,7,16},{9,NOP,17},{NOP,11,18},{NOP,10,19},{NOP,NOP,20},{NOP,NOP,21}}; 51 | List L[MAXSIZE]; 52 | DegNode tl[12]={{0,0},{4,11},{0,12},{2,13},{1,14},{0,15},{0,16},{2,17},{1,18},{0,19},{0,20},{0,21}}; 53 | //InitList(L); 54 | InitTreeWithList(T1,L0,1); 55 | fun(T2,tl,12); 56 | cout<>n; 70 | for(int i=1;n>x>>y>>d; 72 | L[i].firstchild=x; 73 | L[i].nextsibling=y; 74 | L[i].data=d; 75 | } 76 | } 77 | void InitTreeWithList(Tree &T,List L[],int index){ 78 | if(index!=NOP){ 79 | Tree nd=(Tree)malloc(sizeof(TreeNode)); 80 | nd->data=L[index].data; 81 | T=nd; 82 | InitTreeWithList(T->firstchild,L,L[index].firstchild); 83 | InitTreeWithList(T->nextsibling,L,L[index].nextsibling); 84 | }else{ 85 | T=NULL; 86 | } 87 | } 88 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 89 | void PrintTree(Tree T,int x){ 90 | if(T){ 91 | if(x==1){ 92 | cout<data<<" "; 93 | } 94 | PrintTree(T->firstchild,x); 95 | if(x==2){ 96 | cout<data<<" "; 97 | } 98 | PrintTree(T->nextsibling,x); 99 | if(x==3){ 100 | cout<data<<" "; 101 | } 102 | free(T); 103 | } 104 | } 105 | -------------------------------------------------------------------------------- /4-4-7.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct TreeNode{ 8 | ELEMTYPE data; 9 | struct TreeNode *firstchild,*nextsibling; 10 | }TreeNode,*Tree; 11 | typedef struct ListNode{ 12 | int firstchild; 13 | int nextsibling; 14 | ELEMTYPE data; 15 | }List; 16 | typedef struct DegreeList{ 17 | int degree; 18 | ELEMTYPE data; 19 | }DegNode; 20 | void fun(List L[],DegNode tl[]){ 21 | L[1].data=tl[1].data; 22 | L[1].nextsibling=NOP; 23 | int pre=1,last=2,next=2;//各层次起始 24 | while(pre>n; 74 | for(int i=1;n>x>>y>>d; 76 | L[i].firstchild=x; 77 | L[i].nextsibling=y; 78 | L[i].data=d; 79 | } 80 | } 81 | void InitTreeWithList(Tree &T,List L[],int index){ 82 | if(index!=NOP){ 83 | Tree nd=(Tree)malloc(sizeof(TreeNode)); 84 | nd->data=L[index].data; 85 | T=nd; 86 | InitTreeWithList(T->firstchild,L,L[index].firstchild); 87 | InitTreeWithList(T->nextsibling,L,L[index].nextsibling); 88 | }else{ 89 | T=NULL; 90 | } 91 | } 92 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 93 | void PrintTree(Tree T,int x){ 94 | if(T){ 95 | if(x==1){ 96 | cout<data<<" "; 97 | } 98 | PrintTree(T->firstchild,x); 99 | if(x==2){ 100 | cout<data<<" "; 101 | } 102 | PrintTree(T->nextsibling,x); 103 | if(x==3){ 104 | cout<data<<" "; 105 | } 106 | free(T); 107 | } 108 | } 109 | -------------------------------------------------------------------------------- /4-5-10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ELEMTYPE int 4 | #define MAXSIZE 50 5 | #define END 9999 6 | typedef struct BNode{ 7 | struct BNode* lchild; 8 | struct BNode* rchild; 9 | ELEMTYPE key; 10 | int count; 11 | }BNode,*BST; 12 | void fun(BST &T,int k){ 13 | if(T){ 14 | fun(T->rchild,k); 15 | if(T->key>=k)cout<key<<" "; 16 | fun(T->lchild,k); 17 | } 18 | } 19 | bool BST_Insert(BST &T,ELEMTYPE x); 20 | void InitBST(BST &T,ELEMTYPE L[]); 21 | void Print_BST(BST T,int tag); 22 | BST BST_search(BST T,ELEMTYPE value); 23 | int main(){ 24 | ELEMTYPE L[MAXSIZE]; 25 | ELEMTYPE c; 26 | cin>>c; 27 | int i=0; 28 | for(i=0;i>c; 31 | } 32 | L[i]=c; 33 | BST T=NULL; 34 | InitBST(T,L); 35 | cin>>c; 36 | fun(T,c); 37 | cout<key>value)return BST_search(T->lchild,value); 45 | else if(T->keyrchild,value); 46 | else return T; 47 | return NULL; 48 | } 49 | bool BST_Insert(BST &T,ELEMTYPE x){ 50 | if(T){ 51 | if(xkey)return BST_Insert(T->lchild,x); 52 | else if(x>T->key)return BST_Insert(T->rchild,x); 53 | else return false; 54 | }else{ 55 | T=(BST)malloc(sizeof(BNode)); 56 | T->key=x; 57 | T->lchild=NULL; 58 | T->rchild=NULL; 59 | return true; 60 | } 61 | } 62 | void InitBST(BST &T,ELEMTYPE L[]){ 63 | for(int i=0;L[i]!=END;i++){ 64 | BST_Insert(T,L[i]); 65 | } 66 | } 67 | void Print_BST(BST T,int tag){ 68 | if(!T)return ; 69 | if(tag==1)cout<key<<" "; 70 | Print_BST(T->lchild,tag); 71 | if(tag==2)cout<key<<" "; 72 | Print_BST(T->rchild,tag); 73 | if(tag==3)cout<key<<" "; 74 | free(T); 75 | } 76 | -------------------------------------------------------------------------------- /4-5-11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAXSIZE 50 4 | #define END 9999 5 | typedef struct HNode{ 6 | struct HNode* lchild; 7 | struct HNode* rchild; 8 | int data; 9 | int count; 10 | }HNode,*HTree; 11 | typedef struct forestNode{ 12 | HTree data; 13 | struct forestNode* next; 14 | }forestNode,*forest; 15 | int HTree_WPL(HTree T,int level){ 16 | static int WPL=0; 17 | if(T){ 18 | if(T->lchild)HTree_WPL(T->lchild,level+1); 19 | if(T->rchild)HTree_WPL(T->rchild,level+1); 20 | if(!T->lchild&&!T->rchild)WPL+=level*T->data; 21 | } 22 | return WPL; 23 | } 24 | void InitForest(forest &F,int L[]); 25 | void InitHTree(HTree &T,forest &F); 26 | void Print_HTree(HTree T,int tag); 27 | void QSort(int L[],int low,int high); 28 | int main(){ 29 | int L[MAXSIZE]; 30 | int c; 31 | cin>>c; 32 | int i=0; 33 | for(i=0;i>c; 36 | } 37 | if(i==0)return 0; 38 | L[i]=c; 39 | HTree T=NULL; 40 | forest F=NULL; 41 | //forest p=NULL; 42 | QSort(L,0,i-1); 43 | //带头结点 44 | InitForest(F,L); 45 | InitHTree(T,F); 46 | /*p=F->next; 47 | while(p) 48 | { 49 | cout<data->data<<" "; 50 | p=p->next; 51 | }*/ 52 | cout<<"WPL:"<=tmp;j--); 67 | L[i]=L[j]; 68 | for(;inext; 78 | for(;p&&p->data->data<=f->data->data;pre=pre->next,p=p->next); 79 | f->next=pre->next; 80 | pre->next=f; 81 | } 82 | void InitHTree(HTree &T,forest &F){ 83 | forest p=F; 84 | HTree tmp; 85 | while(F->next&&F->next->next){ 86 | p=F->next; 87 | tmp=(HTree)malloc(sizeof(HNode)); 88 | tmp->data=p->data->data+p->next->data->data; 89 | tmp->lchild=p->data; 90 | tmp->rchild=p->next->data; 91 | p->next->data=tmp; 92 | F->next=p->next->next; 93 | ForestInsert(p->next,F); 94 | free(p); 95 | } 96 | T=F->next->data; 97 | free(F->next); 98 | free(F); 99 | } 100 | void InitForest(forest &F,int L[]){ 101 | forest p,s; 102 | F=(forest)malloc(sizeof(forestNode)); 103 | F->next=NULL; 104 | p=F; 105 | for(int i=0;L[i]!=END;i++){ 106 | s=(forest)malloc(sizeof(forestNode)); 107 | s->data=(HTree)malloc(sizeof(HNode)); 108 | s->data->lchild=NULL; 109 | s->data->rchild=NULL; 110 | s->data->data=L[i]; 111 | s->next=p->next; 112 | p->next=s; 113 | p=p->next; 114 | } 115 | } 116 | void Print_HTree(HTree T,int tag){ 117 | if(!T)return ; 118 | if(tag==1)cout<data<<" "; 119 | Print_HTree(T->lchild,tag); 120 | if(tag==2)cout<data<<" "; 121 | Print_HTree(T->rchild,tag); 122 | if(tag==3)cout<data<<" "; 123 | free(T); 124 | } 125 | -------------------------------------------------------------------------------- /4-5-12-ans.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ELEMTYPE int 4 | #define MAXSIZE 50 5 | #define END 9999 6 | typedef struct BNode{ 7 | struct BNode* lchild; 8 | struct BNode* rchild; 9 | ELEMTYPE key; 10 | int count; 11 | }BNode,*BST; 12 | BST fun(BST T,int k){ 13 | if(k<1||T->countlchild){ 15 | if(k==1)return T; 16 | else return fun(T->rchild,k-1); 17 | }else { 18 | if(T->lchild->count>k-1)return fun(T->lchild,k); //bug:注意是k-1，count为该子树结点数！ 19 | else if(T->lchild->count==k-1)return T; 20 | else return fun(T->rchild,k-(1+T->lchild->count)); 21 | } 22 | return NULL; 23 | } 24 | bool BST_Insert(BST &T,ELEMTYPE x); 25 | void InitBST(BST &T,ELEMTYPE L[]); 26 | void Print_BST(BST T,int tag); 27 | BST BST_search(BST T,ELEMTYPE value); 28 | int BST_count(BST &T); 29 | int main(){ 30 | ELEMTYPE L[MAXSIZE]; 31 | ELEMTYPE c; 32 | cin>>c; 33 | int i=0; 34 | for(i=0;i>c; 37 | } 38 | L[i]=c; 39 | BST T=NULL; 40 | InitBST(T,L); 41 | BST_count(T); 42 | cin>>c; 43 | BST p; 44 | p=fun(T,c); 45 | if(p)cout<<"p:"<key<lchild); 54 | count+=BST_count(T->rchild); 55 | T->count=count+1; 56 | return count+1; 57 | } 58 | return 0; 59 | } 60 | BST BST_search(BST T,ELEMTYPE value){ 61 | if(!T)return NULL; 62 | if(T->key>value)return BST_search(T->lchild,value); 63 | else if(T->keyrchild,value); 64 | else return T; 65 | return NULL; 66 | } 67 | bool BST_Insert(BST &T,ELEMTYPE x){ 68 | if(T){ 69 | if(xkey)return BST_Insert(T->lchild,x); 70 | else if(x>T->key)return BST_Insert(T->rchild,x); 71 | else return false; 72 | }else{ 73 | T=(BST)malloc(sizeof(BNode)); 74 | T->key=x; 75 | T->lchild=NULL; 76 | T->rchild=NULL; 77 | return true; 78 | } 79 | } 80 | void InitBST(BST &T,ELEMTYPE L[]){ 81 | for(int i=0;L[i]!=END;i++){ 82 | BST_Insert(T,L[i]); 83 | } 84 | } 85 | void Print_BST(BST T,int tag){ 86 | if(!T)return ; 87 | if(tag==1)cout<key<<":"<count<<" "; 88 | Print_BST(T->lchild,tag); 89 | if(tag==2)cout<key<<":"<count<<" "; 90 | Print_BST(T->rchild,tag); 91 | if(tag==3)cout<key<<":"<count<<" "; 92 | free(T); 93 | } 94 | -------------------------------------------------------------------------------- /4-5-12.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ELEMTYPE int 4 | #define MAXSIZE 50 5 | #define END 9999 6 | typedef struct BNode{ 7 | struct BNode* lchild; 8 | struct BNode* rchild; 9 | ELEMTYPE key; 10 | int count; 11 | }BNode,*BST; 12 | int count=0; 13 | BST fun(BST T,int k){ 14 | if(T){ 15 | BST t; 16 | if(t=fun(T->lchild,k))return t; 17 | count++; 18 | if(k==count)return T; 19 | if(t=fun(T->rchild,k))return t; 20 | } 21 | return NULL; 22 | } 23 | bool BST_Insert(BST &T,ELEMTYPE x); 24 | void InitBST(BST &T,ELEMTYPE L[]); 25 | void Print_BST(BST T,int tag); 26 | BST BST_search(BST T,ELEMTYPE value); 27 | int main(){ 28 | ELEMTYPE L[MAXSIZE]; 29 | ELEMTYPE c; 30 | cin>>c; 31 | int i=0; 32 | for(i=0;i>c; 35 | } 36 | L[i]=c; 37 | BST T=NULL; 38 | InitBST(T,L); 39 | cin>>c; 40 | BST p; 41 | p=fun(T,c); 42 | if(p)cout<<"find:"<key<key>value)return BST_search(T->lchild,value); 50 | else if(T->keyrchild,value); 51 | else return T; 52 | return NULL; 53 | } 54 | bool BST_Insert(BST &T,ELEMTYPE x){ 55 | if(T){ 56 | if(xkey)return BST_Insert(T->lchild,x); 57 | else if(x>T->key)return BST_Insert(T->rchild,x); 58 | else return false; 59 | }else{ 60 | T=(BST)malloc(sizeof(BNode)); 61 | T->key=x; 62 | T->lchild=NULL; 63 | T->rchild=NULL; 64 | return true; 65 | } 66 | } 67 | void InitBST(BST &T,ELEMTYPE L[]){ 68 | for(int i=0;L[i]!=END;i++){ 69 | BST_Insert(T,L[i]); 70 | } 71 | } 72 | void Print_BST(BST T,int tag){ 73 | if(!T)return ; 74 | if(tag==1)cout<key<<" "; 75 | Print_BST(T->lchild,tag); 76 | if(tag==2)cout<key<<" "; 77 | Print_BST(T->rchild,tag); 78 | if(tag==3)cout<key<<" "; 79 | free(T); 80 | } 81 | -------------------------------------------------------------------------------- /4-5-6-ans.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | void fun_start(BiTree &T); 17 | int predt=-32767; 18 | int fun(BiTree &T){ 19 | if(!T)return 1; 20 | int b1,b2; 21 | b1=fun(T->lchild); 22 | if(b1==0||predt>=T->data){ 23 | return 0; 24 | } 25 | predt=T->data; 26 | b2=fun(T->rchild); 27 | return b2; 28 | } 29 | //不使用第一项 30 | void InitList(List L[]){ 31 | int x=0,y=0,n=0; 32 | ELEMTYPE d; 33 | L[0]={0,0,0}; 34 | cout<<"input numbers of tree node:"<>n; 36 | for(int i=1;n>x>>y>>d; 38 | L[i].lchild=x; 39 | L[i].rchild=y; 40 | L[i].data=d; 41 | } 42 | } 43 | void InitTreeWithList(BiTree &T,List L[],int index){ 44 | if(index!=NOP){ 45 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 46 | nd->data=L[index].data; 47 | T=nd; 48 | InitTreeWithList(T->lchild,L,L[index].lchild); 49 | InitTreeWithList(T->rchild,L,L[index].rchild); 50 | }else{ 51 | T=NULL; 52 | } 53 | } 54 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 55 | void PrintTree(BiTree T,int x){ 56 | if(T){ 57 | if(x==1){ 58 | cout<data<<" "; 59 | } 60 | PrintTree(T->lchild,x); 61 | if(x==2){ 62 | cout<data<<" "; 63 | } 64 | PrintTree(T->rchild,x); 65 | if(x==3){ 66 | cout<data<<" "; 67 | } 68 | free(T); 69 | } 70 | } 71 | void fun_start(BiTree &T){ 72 | //以下是一个预置的初始化数组 73 | //不使用第一项 74 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 75 | List L[MAXSIZE]; 76 | //InitList(L); 77 | InitTreeWithList(T,L0,1); 78 | cout<<(fun(T)?"true":"false")< 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | #define LEFT 3 7 | #define RIGHT 1 8 | using namespace std; 9 | typedef struct BiNode{ 10 | ELEMTYPE data; 11 | struct BiNode *lchild,*rchild; 12 | }BiNode,*BiTree; 13 | typedef struct ListNode{ 14 | int lchild; 15 | int rchild; 16 | ELEMTYPE data; 17 | }List; 18 | void fun_start(BiTree &T); 19 | bool flag=true; 20 | int fun(BiTree T,int tag){ 21 | if(T&&flag){ 22 | int minval,maxval; 23 | if(T->lchild)maxval=fun(T->lchild,LEFT); 24 | else maxval=T->data; 25 | if(T->rchild)minval=fun(T->rchild,RIGHT); 26 | else minval=T->data; 27 | //cout<data<<":"<lchild&&!T->rchild)return T->data; 29 | else if(!T->lchild&&T->rchild){ 30 | if(T->data>=minval)flag=false; 31 | }else if(T->rchild&&!T->lchild){ 32 | if(T->data<=maxval)flag=false; 33 | }else if(T->lchild&&T->rchild){ 34 | if(T->data>=minval||T->data<=maxval)flag=false; 35 | } 36 | if(tag==LEFT)return maxval; 37 | if(tag==RIGHT)return minval; 38 | } 39 | return 0; 40 | } 41 | //不使用第一项 42 | void InitList(List L[]){ 43 | int x=0,y=0,n=0; 44 | ELEMTYPE d; 45 | L[0]={0,0,0}; 46 | cout<<"input numbers of tree node:"<>n; 48 | for(int i=1;n>x>>y>>d; 50 | L[i].lchild=x; 51 | L[i].rchild=y; 52 | L[i].data=d; 53 | } 54 | } 55 | void InitTreeWithList(BiTree &T,List L[],int index){ 56 | if(index!=NOP){ 57 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 58 | nd->data=L[index].data; 59 | T=nd; 60 | InitTreeWithList(T->lchild,L,L[index].lchild); 61 | InitTreeWithList(T->rchild,L,L[index].rchild); 62 | }else{ 63 | T=NULL; 64 | } 65 | } 66 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 67 | void PrintTree(BiTree T,int x){ 68 | if(T){ 69 | if(x==1){ 70 | cout<data<<" "; 71 | } 72 | PrintTree(T->lchild,x); 73 | if(x==2){ 74 | cout<data<<" "; 75 | } 76 | PrintTree(T->rchild,x); 77 | if(x==3){ 78 | cout<data<<" "; 79 | } 80 | free(T); 81 | } 82 | } 83 | void fun_start(BiTree &T){ 84 | //以下是一个预置的初始化数组 85 | //不使用第一项 86 | // List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 87 | List L[MAXSIZE]; 88 | InitList(L); 89 | InitTreeWithList(T,L,1); 90 | int minval=1,maxval=1; 91 | maxval=fun(T,LEFT); 92 | //cout< 2 | using namespace std; 3 | #define ELEMTYPE int 4 | #define MAXSIZE 50 5 | #define END 9999 6 | typedef struct BNode{ 7 | struct BNode* lchild; 8 | struct BNode* rchild; 9 | ELEMTYPE key; 10 | int count; 11 | }BNode,*BST; 12 | int fun(BST T,BNode *p){ 13 | int n=1; 14 | while(T){ 15 | if(T->key>p->key){ 16 | T=T->lchild; 17 | }else if(T->keykey){ 18 | T=T->rchild; 19 | }else if(T==p)break; 20 | n++; 21 | } 22 | if(!T)return 0; 23 | return n; 24 | } 25 | bool BST_Insert(BST &T,ELEMTYPE x); 26 | void InitBST(BST &T,ELEMTYPE L[]); 27 | void Print_BST(BST T,int tag); 28 | BST BST_search(BST T,ELEMTYPE value); 29 | int main(){ 30 | ELEMTYPE L[MAXSIZE]; 31 | ELEMTYPE c; 32 | cin>>c; 33 | int i=0; 34 | for(i=0;i>c; 37 | } 38 | L[i]=c; 39 | BST T=NULL; 40 | InitBST(T,L); 41 | cout<<"input:"; 42 | cin>>c; 43 | BST p=BST_search(T,c); 44 | cout<<"level:"<key>value)return BST_search(T->lchild,value); 52 | else if(T->keyrchild,value); 53 | else return T; 54 | return NULL; 55 | } 56 | bool BST_Insert(BST &T,ELEMTYPE x){ 57 | if(T){ 58 | if(xkey)return BST_Insert(T->lchild,x); 59 | else if(x>T->key)return BST_Insert(T->rchild,x); 60 | else return false; 61 | }else{ 62 | T=(BST)malloc(sizeof(BNode)); 63 | T->key=x; 64 | T->lchild=NULL; 65 | T->rchild=NULL; 66 | return true; 67 | } 68 | } 69 | void InitBST(BST &T,ELEMTYPE L[]){ 70 | for(int i=0;L[i]!=END;i++){ 71 | BST_Insert(T,L[i]); 72 | } 73 | } 74 | void Print_BST(BST T,int tag){ 75 | if(!T)return ; 76 | if(tag==1)cout<key<<" "; 77 | Print_BST(T->lchild,tag); 78 | if(tag==2)cout<key<<" "; 79 | Print_BST(T->rchild,tag); 80 | if(tag==3)cout<key<<" "; 81 | free(T); 82 | } 83 | -------------------------------------------------------------------------------- /4-5-8.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ELEMTYPE int 4 | #define MAXSIZE 50 5 | #define END 9999 6 | typedef struct BNode{ 7 | struct BNode* lchild; 8 | struct BNode* rchild; 9 | ELEMTYPE key; 10 | int count; 11 | }BNode,*BST; 12 | bool flag=true; 13 | int fun(BST T){ 14 | if(T){ 15 | int h1,h2; 16 | h1=fun(T->lchild); 17 | h2=fun(T->rchild); 18 | if(abs(h1-h2)>1)flag=false; 19 | return max(h1,h2)+1; 20 | } 21 | return 0; 22 | } 23 | bool BST_Insert(BST &T,ELEMTYPE x); 24 | void InitBST(BST &T,ELEMTYPE L[]); 25 | void Print_BST(BST T,int tag); 26 | BST BST_search(BST T,ELEMTYPE value); 27 | int main(){ 28 | ELEMTYPE L[MAXSIZE]; 29 | ELEMTYPE c; 30 | cin>>c; 31 | int i=0; 32 | for(i=0;i>c; 35 | } 36 | L[i]=c; 37 | BST T=NULL; 38 | InitBST(T,L); 39 | fun(T); 40 | cout<<(flag?"true":"false")<key>value)return BST_search(T->lchild,value); 48 | else if(T->keyrchild,value); 49 | else return T; 50 | return NULL; 51 | } 52 | bool BST_Insert(BST &T,ELEMTYPE x){ 53 | if(T){ 54 | if(xkey)return BST_Insert(T->lchild,x); 55 | else if(x>T->key)return BST_Insert(T->rchild,x); 56 | else return false; 57 | }else{ 58 | T=(BST)malloc(sizeof(BNode)); 59 | T->key=x; 60 | T->lchild=NULL; 61 | T->rchild=NULL; 62 | return true; 63 | } 64 | } 65 | void InitBST(BST &T,ELEMTYPE L[]){ 66 | for(int i=0;L[i]!=END;i++){ 67 | BST_Insert(T,L[i]); 68 | } 69 | } 70 | void Print_BST(BST T,int tag){ 71 | if(!T)return ; 72 | if(tag==1)cout<key<<" "; 73 | Print_BST(T->lchild,tag); 74 | if(tag==2)cout<key<<" "; 75 | Print_BST(T->rchild,tag); 76 | if(tag==3)cout<key<<" "; 77 | free(T); 78 | } 79 | -------------------------------------------------------------------------------- /4-5-9.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAXSIZE 50 4 | #define END 9999 5 | typedef struct BNode{ 6 | struct BNode* lchild; 7 | struct BNode* rchild; 8 | int key; 9 | int count; 10 | }BNode,*BST; 11 | int fun(BST T,int &minval,int &maxval){ 12 | BST p=T; 13 | while(p->lchild)p=p->lchild; 14 | minval=p->key; 15 | p=T; 16 | while(p->rchild)p=p->rchild; 17 | maxval=p->key; 18 | return 0; 19 | } 20 | bool BST_Insert(BST &T,int x); 21 | void InitBST(BST &T,int L[]); 22 | void Print_BST(BST T,int tag); 23 | BST BST_search(BST T,int value); 24 | int main(){ 25 | int L[MAXSIZE]; 26 | int c; 27 | cin>>c; 28 | int i=0; 29 | for(i=0;i>c; 32 | } 33 | L[i]=c; 34 | BST T=NULL; 35 | InitBST(T,L); 36 | int minval,maxval; 37 | fun(T,minval,maxval); 38 | cout<<"min:"<key>value)return BST_search(T->lchild,value); 46 | else if(T->keyrchild,value); 47 | else return T; 48 | return NULL; 49 | } 50 | bool BST_Insert(BST &T,int x){ 51 | if(T){ 52 | if(xkey)return BST_Insert(T->lchild,x); 53 | else if(x>T->key)return BST_Insert(T->rchild,x); 54 | else return false; 55 | }else{ 56 | T=(BST)malloc(sizeof(BNode)); 57 | T->key=x; 58 | T->lchild=NULL; 59 | T->rchild=NULL; 60 | return true; 61 | } 62 | } 63 | void InitBST(BST &T,int L[]){ 64 | for(int i=0;L[i]!=END;i++){ 65 | BST_Insert(T,L[i]); 66 | } 67 | } 68 | void Print_BST(BST T,int tag){ 69 | if(!T)return ; 70 | if(tag==1)cout<key<<" "; 71 | Print_BST(T->lchild,tag); 72 | if(tag==2)cout<key<<" "; 73 | Print_BST(T->rchild,tag); 74 | if(tag==3)cout<key<<" "; 75 | free(T); 76 | } 77 | -------------------------------------------------------------------------------- /4-BST.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define ELEMTYPE int 4 | #define MAXSIZE 50 5 | #define END 9999 6 | typedef struct BNode{ 7 | struct BNode* lchild; 8 | struct BNode* rchild; 9 | ELEMTYPE key; 10 | int count; 11 | }BNode,*BST; 12 | int fun(BST &T){ 13 | return 0; 14 | } 15 | bool BST_Insert(BST &T,ELEMTYPE x); 16 | void InitBST(BST &T,ELEMTYPE L[]); 17 | void Print_BST(BST T,int tag); 18 | BST BST_search(BST T,ELEMTYPE value); 19 | int main(){ 20 | ELEMTYPE L[MAXSIZE]; 21 | ELEMTYPE c; 22 | cin>>c; 23 | int i=0; 24 | for(i=0;i>c; 27 | } 28 | L[i]=c; 29 | BST T=NULL; 30 | InitBST(T,L); 31 | fun(T); 32 | Print_BST(T,2); 33 | cout<key>value)return BST_search(T->lchild,value); 39 | else if(T->keyrchild,value); 40 | else return T; 41 | return NULL; 42 | } 43 | bool BST_Insert(BST &T,ELEMTYPE x){ 44 | if(T){ 45 | if(xkey)return BST_Insert(T->lchild,x); 46 | else if(x>T->key)return BST_Insert(T->rchild,x); 47 | else return false; 48 | }else{ 49 | T=(BST)malloc(sizeof(BNode)); 50 | T->key=x; 51 | T->lchild=NULL; 52 | T->rchild=NULL; 53 | return true; 54 | } 55 | } 56 | void InitBST(BST &T,ELEMTYPE L[]){ 57 | for(int i=0;L[i]!=END;i++){ 58 | BST_Insert(T,L[i]); 59 | } 60 | } 61 | void Print_BST(BST T,int tag){ 62 | if(!T)return ; 63 | if(tag==1)cout<key<<" "; 64 | Print_BST(T->lchild,tag); 65 | if(tag==2)cout<key<<" "; 66 | Print_BST(T->rchild,tag); 67 | if(tag==3)cout<key<<" "; 68 | free(T); 69 | } 70 | -------------------------------------------------------------------------------- /4-BiTree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct BiNode{ 8 | ELEMTYPE data; 9 | struct BiNode *lchild,*rchild; 10 | }BiNode,*BiTree; 11 | typedef struct ListNode{ 12 | int lchild; 13 | int rchild; 14 | ELEMTYPE data; 15 | }List; 16 | 17 | void fun_start(BiTree &T); 18 | void fun(BiTree &T){ 19 | 20 | } 21 | 22 | 23 | 24 | 25 | 26 | 27 | //不使用第一项 28 | void InitList(List L[]){ 29 | int x=0,y=0,n=0; 30 | ELEMTYPE d; 31 | L[0]={0,0,0}; 32 | cout<<"input numbers of tree node:"<>n; 34 | for(int i=1;n>x>>y>>d; 36 | L[i].lchild=x; 37 | L[i].rchild=y; 38 | L[i].data=d; 39 | } 40 | } 41 | void InitTreeWithList(BiTree &T,List L[],int index){ 42 | if(index!=NOP){ 43 | BiTree nd=(BiTree)malloc(sizeof(BiNode)); 44 | nd->data=L[index].data; 45 | T=nd; 46 | InitTreeWithList(T->lchild,L,L[index].lchild); 47 | InitTreeWithList(T->rchild,L,L[index].rchild); 48 | }else{ 49 | T=NULL; 50 | } 51 | } 52 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 53 | void PrintTree(BiTree T,int x){ 54 | if(T){ 55 | if(x==1){ 56 | cout<data<<" "; 57 | } 58 | PrintTree(T->lchild,x); 59 | if(x==2){ 60 | cout<data<<" "; 61 | } 62 | PrintTree(T->rchild,x); 63 | if(x==3){ 64 | cout<data<<" "; 65 | } 66 | free(T); 67 | } 68 | } 69 | void fun_start(BiTree &T){ 70 | //以下是一个预置的初始化数组 71 | //不使用第一项 72 | List L0[10]={{0,0,0},{2,3,11},{4,5,12},{6,NOP,13},{NOP,7,14},{NOP,8,15},{NOP,NOP,16},{9,NOP,17},{NOP,NOP,18},{NOP,NOP,19}}; 73 | List L[MAXSIZE]; 74 | //InitList(L); 75 | InitTreeWithList(T,L0,1); 76 | fun(T); 77 | PrintTree(T,1); 78 | } 79 | 80 | 81 | 82 | int main(){ 83 | BiTree T; 84 | fun_start(T); 85 | cout< 2 | using namespace std; 3 | #define MAXSIZE 50 4 | #define END 9999 5 | typedef struct HNode{ 6 | struct HNode* lchild; 7 | struct HNode* rchild; 8 | int data; 9 | int count; 10 | }HNode,*HTree; 11 | typedef struct forestNode{ 12 | HTree data; 13 | struct forestNode* next; 14 | }forestNode,*forest; 15 | int fun(HTree &T){ 16 | return 0; 17 | } 18 | void InitForest(forest &F,int L[]); 19 | void InitHTree(HTree &T,forest &F); 20 | void Print_HTree(HTree T,int tag); 21 | void QSort(int L[],int low,int high); 22 | int main(){ 23 | int L[MAXSIZE]; 24 | int c; 25 | cin>>c; 26 | int i=0; 27 | for(i=0;i>c; 30 | } 31 | if(i==0)return 0; 32 | L[i]=c; 33 | HTree T=NULL; 34 | forest F=NULL; 35 | //forest p=NULL; 36 | QSort(L,0,i-1); 37 | //带头结点 38 | InitForest(F,L); 39 | InitHTree(T,F); 40 | /*p=F->next; 41 | while(p) 42 | { 43 | cout<data->data<<" "; 44 | p=p->next; 45 | }*/ 46 | fun(T); 47 | Print_HTree(T,1); 48 | cout<=tmp;j--); 61 | L[i]=L[j]; 62 | for(;inext; 72 | for(;p&&p->data->data<=f->data->data;pre=pre->next,p=p->next); 73 | f->next=pre->next; 74 | pre->next=f; 75 | } 76 | void InitHTree(HTree &T,forest &F){ 77 | forest p=F; 78 | HTree tmp; 79 | while(F->next&&F->next->next){ 80 | p=F->next; 81 | tmp=(HTree)malloc(sizeof(HNode)); 82 | tmp->data=p->data->data+p->next->data->data; 83 | tmp->lchild=p->data; 84 | tmp->rchild=p->next->data; 85 | p->next->data=tmp; 86 | F->next=p->next->next; 87 | ForestInsert(p->next,F); 88 | free(p); 89 | } 90 | T=F->next->data; 91 | free(F->next); 92 | free(F); 93 | } 94 | void InitForest(forest &F,int L[]){ 95 | forest p,s; 96 | F=(forest)malloc(sizeof(forestNode)); 97 | F->next=NULL; 98 | p=F; 99 | for(int i=0;L[i]!=END;i++){ 100 | s=(forest)malloc(sizeof(forestNode)); 101 | s->data=(HTree)malloc(sizeof(HNode)); 102 | s->data->lchild=NULL; 103 | s->data->rchild=NULL; 104 | s->data->data=L[i]; 105 | s->next=p->next; 106 | p->next=s; 107 | p=p->next; 108 | } 109 | } 110 | void Print_HTree(HTree T,int tag){ 111 | if(!T)return ; 112 | if(tag==1)cout<data<<" "; 113 | Print_HTree(T->lchild,tag); 114 | if(tag==2)cout<data<<" "; 115 | Print_HTree(T->rchild,tag); 116 | if(tag==3)cout<data<<" "; 117 | free(T); 118 | } 119 | -------------------------------------------------------------------------------- /4-Tree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ELEMTYPE int 3 | #define MAXSIZE 50 4 | #define END 9999 5 | #define NOP -1 6 | using namespace std; 7 | typedef struct TreeNode{ 8 | ELEMTYPE data; 9 | struct TreeNode *firstchild,*nextsibling; 10 | }TreeNode,*Tree; 11 | typedef struct ListNode{ 12 | int firstchild; 13 | int nextsibling; 14 | ELEMTYPE data; 15 | }List; 16 | void fun(Tree &T){ 17 | } 18 | void InitTreeWithList(Tree &T,List L[],int index); 19 | void PrintTree(Tree T,int x); 20 | void InitList(List L[]); 21 | int main(){ 22 | Tree T; 23 | //以下是一个预置的初始化数组 24 | //不使用第一项 25 | List L0[12]={{0,0,0},{2,NOP,11},{NOP,3,12},{6,4,13},{8,5,14},{NOP,NOP,15},{NOP,7,16},{9,NOP,17},{NOP,NOP,18},{NOP,10,19},{NOP,11,20},{NOP,NOP,21}}; 26 | List L[MAXSIZE]; 27 | //InitList(L); 28 | InitTreeWithList(T,L0,1); 29 | fun(T); 30 | PrintTree(T,1); 31 | cout<>n; 41 | for(int i=1;n>x>>y>>d; 43 | L[i].firstchild=x; 44 | L[i].nextsibling=y; 45 | L[i].data=d; 46 | } 47 | } 48 | void InitTreeWithList(Tree &T,List L[],int index){ 49 | if(index!=NOP){ 50 | Tree nd=(Tree)malloc(sizeof(TreeNode)); 51 | nd->data=L[index].data; 52 | T=nd; 53 | InitTreeWithList(T->firstchild,L,L[index].firstchild); 54 | InitTreeWithList(T->nextsibling,L,L[index].nextsibling); 55 | }else{ 56 | T=NULL; 57 | } 58 | } 59 | // 1 for PreOrder,2 for InOrder,3 for PostOrder 60 | void PrintTree(Tree T,int x){ 61 | if(T){ 62 | if(x==1){ 63 | cout<data<<" "; 64 | } 65 | PrintTree(T->firstchild,x); 66 | if(x==2){ 67 | cout<data<<" "; 68 | } 69 | PrintTree(T->nextsibling,x); 70 | if(x==3){ 71 | cout<data<<" "; 72 | } 73 | free(T); 74 | } 75 | } 76 | 77 | -------------------------------------------------------------------------------- /5-2-3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAXSIZE 50 4 | #define DATATYPE int 5 | #define NOP -1 6 | //邻接表表示的图 无向图arcnum等于2×边数 7 | typedef struct ArcNode{ 8 | int value; 9 | int adjvex; 10 | struct ArcNode *next; 11 | }ArcNode,*Arc; 12 | typedef struct VNode{ 13 | ArcNode *next; 14 | DATATYPE data; 15 | }VNode,AdjList[MAXSIZE]; 16 | typedef struct{ 17 | AdjList vertices; 18 | int vexnum,arcnum; 19 | }Graph; 20 | void AddArc(Graph &G,int x,int y,int value){ 21 | Arc p,pre=NULL,s; 22 | for(p=G.vertices[x].next;p;pre=p,p=p->next){ 23 | if(p->adjvex==y)return; 24 | } 25 | s=(Arc)malloc(sizeof(ArcNode)); 26 | s->adjvex=y; 27 | s->value=value; 28 | s->next=NULL; 29 | if(pre)pre->next=s; 30 | else{ 31 | G.vertices[x].next=s; 32 | } 33 | } 34 | void InitGraph(Graph &g){ 35 | int vn,an,x=0,num1,num2,value; 36 | cin>>vn; 37 | cin>>an; 38 | g.vexnum=vn; 39 | g.arcnum=an; 40 | for(int i=0;i>num1; 45 | cin>>num2; 46 | cin>>value; 47 | AddArc(g,num1,num2,value); 48 | } 49 | } 50 | void PrintAdjList(Graph g){ 51 | Arc p,tmp; 52 | for(int i=0;iadjvex<<":"<value<<" "; 56 | tmp=p->next; 57 | free(p); 58 | p=tmp; 59 | } 60 | cout<next)Edge[i][p->adjvex]=p->value; 72 | } 73 | } 74 | void PrintEdge(Graph &g,int Edge[][MAXSIZE]){ 75 | for(int i=0;i 2 | #include 3 | using namespace std; 4 | #define MAXSIZE 50 5 | #define DATATYPE int 6 | //邻接表表示的图 无向图arcnum等于2×边数 7 | typedef struct ArcNode{ 8 | int value; 9 | int adjvex; 10 | struct ArcNode *next; 11 | }ArcNode,*Arc; 12 | typedef struct VNode{ 13 | ArcNode *next; 14 | DATATYPE data; 15 | }VNode,AdjList[MAXSIZE]; 16 | typedef struct{ 17 | AdjList vertices; 18 | int vexnum,arcnum; 19 | }Graph; 20 | void AddArc(Graph &G,int x,int y,int value){ 21 | Arc p,pre=NULL,s; 22 | for(p=G.vertices[x].next;p;pre=p,p=p->next){ 23 | if(p->adjvex==y)return; 24 | } 25 | s=(Arc)malloc(sizeof(ArcNode)); 26 | s->adjvex=y; 27 | s->value=value; 28 | s->next=NULL; 29 | if(pre)pre->next=s; 30 | else{ 31 | G.vertices[x].next=s; 32 | } 33 | } 34 | void InitGraph(Graph &g){ 35 | int vn,an,x=0,num1,num2,value; 36 | cin>>vn; 37 | cin>>an; 38 | g.vexnum=vn; 39 | g.arcnum=an; 40 | for(int i=0;i>num1; 45 | cin>>num2; 46 | cin>>value; 47 | AddArc(g,num1,num2,value); 48 | } 49 | } 50 | void PrintAdjList(Graph g){ 51 | Arc p,tmp; 52 | for(int i=0;iadjvex<<":"<value<<" "; 56 | tmp=p->next; 57 | free(p); 58 | p=tmp; 59 | } 60 | cout<adjvex; 65 | else return -1; 66 | } 67 | int NextNeighbor(Graph &G,int v,int w){ 68 | Arc p; 69 | for(p=G.vertices[v].next;p;p=p->next){ 70 | if(p->adjvex==w){ 71 | if(p->next){ 72 | return p->next->adjvex; 73 | }else return -1; 74 | } 75 | } 76 | return -1; 77 | } 78 | bool visted[MAXSIZE]; 79 | void BFS(Graph &G,int v){ 80 | queue q; 81 | cout< 2 | #include 3 | using namespace std; 4 | #define MAXSIZE 50 5 | #define DATATYPE int 6 | //邻接表表示的图 无向图arcnum等于2×边数 7 | typedef struct ArcNode{ 8 | int value; 9 | int adjvex; 10 | struct ArcNode *next; 11 | }ArcNode,*Arc; 12 | typedef struct VNode{ 13 | ArcNode *next; 14 | DATATYPE data; 15 | }VNode,AdjList[MAXSIZE]; 16 | typedef struct{ 17 | AdjList vertices; 18 | int vexnum,arcnum; 19 | }Graph; 20 | void AddArc(Graph &G,int x,int y,int value){ 21 | Arc p,pre=NULL,s; 22 | for(p=G.vertices[x].next;p;pre=p,p=p->next){ 23 | if(p->adjvex==y)return; 24 | } 25 | s=(Arc)malloc(sizeof(ArcNode)); 26 | s->adjvex=y; 27 | s->value=value; 28 | s->next=NULL; 29 | if(pre)pre->next=s; 30 | else{ 31 | G.vertices[x].next=s; 32 | } 33 | } 34 | void InitGraph(Graph &g){ 35 | int vn,an,x=0,num1,num2,value; 36 | cin>>vn; 37 | cin>>an; 38 | g.vexnum=vn; 39 | g.arcnum=an; 40 | for(int i=0;i>num1; 45 | cin>>num2; 46 | cin>>value; 47 | AddArc(g,num1,num2,value); 48 | } 49 | } 50 | void PrintAdjList(Graph g){ 51 | Arc p,tmp; 52 | for(int i=0;iadjvex<<":"<value<<" "; 56 | tmp=p->next; 57 | free(p); 58 | p=tmp; 59 | } 60 | cout<adjvex; 65 | else return -1; 66 | } 67 | int NextNeighbor(Graph &G,int v,int w){ 68 | Arc p; 69 | for(p=G.vertices[v].next;p;p=p->next){ 70 | if(p->adjvex==w){ 71 | if(p->next){ 72 | return p->next->adjvex; 73 | }else return -1; 74 | } 75 | } 76 | return -1; 77 | } 78 | bool visted[MAXSIZE]; 79 | void DFS(Graph &G,int v){ 80 | int p; 81 | cout< s; 90 | int p,w; 91 | s.push(v); 92 | visted[v]=true; 93 | while(!s.empty()){ 94 | w=s.top(); 95 | s.pop(); 96 | cout< 2 | #include 3 | using namespace std; 4 | #define MAXSIZE 50 5 | #define DATATYPE int 6 | //邻接表表示的图 无向图arcnum等于2×边数 7 | typedef struct ArcNode{ 8 | int value; 9 | int adjvex; 10 | struct ArcNode *next; 11 | }ArcNode,*Arc; 12 | typedef struct VNode{ 13 | ArcNode *next; 14 | DATATYPE data; 15 | }VNode,AdjList[MAXSIZE]; 16 | typedef struct{ 17 | AdjList vertices; 18 | int vexnum,arcnum; 19 | }Graph; 20 | void AddArc(Graph &G,int x,int y,int value){ 21 | Arc p,pre=NULL,s; 22 | for(p=G.vertices[x].next;p;pre=p,p=p->next){ 23 | if(p->adjvex==y)return; 24 | } 25 | s=(Arc)malloc(sizeof(ArcNode)); 26 | s->adjvex=y; 27 | s->value=value; 28 | s->next=NULL; 29 | if(pre)pre->next=s; 30 | else{ 31 | G.vertices[x].next=s; 32 | } 33 | } 34 | void InitGraph(Graph &g){ 35 | int vn,an,x=0,num1,num2,value; 36 | cin>>vn; 37 | cin>>an; 38 | g.vexnum=vn; 39 | g.arcnum=an; 40 | for(int i=0;i>num1; 45 | cin>>num2; 46 | cin>>value; 47 | AddArc(g,num1,num2,value); 48 | } 49 | } 50 | void PrintAdjList(Graph g){ 51 | Arc p,tmp; 52 | for(int i=0;iadjvex<<":"<value<<" "; 56 | tmp=p->next; 57 | free(p); 58 | p=tmp; 59 | } 60 | cout<adjvex; 65 | else return -1; 66 | } 67 | int NextNeighbor(Graph &G,int v,int w){ 68 | Arc p; 69 | for(p=G.vertices[v].next;p;p=p->next){ 70 | if(p->adjvex==w){ 71 | if(p->next){ 72 | return p->next->adjvex; 73 | }else return -1; 74 | } 75 | } 76 | return -1; 77 | } 78 | bool visted[MAXSIZE]; 79 | void BFS(Graph &G,int v){ 80 | queue q; 81 | cout<>x; 112 | cin>>y; 113 | DFS(G,x); 114 | cout< 2 | #include 3 | using namespace std; 4 | #define MAXSIZE 50 5 | #define DATATYPE int 6 | //邻接表表示的图 无向图arcnum等于2×边数 7 | typedef struct ArcNode{ 8 | int value; 9 | int adjvex; 10 | struct ArcNode *next; 11 | }ArcNode,*Arc; 12 | typedef struct VNode{ 13 | ArcNode *next; 14 | DATATYPE data; 15 | }VNode,AdjList[MAXSIZE]; 16 | typedef struct{ 17 | AdjList vertices; 18 | int vexnum,arcnum; 19 | }Graph; 20 | void AddArc(Graph &G,int x,int y,int value){ 21 | Arc p,pre=NULL,s; 22 | for(p=G.vertices[x].next;p;pre=p,p=p->next){ 23 | if(p->adjvex==y)return; 24 | } 25 | s=(Arc)malloc(sizeof(ArcNode)); 26 | s->adjvex=y; 27 | s->value=value; 28 | s->next=NULL; 29 | if(pre)pre->next=s; 30 | else{ 31 | G.vertices[x].next=s; 32 | } 33 | } 34 | void InitGraph(Graph &g){ 35 | int vn,an,x=0,num1,num2,value; 36 | cin>>vn; 37 | cin>>an; 38 | g.vexnum=vn; 39 | g.arcnum=an; 40 | for(int i=0;i>num1; 45 | cin>>num2; 46 | cin>>value; 47 | AddArc(g,num1,num2,value); 48 | } 49 | } 50 | void PrintAdjList(Graph g){ 51 | Arc p,tmp; 52 | for(int i=0;iadjvex<<":"<value<<" "; 56 | tmp=p->next; 57 | free(p); 58 | p=tmp; 59 | } 60 | cout<adjvex; 65 | else return -1; 66 | } 67 | int NextNeighbor(Graph &G,int v,int w){ 68 | Arc p; 69 | for(p=G.vertices[v].next;p;p=p->next){ 70 | if(p->adjvex==w){ 71 | if(p->next){ 72 | return p->next->adjvex; 73 | }else return -1; 74 | } 75 | } 76 | return -1; 77 | } 78 | bool visted[MAXSIZE]; 79 | void BFS(Graph &G,int v){ 80 | queue q; 81 | cout<