├── README.md ├── chapter06 ├── P206_4 ├── P206_4.cpp ├── P206_4.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P206_4 ├── P206_6 ├── P206_6.cpp ├── P206_6.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P206_6 ├── P217_2.cpp ├── P217_3.cpp ├── P217_4.cpp ├── P217_5.cpp └── P238_6.cpp ├── chapter07 ├── P264_5 ├── P264_5.cpp ├── P264_5.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P264_5 ├── P264_6 ├── P264_6.cpp ├── P264_6.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P264_6 ├── P285_6 ├── P285_6.cpp ├── P285_6.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P285_6 ├── P286_10 ├── P286_10.cpp ├── P286_10.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P286_10 ├── P286_11.cpp ├── P286_7 ├── P286_7.cpp ├── P286_7.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P286_7 ├── P286_8 ├── P286_8.cpp ├── P286_8.dSYM │ └── Contents │ │ ├── Info.plist │ │ └── Resources │ │ └── DWARF │ │ └── P286_8 ├── P286_9 ├── P286_9.cpp └── P286_9.dSYM │ └── Contents │ ├── Info.plist │ └── Resources │ └── DWARF │ └── P286_9 ├── chapter08 ├── P335_2.cpp ├── P335_3.cpp ├── P335_4.cpp ├── P335_5.cpp ├── P335_6.cpp ├── P335_7.cpp ├── P346_4.cpp ├── P346_5.cpp ├── P360_2.cpp ├── P360_3.cpp └── P360_4.cpp ├── chapter2 ├── 2_1_1.cpp ├── 2_1_10.cpp ├── 2_1_11.cpp ├── 2_1_12.cpp ├── 2_1_13.cpp ├── 2_1_14.cpp ├── 2_1_2.cpp ├── 2_1_3.cpp ├── 2_1_4.cpp ├── 2_1_5.cpp ├── 2_1_6.cpp ├── 2_1_7.cpp ├── 2_1_8.cpp ├── 2_1_9.cpp ├── 2_2_1.cpp ├── 2_2_10.cpp ├── 2_2_11.cpp ├── 2_2_12.cpp ├── 2_2_13.cpp ├── 2_2_14.cpp ├── 2_2_15.CPP ├── 2_2_16.cpp ├── 2_2_17.cpp ├── 2_2_18.cpp ├── 2_2_19.cpp ├── 2_2_2.cpp ├── 2_2_20.cpp ├── 2_2_21.cpp ├── 2_2_22.cpp ├── 2_2_23.cpp ├── 2_2_24.cpp ├── 2_2_25.cpp ├── 2_2_3.cpp ├── 2_2_4.cpp ├── 2_2_5.cpp ├── 2_2_6.cpp ├── 2_2_7.cpp ├── 2_2_8.cpp └── 2_2_9.cpp ├── chapter3 ├── P141-7.cpp ├── P66_3.cpp ├── P66_4.cpp ├── P66_5.cpp ├── P80_1.cpp ├── P80_2.cpp ├── P80_3.cpp ├── P80_4.cpp ├── P90_1.cpp ├── P90_2.cpp ├── P90_3.cpp ├── P90_4.cpp └── chapter3.zip └── chapter5 ├── P127_5.cpp ├── P141-7.cpp ├── P141_3.cpp ├── P141_4.cpp ├── P141_5.cpp ├── P141_6.cpp ├── P142_8.cpp ├── P142_9.cpp ├── P149_10.cpp ├── P149_11.cpp ├── P150_12.cpp ├── P150_13.cpp ├── P150_14.cpp ├── P150_15.cpp ├── P150_16.cpp ├── P150_17.cpp ├── P150_18.cpp ├── P150_19.cpp ├── P150_20.cpp ├── P175_4.cpp ├── P175_5.cpp └── P175_6.cpp /README.md: -------------------------------------------------------------------------------- 1 | # Data-Structure 2 | 王道数据结构课后编程题部分源码，仅供参考，重在实践！ 3 | -------------------------------------------------------------------------------- /chapter06/P206_4: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter06/P206_4 -------------------------------------------------------------------------------- /chapter06/P206_4.cpp: -------------------------------------------------------------------------------- 1 | //P206（4）写出从图的邻接表表示转换成邻接矩阵表示的算法。 2 | #include 3 | using namespace std; 4 | 5 | //邻接表存储结构 6 | //边表的结点 7 | typedef struct Arcnode{ 8 | //当前弧指向顶点的位置 9 | int adjvex; 10 | //指向下一条弧的指针 11 | struct Arcnode *next; 12 | }Arcnode; 13 | //顶点表结点 14 | typedef struct Vnode{ 15 | //顶点信息 16 | char data; 17 | //指向第一条依附该顶点的弧的指针 18 | Arcnode *first; 19 | }Vnode,AdjList[10]; 20 | 21 | //组合的邻接表 22 | typedef struct{ 23 | //邻接表 24 | AdjList v; 25 | //顶点数和弧数 26 | int vnum,arcnum; 27 | }ALGraph; 28 | 29 | //转换函数 30 | void Convert(ALGraph &G,int arcs[M][N]) 31 | { 32 | //用来取边 33 | Arcnode *p; 34 | //遍历每条顶点表结点为头的边链表 35 | for(int i=0;iadjvex]=1; 45 | //指向下一个结点 即取下一条边 46 | p=p->next; 47 | } 48 | } 49 | 50 | } 51 | int main() 52 | { 53 | 54 | return 0; 55 | } -------------------------------------------------------------------------------- /chapter06/P206_4.dSYM/Contents/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P206_4 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter06/P206_4.dSYM/Contents/Resources/DWARF/P206_4: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter06/P206_4.dSYM/Contents/Resources/DWARF/P206_4 -------------------------------------------------------------------------------- /chapter06/P206_6: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter06/P206_6 -------------------------------------------------------------------------------- /chapter06/P206_6.cpp: -------------------------------------------------------------------------------- 1 | //P206（6）判断图是否有EL路径 2 | #include 3 | using namespace std; 4 | //邻接矩阵存储的结构体 5 | typedef struct{ 6 | int numVertices,numEdges; 7 | char VerticesList[6]; 8 | int Edge[6][6]; 9 | }MGraph; 10 | int IsExistEL(MGraph G) 11 | { 12 | //度数和结果变量 13 | int degree,count=0; 14 | //遍历邻接矩阵 依次遍历每行 15 | for(int i=0;i>G.Edge[i][j]; 41 | cout< 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P206_6 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter06/P206_6.dSYM/Contents/Resources/DWARF/P206_6: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter06/P206_6.dSYM/Contents/Resources/DWARF/P206_6 -------------------------------------------------------------------------------- /chapter06/P217_2.cpp: -------------------------------------------------------------------------------- 1 | //P217（2）试设计一个算法，判断一个无向图G是否为一-棵树。若是一-棵树，则算法返回true,否则返回false. 2 | 3 | //DFS 4 | void DFS(Graph &G,int v,int &Vnum,int &Enum,int visited[]) 5 | { 6 | visited[v]=true;//访问过 7 | Vnum++;//顶点数+1 8 | int w=FirstNeighbor(G,v); 9 | while(w!=-1) 10 | { 11 | //第一个邻接结点存在 存在边 12 | Enum++;//边+1 13 | if(!visited[w])//该邻接点有没有访问过 14 | DFS(G,W,Vnum,Enum,visited);//继续遍历 15 | w=NextNeighbor(G,v,w);//找下一个邻接点 16 | } 17 | } 18 | 19 | //判断是否是树 20 | bool istree() 21 | { 22 | //顶点数 边数 23 | int Vnum=0,Enum=0; 24 | //访问标记数组 25 | bool visited[Max]; 26 | for(int i=0;i=0;w=NextNeighbor(G,k,w)) 24 | { 25 | //没有进过栈的话进栈 26 | if(!visited[w]) 27 | { 28 | Push(S,w); 29 | visited[w]=true; 30 | } 31 | } 32 | } 33 | } -------------------------------------------------------------------------------- /chapter06/P217_4.cpp: -------------------------------------------------------------------------------- 1 | //P217（4）分别采用基于深度优先遍历和广度优先遍历算法判别以邻接表方式存储的有向图中是否存在由顶点v;到顶点y的路径(i#j).注意，算法中涉及的图的基本操作必须在此存储结构上实现。 2 | 3 | //visited数组 4 | int visited[Max]; 5 | //DFS 6 | void DFS(ALGraph G,int i,int j,bool &isok) 7 | { 8 | //如果当前结点就是j结点 9 | if(i==j) 10 | { 11 | //isok赋值 并退出函数 12 | isok=true; 13 | return; 14 | } 15 | //否则更新访问标记 16 | visited[i]=1; 17 | //遍历邻接点 向后延伸 18 | for(int p=FirstNeighbor(G,i);p>=0;p=NextNeighbor(G,i,p)) 19 | { //没有找到j点并且该点没有访问过 继续DFS遍历 20 | if(!visited[p]&&!isok) DFS(G,p,j,isok); 21 | } 22 | } 23 | 24 | //BFS 25 | int BFS(ALGraph G,int i,int j) 26 | { 27 | //初始化队 28 | InitQueue(Q); 29 | //顶点入队 30 | EnQueue(Q,i); 31 | //循环体 遍历队 32 | while(!isempty(Q)) 33 | { 34 | //出队 保留出队元素 35 | Dequeue(Q,u); 36 | //更新访问标记 37 | visited[u]=1; 38 | //如果当前点为j 即返回 39 | if(u==j) return 1; 40 | //否则遍历邻接点 41 | for(int p=FirstNeighbor(G,i);p>=0;p=NextNeighbor(G,i,p)) 42 | { 43 | //再次判断是否为j点 44 | if(p==j) return 1; 45 | //是的话返回 46 | //不是 将邻接点入队 47 | if(!visited[p]) 48 | { 49 | Enqueue(Q,p); 50 | visited[p]=1; 51 | //更新访问标记 52 | } 53 | 54 | } 55 | } 56 | return 0; 57 | } -------------------------------------------------------------------------------- /chapter06/P217_5.cpp: -------------------------------------------------------------------------------- 1 | //P217（5）假设图用邻接表表示，设计一个算法，输出从顶点Vi到顶点Vj的所有简单路径。 2 | 3 | void FindPath(AGraph *G,int u,int v,int path[],int d) 4 | { 5 | //添加当前结点到路径当中 首先路径要+1 再加入结点 6 | d++; 7 | path[d]=u; 8 | //这时候当前结点访问过 9 | visited[u]=1; 10 | //如果该点为路径终点 就输出 11 | if(u==v) cout<adjlist[u].firstarc; 14 | //不断去访问相邻点的下一个邻接点 往深处去搜索 15 | while(p!=NULL) 16 | { 17 | //获取当前的邻接点的弧所指向顶点的位置 18 | int w=p->adjvex; 19 | //如果这个点没有访问过 递归地去往下找 20 | if(visited[w]==0) 21 | FindPath(G,w,v,path,d); 22 | //之后p后移 23 | p=p->nextarc; 24 | } 25 | //为了该点可以重新使用 visit=0 26 | visited[u]=0; 27 | } -------------------------------------------------------------------------------- /chapter06/P238_6.cpp: -------------------------------------------------------------------------------- 1 | //P238（6）试说明利用DFS如何实现有向无环图拓扑排序。 2 | int finishtime[Max]; 3 | //访问的标记数组 4 | bool visited[Max]; 5 | void DFS(Graph G,int v) 6 | { 7 | //访问当前结点 8 | visited[v]=true; 9 | visit(v); 10 | //深度遍历邻接结点 11 | for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)) 12 | { 13 | if(!visited[w]) DFS(G,W); 14 | } 15 | //时间存储 16 | time++; 17 | finishtime[v]=time; 18 | } 19 | void DFSTraverse(Graph G) 20 | { 21 | //初始化标记数组 22 | for(int i=0;i 2 | using namespace std; 3 | typedef struct{ 4 | int a[10]={0,1,2,3,4,5,6,7,8}; 5 | int length=8; 6 | }ST; 7 | int Bin(ST s,int ans,int low,int high) 8 | { 9 | //递归条件 10 | if(low>high) return 0; 11 | //求出中间下标 12 | int mid=(low+high)/2; 13 | //中间值小了 到右边进行查找 14 | if(ans>s.a[mid]) return Bin(s,ans,mid+1,high); 15 | //中间值大了 到左边进行查找 16 | else if(ans 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P264_5 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter07/P264_5.dSYM/Contents/Resources/DWARF/P264_5: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P264_5.dSYM/Contents/Resources/DWARF/P264_5 -------------------------------------------------------------------------------- /chapter07/P264_6: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P264_6 -------------------------------------------------------------------------------- /chapter07/P264_6.cpp: -------------------------------------------------------------------------------- 1 | //P264（6）线性表中各结点的检索概率不等时，可用如下策略提高顺序检索的效率:若找到指定的结点，则将该结点和其前驱结点(若存在)交换，使得经常被检索的结点尽量位于表的前端。 2 | //试设计在顺序结构和链式结构的线性表上实现上述策略的顺序检索算法。P264（6）线性表中各结点的检索概率不等时，可用如下策略提高顺序检索的效率:若找到指定的结点， 3 | //则将该结点和其前驱结点(若存在)交换，使得经常被检索的结点尽量位于表的前端。试设计在顺序结构和链式结构的线性表上实现上述策略的顺序检索算法。 4 | #include 5 | using namespace std; 6 | //置前函数 7 | int Search(int a[],int n,int k) 8 | { 9 | //遍历 10 | int i; 11 | for(i=0;i0&&i 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P264_6 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter07/P264_6.dSYM/Contents/Resources/DWARF/P264_6: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P264_6.dSYM/Contents/Resources/DWARF/P264_6 -------------------------------------------------------------------------------- /chapter07/P285_6: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P285_6 -------------------------------------------------------------------------------- /chapter07/P285_6.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | //树结点的存储结构 4 | typedef struct treenode{ 5 | //结点的值 6 | char data; 7 | //左右孩子指针 8 | struct treenode *lchild,*rchild; 9 | }treenode,*tree; 10 | //建树 11 | void buildtree(tree &t) 12 | { 13 | char ch; 14 | cin>>ch; 15 | if(ch=='#') t=NULL; 16 | else 17 | { 18 | //分配内存 19 | t=(treenode *)malloc(sizeof(treenode)); 20 | //赋值 21 | t->data=ch; 22 | //初始化 23 | t->lchild=NULL; 24 | t->rchild=NULL; 25 | //递归去赋值 26 | buildtree(t->lchild); 27 | buildtree(t->rchild); 28 | } 29 | } 30 | //中序遍历二叉树是否是二叉排序树 31 | 32 | //初始化前驱值 33 | int pre=-35555; 34 | int isok(tree t) 35 | { 36 | //先判断树是否为空 37 | if(t==NULL) return 1; 38 | else 39 | { 40 | //递归求左子树是否是二叉排序树 41 | int b1=isok(t->lchild); 42 | //判断左子树的值和当前结点与前驱结点值的比较 43 | if(b1==0||((t->data)-'0')<=pre) return 0; 44 | //将当前结点作为下一个前驱结点 保存下来 45 | pre=(t->data)-'0'; 46 | //递归求右子树的值 47 | return isok(t->rchild); 48 | //返回 49 | } 50 | } 51 | //测试 52 | int main() 53 | { 54 | tree t; 55 | buildtree(t); 56 | cout< 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P285_6 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter07/P285_6.dSYM/Contents/Resources/DWARF/P285_6: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P285_6.dSYM/Contents/Resources/DWARF/P285_6 -------------------------------------------------------------------------------- /chapter07/P286_10: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_10 -------------------------------------------------------------------------------- /chapter07/P286_10.cpp: -------------------------------------------------------------------------------- 1 | //P286（10）设计-一个算法，从大到小输出二叉排序树中所有值不小于k的关键字。 2 | #include 3 | using namespace std; 4 | //树结点的存储结构 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //分配空间 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //赋值 22 | t->data=ch; 23 | //初始化 24 | t->lchild=NULL; 25 | t->rchild=NULL; 26 | //递归去赋值 27 | buildtree(t->lchild); 28 | buildtree(t->rchild); 29 | } 30 | } 31 | //输出>=k的关键字 32 | void disp(tree t,char k) 33 | { 34 | //空树 35 | if(t==NULL) return; 36 | //右子树 37 | if(t->rchild!=NULL) 38 | disp(t->rchild,k); 39 | //根输出 40 | if(t->data>=k) cout<data<<" "; 41 | //左子树 42 | if(t->lchild!=NULL) 43 | disp(t->lchild,k); 44 | } 45 | int main() 46 | { 47 | 48 | tree t; 49 | buildtree(t); 50 | disp(t,'E'); 51 | return 0; 52 | } 53 | /* F 54 | E H 55 | C G I 56 | A D 57 | B 58 | FECA#B##D###HG##I## 59 | */ -------------------------------------------------------------------------------- /chapter07/P286_10.dSYM/Contents/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P286_10 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter07/P286_10.dSYM/Contents/Resources/DWARF/P286_10: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_10.dSYM/Contents/Resources/DWARF/P286_10 -------------------------------------------------------------------------------- /chapter07/P286_11.cpp: -------------------------------------------------------------------------------- 1 | //P286（11）编写-一个递归算法，在一棵有n个结点的、随机建立起来的二叉排序树上查找第k(1≤k≤n)小的元素，并返回指向该结点的指针。 2 | //要求算法的平均时间复杂度为0(log2n).二叉排序树的每个结点中除data, lchild, rchild 等数据成员外，增加一-个count成员，保存以该结点为根的子树上的结点个数。 3 | 4 | 5 | //存储结构 6 | typedef struct treenode{ 7 | //结点值 8 | char data; 9 | //左右孩子指针 10 | struct treenode *lchild,*rchild; 11 | //子树包括根的所有结点个数 12 | int count; 13 | }treenode,*tree; 14 | //第k小元素 15 | treenode *min_k(tree t,int k) 16 | { 17 | //k合法条件 18 | if(k<1||k>t->count) return NULL; 19 | //左子树空的情况 20 | if(t->lchild==NULL) 21 | { 22 | //k=1就是根结点 23 | if(k==1) return t; 24 | //k不为1 就是到右子树中找第k-1小 根结点已考虑 25 | else min_k(t->rchild,k-1); 26 | } 27 | //左子树不为空 28 | else 29 | { 30 | //左子树结点个数为k-1 结果就是根结点 31 | if(t->lchild->count==k-1) return t; 32 | //左子树结点个数>k-1 在左子树中找第k小 33 | if(t->lchild->count>k-1) return min_k(t->lchild,k); 34 | //左子树结点个数lchild->countrchild,k-(t->lchild->count+1)); 36 | } 37 | } 38 | 39 | -------------------------------------------------------------------------------- /chapter07/P286_7: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_7 -------------------------------------------------------------------------------- /chapter07/P286_7.cpp: -------------------------------------------------------------------------------- 1 | //P286（7）设计一个算法，求出指定结点在给定二叉排序树中的层次。 2 | #include 3 | using namespace std; 4 | //树结点的存储结构 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else{ 18 | //分配空间 19 | t=(treenode *)malloc(sizeof(treenode)); 20 | //赋值 21 | t->data=ch; 22 | //初始化 23 | t->lchild=NULL; 24 | t->rchild=NULL; 25 | //递归去赋值左右子树的结点 26 | buildtree(t->lchild); 27 | buildtree(t->rchild); 28 | } 29 | } 30 | //找层次 31 | int level(tree t,treenode *p) 32 | { 33 | //层数初始化 34 | int n=0; 35 | //遍历树的结点 36 | treenode *tt=t; 37 | //树不空的话 根结点层数+1 38 | if(t!=NULL) 39 | { 40 | n++; 41 | //循环条件是当前结点的值不为要找的那个值 42 | while(tt->data!=p->data) 43 | { 44 | if(tt->data>p->data)//当前结点值大了 结点指向左孩子 45 | tt=tt->lchild; 46 | else tt=tt->rchild; //当前结点小了 结点指向右孩子 47 | n++;//同时层数+1 48 | } 49 | } 50 | //最后返回层数 51 | return n; 52 | } 53 | int main() 54 | { 55 | tree t; 56 | buildtree(t); 57 | cout<lchild->lchild->lchild->rchild)< 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P286_7 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter07/P286_7.dSYM/Contents/Resources/DWARF/P286_7: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_7.dSYM/Contents/Resources/DWARF/P286_7 -------------------------------------------------------------------------------- /chapter07/P286_8: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_8 -------------------------------------------------------------------------------- /chapter07/P286_8.cpp: -------------------------------------------------------------------------------- 1 | //P286（8）利用二叉树遍历的思想编写一个判断二叉树是否是平衡二叉树的算法。 2 | #include 3 | using namespace std; 4 | //树结点的存储结构 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else{ 18 | //分配空间 19 | t=(treenode *)malloc(sizeof(treenode)); 20 | //赋值 21 | t->data=ch; 22 | //初始化 23 | t->lchild=NULL; 24 | t->rchild=NULL; 25 | //递归赋值 26 | buildtree(t->lchild); 27 | buildtree(t->rchild); 28 | } 29 | } 30 | //后序遍历 判断是否是平衡二叉树 31 | void isAVL(tree t,int &ba,int &h) 32 | { 33 | //左右子树的高度 平衡因子变量 34 | int h1,h2,b1,b2; 35 | //空树 高度为0 平衡因子为1 36 | if(t==NULL) 37 | { 38 | h=0; 39 | ba=1; 40 | } 41 | //只有一个根结点 高度为1 平衡因子为1 42 | else if(t->lchild==NULL&&t->rchild==NULL) 43 | { 44 | h=1; 45 | ba=1; 46 | } 47 | else 48 | { 49 | //递归判断左子树 50 | isAVL(t->lchild,ba,h); 51 | //递归判断右子树 52 | isAVL(t->rchild,ba,h); 53 | //到根这里 更新树高 54 | h=max(h1,h2)+1; 55 | //判断左右子树高度绝对值之差 56 | if(abs(h1-h2)<=1) 57 | { 58 | ba=b1&&b2; 59 | } 60 | //判断左右子树平衡因子 61 | else ba=0; 62 | } 63 | } 64 | int main() 65 | { 66 | 67 | tree t; 68 | buildtree(t); 69 | int ba,h; 70 | isAVL(t,ba,h); 71 | cout< 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P286_8 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter07/P286_8.dSYM/Contents/Resources/DWARF/P286_8: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_8.dSYM/Contents/Resources/DWARF/P286_8 -------------------------------------------------------------------------------- /chapter07/P286_9: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_9 -------------------------------------------------------------------------------- /chapter07/P286_9.cpp: -------------------------------------------------------------------------------- 1 | //P286（8）利用二叉树遍历的思想编写一个判断二叉树是否是平衡二叉树的算法。 2 | #include 3 | using namespace std; 4 | //树结点的存储结构 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else{ 18 | //分配空间 19 | t=(treenode *)malloc(sizeof(treenode)); 20 | //赋值 21 | t->data=ch; 22 | //初始化 23 | t->lchild=NULL; 24 | t->rchild=NULL; 25 | //递归赋值 26 | buildtree(t->lchild); 27 | buildtree(t->rchild); 28 | } 29 | } 30 | //二叉排序树中最小关键字 31 | char Min(tree t) 32 | { 33 | while(t->lchild!=NULL) 34 | { 35 | t=t->lchild; 36 | } 37 | return t->data; 38 | } 39 | //二叉排序树中最大关键字 40 | char Max(tree t) 41 | { 42 | while(t->rchild!=NULL) 43 | { 44 | t=t->rchild; 45 | } 46 | return t->data; 47 | } 48 | int main() 49 | { 50 | 51 | tree t; 52 | buildtree(t); 53 | cout< 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | English 7 | CFBundleIdentifier 8 | com.apple.xcode.dsym.P286_9 9 | CFBundleInfoDictionaryVersion 10 | 6.0 11 | CFBundlePackageType 12 | dSYM 13 | CFBundleSignature 14 | ???? 15 | CFBundleShortVersionString 16 | 1.0 17 | CFBundleVersion 18 | 1 19 | 20 | 21 | -------------------------------------------------------------------------------- /chapter07/P286_9.dSYM/Contents/Resources/DWARF/P286_9: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/littlefish-Max/Data-Structure/30a682a34f9d498b3d03f6985948f35b59a0bbdc/chapter07/P286_9.dSYM/Contents/Resources/DWARF/P286_9 -------------------------------------------------------------------------------- /chapter08/P335_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | //双向冒泡 4 | void bsort(int a[],int n) 5 | { 6 | //范围的左右两端 7 | int low=0,high=n-1; 8 | //一趟是否交换过 初始化 9 | bool flag=true; 10 | //循环条件 左端<右端并且一趟有交换 11 | while(lowa[i+1]) 19 | { 20 | swap(a[i],a[i+1]); 21 | flag=true; 22 | } 23 | } 24 | high--; 25 | //从后向前交换 26 | for(int i=high;i>low;i--) 27 | { 28 | if(a[i] 3 | using namespace std; 4 | void Move(int a[],int n) 5 | { 6 | //查找范围的左右两端 7 | int i=0,j=n-1; 8 | //循环遍历条件 9 | while(i 3 | using namespace std; 4 | void Partition2(int a[],int low,int high) 5 | { 6 | //获取随机下标 7 | int root=low+rand()%(high-low+1); 8 | //交换到第一个 9 | swap(a[low],a[root]); 10 | //i一开始指向low位置 11 | int i=low; 12 | //从第二个开始遍历到结束 13 | int p=a[low]; 14 | for(int j=low+1;j<=high;j++) 15 | { 16 | //如果小于基准值 17 | if(a[j] 2 | using namespace std; 3 | int min_k(int a[],int low,int high,int k) 4 | { 5 | //快速排序划分算法 6 | //i一开始指向low位置 7 | int i=low; 8 | //从第二个开始遍历到结束 9 | int p=a[low]; 10 | for(int j=low+1;j<=high;j++) 11 | { 12 | //如果小于基准值 13 | if(a[j]k) return min_k(a,low,i-1,k); 23 | //若最后基准的位置>k的话 则在基准左边递归去找 24 | else return min_k(a,i+1,high,k); 25 | //若最后基准的位置 3 | using namespace std; 4 | 5 | //按照负数0 正数来排数组 6 | void num(int a[],int n) 7 | { 8 | //三个指针的指向 初始化 9 | int i=0,j=0,k=n-1; 10 | //循环体 j<=k 11 | while(j<=k) 12 | { 13 | int v; 14 | if(a[j]>0) v=1; 15 | else if(a[j]==0) v=0; 16 | else v=-1; 17 | //switch判断a[j]的值 18 | switch (v) 19 | { 20 | //负数 和i交换 21 | case -1:swap(a[i],a[j]);i++;j++;break; 22 | //0 遍历指针+1 23 | case 0:j++;break; 24 | //正数 和k交换 25 | case 1:swap(a[j],a[k]);k--;break; 26 | } 27 | } 28 | } 29 | int main() 30 | { 31 | int a[9]={0,-1,-2,0,0,3,-4,1}; 32 | num(a,8); 33 | for(int i=0;i<8;i++) 34 | cout< 3 | using namespace std; 4 | 5 | //快排 6 | void seta(int a[],int n,int low,int high) 7 | { 8 | //非递归 9 | int flag=1; 10 | //取中间值 后面与基准值进行比较 11 | int k=(high-low)/2; 12 | //非递归条件 13 | while(flag) 14 | { 15 | //快排 16 | //i一开始指向low位置 17 | int i=low; 18 | //从第二个开始遍历到结束 19 | int p=a[low]; 20 | for(int j=low+1;j<=high;j++) 21 | { 22 | //如果小于基准值 23 | if(a[j] 3 | using namespace std; 4 | //链表存储结构 5 | typedef struct lnode{ 6 | int data; 7 | struct lnode *next; 8 | }lnode,*linklist; 9 | int a[10]={7,5,9,2,6,4,3,8,1}; 10 | int n=9; 11 | //建立链表 不带头结点 12 | void buildlist(lnode *L) 13 | { 14 | lnode *s,*r=L; 15 | r->data=a[0]; 16 | if(n==1) r->next=NULL; 17 | else{ 18 | for(int i=1;idata=a[i]; 22 | r->next=s; 23 | r=r->next; 24 | } 25 | r->next=NULL; 26 | } 27 | } 28 | //输出链表 29 | void disp(linklist L) 30 | { 31 | lnode *s=L; 32 | while(s) 33 | { 34 | cout<data<<" "; 35 | s=s->next; 36 | } 37 | cout<data>s->data) 58 | { 59 | //更新最大结点位置 60 | s=p; 61 | //更新最大结点的前驱 62 | r=q; 63 | } 64 | q=p; 65 | p=p->next; 66 | //工作指针向后遍历时前驱指针和工作指针向后移 67 | } 68 | 69 | //若最大的是表头 将遍历表的指针后移 70 | 71 | if(s==h) h=h->next; 72 | else 73 | { 74 | r->next=s->next; 75 | } 76 | //插入结果链表当中 77 | s->next=l; 78 | //更新结果链表的头 79 | l=s; 80 | 81 | } 82 | } 83 | int main() 84 | { 85 | lnode L; 86 | lnode *l=&L; 87 | buildlist(l); 88 | selectsort(l); 89 | disp(l); 90 | return 0; 91 | } -------------------------------------------------------------------------------- /chapter08/P346_5.cpp: -------------------------------------------------------------------------------- 1 | //P346（5）试设计一个算法，判断-一个数据序列是否构成一个小根堆。 2 | #include 3 | using namespace std; 4 | //判断是不是小根堆 5 | int is_min(int a[],int len) 6 | { 7 | //最后的序号为偶数 8 | if(len%2==0) 9 | { 10 | //判断单枝结点 11 | if(a[len/2]>a[len]) return 0; 12 | //判断双支结点 13 | for(int i=len/2-1;i>=1;i--) 14 | { 15 | if(a[i]>a[2*i]||a[i]>a[2*i+1]) 16 | return 0; 17 | } 18 | } 19 | else 20 | { 21 | //为奇数 22 | for(int i=len/2;i>=1;i--) 23 | { 24 | //判断双支结点 25 | if(a[i]>a[i*2]||a[i]>a[i*2+1]) 26 | return 0; 27 | } 28 | } 29 | return 1; 30 | } 31 | int main() 32 | { 33 | int a[8]={1,1,3,2,5,4,0}; 34 | cout< 3 | using namespace std; 4 | void insertsort(int a[],int m,int n) 5 | { 6 | //两个遍历指针 7 | int i,j; 8 | //第一个遍历范围 9 | for(i=m+1;i<=m+n;i++) 10 | { 11 | //复制哨兵 12 | a[0]=a[i]; 13 | for(j=i-1;a[j]>a[0];j--) 14 | { 15 | a[j+1]=a[j]; 16 | //后移 17 | } 18 | a[j+1]=a[0]; 19 | //插入哨兵值 20 | } 21 | } 22 | int main() 23 | { 24 | int a[8]={0,1,3,5,7,2,4,9}; 25 | insertsort(a,4,3); 26 | for(int i=1;i<=7;i++) cout< 2 | using namespace std; 3 | void countsort(int a[],int b[],int n) 4 | { 5 | //遍历每一趟 6 | int count=0; 7 | for(int i=0;i 2 | using namespace std; 3 | int quicksort(int a[],int low,int high) 4 | { 5 | //i一开始指向high位置 6 | int i=high; 7 | //从倒数二个开始遍历到头 8 | int p=a[high]; 9 | for(int j=high-1;j>=0;j--) 10 | { 11 | //如果大于基准值 12 | if(a[j]>p) swap(a[--i],a[j]); 13 | //交换到后面去 14 | } 15 | //将基准元素插入到最终的位置 16 | swap(a[high],a[i]); 17 | //返回基准元素的位置 18 | return i; 19 | } 20 | int main() 21 | { 22 | int a[5]={3,5,7,2,4}; 23 | cout< 6 | using namespace std; 7 | #define Max 50 8 | struct SqList{ 9 | int a[Max]={}; 10 | int length=0; 11 | }; 12 | bool listdelete(SqList &s,int &ele) 13 | { 14 | if(s.length==0) 15 | return false; 16 | int minn=s.a[0]; 17 | int flag=0; 18 | for(int i=1;i 3 | using namespace std; 4 | 5 | int a[7]={1,2,3,4,5,6,7}; 6 | int n=7; 7 | void reverse(int a[],int l,int r) 8 | { 9 | for(int i=l;i<=(l+r)/2;i++) 10 | { 11 | int t=a[i]; 12 | a[i]=a[(l+r)-i]; 13 | a[(l+r)-i]=t; 14 | } 15 | } 16 | void prin(int a[]) 17 | { 18 | for(int i=0;i 3 | using namespace std; 4 | int a[5]={11,13,15,17,19}; 5 | int b[5]={2,4,6,8,20}; 6 | int c[10]; 7 | int verge(int a[],int b[],int c[]) 8 | { 9 | int i=0,j=0,k=0; 10 | while(i<5&&j<5) 11 | { 12 | if(a[i]<=b[j]) c[k++]=a[i++]; 13 | else c[k++]=b[j++]; 14 | } 15 | while(i<5) c[k++]=a[i++]; 16 | while(j<5) c[k++]=b[j++]; 17 | return c[(k-1)/2]; 18 | } 19 | int main() 20 | { 21 | int t=verge(a,b,c); 22 | for(int i=0;i<10;i++) cout< 3 | using namespace std; 4 | int a[8]={0,5,5,3,5,7,5,5}; 5 | int a1[8]={0,5,5,3,5,1,5,7}; 6 | int n=8; 7 | 8 | bool half(int a[],int &cc) 9 | { 10 | int c=a[0],count=1; 11 | for(int i=1;i0) count--; 16 | else { 17 | c=a[i]; 18 | count=1; 19 | } 20 | } 21 | } 22 | int k=0; 23 | for(int i=0;in/2) { cc=c;return true;} 25 | else return false; 26 | } 27 | 28 | bool hashmapp(int a[],int &cc) 29 | { 30 | mapmp; 31 | for(int i=0;icount) 36 | { 37 | c=v.first; 38 | count=v.second; 39 | } 40 | } 41 | if(count>n/2) 42 | { 43 | cc=c; 44 | return true; 45 | } 46 | else return false; 47 | } 48 | int main() 49 | { 50 | int cc; 51 | // if(half(a1,cc)) cout<<"主元素为 "< 3 | using namespace std; 4 | int a[4]={1,2,4,3}; 5 | int n=4; 6 | int findmin(int a[]) 7 | { 8 | int b[n+2]={0}; 9 | for(int i=0;i0&&a[i]<=n+1) b[a[i]]=1; 12 | } 13 | int ans=0; 14 | for(int i=1;i 3 | using namespace std; 4 | #define Max 0x7fffffff 5 | int abss(int a) 6 | { 7 | if(a<0) return -a; 8 | else return a; 9 | } 10 | bool minn(int a,int b,int c) 11 | { 12 | if(min(a,min(b,c))==a) return true; 13 | return false; 14 | } 15 | int findd(int a[],int b[],int c[],int na,int nb,int nc) 16 | { 17 | int i=0,j=0,k=0,ans=Max; 18 | while(i=0) 19 | { 20 | int v=abs(a[i]-b[j])+abs(b[j]-c[k])+abs(c[k]-a[i]); 21 | if(v 3 | using namespace std; 4 | #define Max 50 5 | struct SqList{ 6 | int a[Max]={1,4,6,3,2,8,7}; 7 | int length=7; 8 | }; 9 | void reverse(SqList &L) 10 | { 11 | for(int i=0;i 2 | using namespace std; 3 | #define Max 50 4 | struct SqList 5 | { 6 | /* data */ 7 | int a[Max]={5,2,0,1,3,1,4,1,1,4}; 8 | int length=10; 9 | }; 10 | void deletelist(SqList &L,int x) 11 | { 12 | int k=0; 13 | for(int i=0;i 3 | using namespace std; 4 | #define Max 50 5 | struct sqlist{ 6 | int a[Max]={1,2,3,3,4,5,6,7,7,7,8,9}; 7 | int length=12; 8 | }; 9 | bool deletesqlist(sqlist &L,int s,int v) 10 | { 11 | if(s>=v||L.length==0) return false; 12 | int ss=0; 13 | bool flag=false; 14 | for(int i=0;i=s) 17 | { 18 | ss=i; 19 | flag=true; 20 | break; 21 | } 22 | } 23 | if(!flag) return false; 24 | int vv=0; 25 | for(int i=ss;iv) 28 | { 29 | vv=i; 30 | break; 31 | } 32 | } 33 | int s1=ss,v1=vv; 34 | for(int i=vv;i 2 | using namespace std; 3 | #define Max 50 4 | struct sqlist{ 5 | int a[Max]={4,1,2,5,0,0,3}; 6 | int length=7; 7 | }; 8 | bool deletesqlist(sqlist &L,int s,int v) 9 | { 10 | if(L.length==0||s>=v) return false; 11 | int k=0; 12 | bool flag=false; 13 | for(int i=0;i=s) { 16 | flag=true;break; 17 | } 18 | } 19 | if(!flag) return false; 20 | for(int i=0;i=s&&L.a[i]<=v) k++; 23 | else L.a[i-k]=L.a[i]; 24 | } 25 | L.length=L.length-k; 26 | return true; 27 | } 28 | int main() 29 | { 30 | sqlist L; 31 | for(int i=0;i 2 | using namespace std; 3 | #define Max 50 4 | struct sqlist{ 5 | int a[Max]={2,2,3,3,3,5,6,6,7}; 6 | int length=9; 7 | }; 8 | void deletelist(sqlist &L) 9 | { 10 | int black=1; 11 | for(int red=1;red 3 | using namespace std; 4 | #define Max 50 5 | struct sqlist{ 6 | int data[Max]; 7 | int length; 8 | }; 9 | bool verge(sqlist a,sqlist b,sqlist &c) 10 | { 11 | if(c.length 4 | using namespace std; 5 | #define Max 50 6 | struct sqlist{ 7 | int a[Max]={1,2,3,4,5,6,7}; 8 | int length=7; 9 | }; 10 | void reverse(sqlist &L,int left,int right) 11 | { 12 | for(int i=left;i<=(right+left)/2;i++) 13 | { 14 | int t=L.a[i]; 15 | L.a[i]=L.a[right+left-i]; 16 | L.a[right+left-i]=t; 17 | } 18 | } 19 | void prin(sqlist L) 20 | { 21 | for(int i=0;i 3 | using namespace std; 4 | int a[10]={1,2,3,4,5,7,8,9,10}; 5 | int n=9; 6 | void findd(int a[],int x) 7 | { 8 | int left,right,mid; 9 | left=0,right=n-1; 10 | while(left<=right) 11 | { 12 | mid=(left+right)/2; 13 | if(a[mid]==x) break; 14 | else if(a[mid]>x) right=mid-1; 15 | else left=mid+1; 16 | } 17 | if(a[mid]==x&&mid!=n-1) 18 | { 19 | int t=a[mid]; 20 | a[mid]=a[mid+1]; 21 | a[mid+1]=t; 22 | } 23 | if(rightright;i--) 26 | { 27 | a[i+1]=a[i]; 28 | } 29 | a[i+1]=x; 30 | } 31 | } 32 | int main() 33 | { 34 | for(int i=0;i<9;i++) cout< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode; 8 | int a[4]={1,3,3,4}; 9 | int n=4; 10 | void buildlist(lnode *L) 11 | { 12 | lnode *s,*r=L; 13 | r->data=a[0]; 14 | if(n==1) r->next=NULL; 15 | else{ 16 | for(int i=1;idata=a[i]; 20 | r->next=s; 21 | r=r->next; 22 | } 23 | r->next=NULL; 24 | } 25 | } 26 | void disp(lnode *L) 27 | { 28 | lnode *s=L; 29 | while(s) 30 | { 31 | cout<<(s->data)<<" "; 32 | s=s->next; 33 | } 34 | cout<data==x) 41 | { 42 | p=L; 43 | L=L->next; 44 | free(p); 45 | deletex(L,x); 46 | } 47 | else deletex(L->next,x); 48 | } 49 | int main() 50 | { 51 | lnode list; 52 | lnode *L=&list; 53 | buildlist(L); 54 | disp(L); 55 | deletex(L,3); 56 | disp(L); 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /chapter2/2_2_10.cpp: -------------------------------------------------------------------------------- 1 | //分链表 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[5]={2,7,4,1,9}; 9 | int n=5; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *r=L,*s; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next=NULL; 38 | lnode *r1=L1,*r2=L2,*p=L1->next; 39 | int i=0; 40 | L1->next=NULL; 41 | while(p) 42 | { 43 | i++; 44 | if(i%2==0) 45 | { 46 | r2->next=p; 47 | r2=p; 48 | } 49 | else 50 | { 51 | r1->next=p; 52 | r1=p; 53 | } 54 | p=p->next; 55 | } 56 | r1->next=NULL; 57 | r2->next=NULL; 58 | } 59 | int main() 60 | { 61 | linklist L1; 62 | buildlist(L1); 63 | cout<<"之前"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[10]={1,2,3,4,5,6,7,8,9,10}; 9 | int n=10; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next=NULL; 38 | lnode *p=L1->next,*q,*r=L1; 39 | while(p) 40 | { 41 | r->next=p; 42 | r=p; 43 | p=p->next; 44 | if(p!=NULL) q=p->next; 45 | p->next=L2->next; 46 | L2->next=p; 47 | p=q; 48 | } 49 | r->next=NULL; 50 | } 51 | int main() 52 | { 53 | linklist L1; 54 | buildlist(L1); 55 | cout<<"一开始L1"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[10]={1,2,3,5,6,6,7,7,9,10}; 9 | int n=10; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next==NULL) return; 36 | lnode *p=L->next,*q; 37 | while(p->next!=NULL) 38 | { 39 | q=p->next; 40 | if(p->data==q->data) 41 | { 42 | p->next=q->next; 43 | free(q); 44 | } 45 | else p=p->next; 46 | } 47 | } 48 | int main() 49 | { 50 | linklist L; 51 | buildlist(L); 52 | cout<<"删除之前"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={1,2,3,4}; 9 | int b[5]={3,4,5,6,7}; 10 | int n1=4,n2=5; 11 | void buildlist(linklist &L,int aa[],int n) 12 | { 13 | L=(linklist)malloc(sizeof(lnode)); 14 | lnode *r=L,*s; 15 | for(int i=0;idata=aa[i]; 19 | r->next=s; 20 | r=r->next; 21 | } 22 | r->next=NULL; 23 | } 24 | void disp(linklist L) 25 | { 26 | lnode *s=L->next; 27 | while(s) 28 | { 29 | cout<data<<" "; 30 | s=s->next; 31 | } 32 | cout<next,*p2=L2->next,*r; 37 | L1->next=NULL; 38 | while(p1&&p2) 39 | { 40 | if(p1->data<=p2->data) 41 | { 42 | r=p1->next; 43 | p1->next=L1->next; 44 | L1->next=p1; 45 | p1=r; 46 | } 47 | else 48 | { 49 | r=p2->next; 50 | p2->next=L1->next; 51 | L1->next=p2; 52 | p2=r; 53 | } 54 | } 55 | if(p1) p2=p1; 56 | while(p2) 57 | { 58 | r=p2->next; 59 | p2->next=L1->next; 60 | L1->next=p2; 61 | p2=r; 62 | } 63 | free(L2); 64 | } 65 | int main() 66 | { 67 | linklist L1,L2; 68 | buildlist(L1,a,n1); 69 | buildlist(L2,b,n2); 70 | cout<<"L1:"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={2,3,4,9}; 9 | int n1=4; 10 | int b[5]={4,7,9,10,11}; 11 | int n2=5; 12 | void buildlist(linklist &L,int aa[],int n) 13 | { 14 | L=(linklist)malloc(sizeof(lnode)); 15 | lnode *s,*r=L; 16 | for(int i=0;idata=aa[i]; 20 | r->next=s; 21 | r=r->next; 22 | } 23 | r->next=NULL; 24 | } 25 | void disp(linklist L) 26 | { 27 | lnode *s=L->next; 28 | while(s) 29 | { 30 | cout<data<<" "; 31 | s=s->next; 32 | } 33 | cout<next,*p2=L2->next,*s,*r; 40 | r=L3; 41 | while(p1&&p2) 42 | { 43 | if(p1->datadata) p1=p1->next; 44 | else if(p1->data>p2->data) p2=p2->next; 45 | else 46 | { 47 | s=(lnode *)malloc(sizeof(lnode)); 48 | s->data=p1->data; 49 | r->next=s; 50 | r=s; 51 | p1=p1->next; 52 | p2=p2->next; 53 | } 54 | } 55 | r->next=NULL; 56 | 57 | } 58 | int main() 59 | { 60 | linklist L1,L2; 61 | buildlist(L1,a,n1); 62 | buildlist(L2,b,n2); 63 | cout<<"L1:"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={1,2,3,4}; 9 | int b[6]={2,4,5,6,7,8}; 10 | int n1=4,n2=6; 11 | void buildlist(linklist &L,int aa[],int n) 12 | { 13 | L=(linklist)malloc(sizeof(lnode)); 14 | lnode *s,*r=L; 15 | for(int i=0;idata=aa[i]; 19 | r->next=s; 20 | r=r->next; 21 | } 22 | r->next=NULL; 23 | } 24 | void disp(linklist L) 25 | { 26 | lnode *s=L->next; 27 | while(s) 28 | { 29 | cout<data<<" "; 30 | s=s->next; 31 | } 32 | cout<next,*p2=L2->next,*r=L1,*q; 37 | while(p1&&p2) 38 | { 39 | if(p1->datadata) 40 | { 41 | q=p1; 42 | p1=p1->next; 43 | free(q); 44 | } 45 | else if(p1->data>p2->data) 46 | { 47 | q=p2; 48 | p2=p2->next; 49 | free(q); 50 | } 51 | else 52 | { 53 | r->next=p1; 54 | r=p1; 55 | p1=p1->next; 56 | q=p2; 57 | p2=p2->next; 58 | free(q); 59 | } 60 | } 61 | while(p1) 62 | { 63 | q=p1; 64 | p1=p1->next; 65 | free(q); 66 | } 67 | while(p2) 68 | { 69 | q=p2; 70 | p2=p2->next; 71 | free(q); 72 | } 73 | r->next=NULL; 74 | } 75 | int main() 76 | { 77 | linklist L1,L2; 78 | buildlist(L1,a,n1); 79 | buildlist(L2,b,n2); 80 | cout<<"L1"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[6]={1,2,3,4,5,6}; 9 | int b[3]={3,4,7}; 10 | int n1=6,n2=3; 11 | void buildlist(linklist &L,int aa[],int n) 12 | { 13 | L=(linklist)malloc(sizeof(lnode)); 14 | lnode *s,*r=L; 15 | for(int i=0;idata=aa[i]; 19 | r->next=s; 20 | r=r->next; 21 | } 22 | r->next=NULL; 23 | } 24 | bool isok(linklist L1,linklist L2) 25 | { 26 | lnode *p1=L1->next,*p2=L2->next,*r=L1->next; 27 | while(p1&&p2) 28 | { 29 | if(p1->data!=p2->data) 30 | { 31 | r=r->next; 32 | p1=r; 33 | p2=L2->next; 34 | } 35 | else 36 | { 37 | p1=p1->next; 38 | p2=p2->next; 39 | } 40 | } 41 | if(p2) return false; 42 | else return true; 43 | } 44 | int main() 45 | { 46 | linklist L1,L2; 47 | buildlist(L1,a,n1); 48 | buildlist(L2,b,n2); 49 | if(isok(L1,L2)) cout<<"yes"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next,*prior; 7 | }lnode,*linklist; 8 | int a[6]={1,2,3,4,2,1}; 9 | int n=6; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | L->prior=L; 15 | L->next=L; 16 | for(int i=0;idata=a[i]; 20 | s->next=r->next; 21 | r->next->prior=s; 22 | s->prior=r; 23 | r->next=s; 24 | r=s; 25 | L->prior=s; 26 | } 27 | } 28 | void disp(linklist L) 29 | { 30 | lnode *s=L->next; 31 | while(s!=L) 32 | { 33 | cout<data<<" "; 34 | s=s->next; 35 | } 36 | cout<next,*q=L->prior; 41 | while(p!=q&&q->next!=p) 42 | { 43 | if(p->data==q->data) 44 | { 45 | p=p->next; 46 | q=q->prior; 47 | } 48 | else return false; 49 | } 50 | return true; 51 | } 52 | int main() 53 | { 54 | linklist L; 55 | buildlist(L); 56 | disp(L); 57 | if(isok(L))cout<<"yes"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={1,2,3,4}; 9 | int b[5]={5,6,7,8,9}; 10 | int n1=4,n2=4; 11 | void buildlist(linklist &L,int aa[],int n) 12 | { 13 | L=(linklist)malloc(sizeof(lnode)); 14 | lnode *s,*r=L; 15 | for(int i=0;idata=aa[i]; 19 | r->next=s; 20 | r=r->next; 21 | } 22 | r->next=L; 23 | } 24 | void disp(linklist L) 25 | { 26 | lnode *s=L->next; 27 | while(s!=L) 28 | { 29 | cout<data<<" "; 30 | s=s->next; 31 | } 32 | cout<next,*q=L2->next; 37 | while(p->next!=L1) 38 | { 39 | p=p->next; 40 | } 41 | while(q->next!=L2){ 42 | q=q->next; 43 | } 44 | p->next=L2->next; 45 | q->next=L1; 46 | } 47 | int main() 48 | { 49 | linklist L1,L2; 50 | buildlist(L1,a,n1); 51 | buildlist(L2,b,n2); 52 | cout<<"L1"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[5]={3,5,2,7,1}; 9 | int n=5; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=L; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s!=L) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next!=L) 37 | { 38 | p=L->next,r=L,min=p,mp=r; 39 | while(p!=L) 40 | { 41 | if(p->datadata) 42 | { 43 | min=p; 44 | mp=r; 45 | } 46 | else 47 | { 48 | r=p; 49 | p=p->next; 50 | } 51 | } 52 | cout<data<<" "; 53 | mp->next=min->next; 54 | free(min); 55 | } 56 | free(L); 57 | } 58 | int main() 59 | { 60 | linklist L; 61 | buildlist(L); 62 | cout<<"L:"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={1,3,3,4}; 9 | int n=4; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | } 22 | void disp(linklist L) 23 | { 24 | lnode *s=L->next; 25 | while(s) 26 | { 27 | cout<data<<" "; 28 | s=s->next; 29 | } 30 | cout<next,*q,*r=L; 35 | while(p) 36 | { 37 | if(p->data!=x) 38 | { 39 | r->next=p; 40 | r=p; 41 | p=p->next; 42 | } 43 | else 44 | { 45 | q=p; 46 | p=p->next; 47 | free(q); 48 | } 49 | } 50 | } 51 | int main() 52 | { 53 | linklist L; 54 | buildlist(L); 55 | disp(L); 56 | deletex(L,3); 57 | disp(L); 58 | return 0; 59 | } -------------------------------------------------------------------------------- /chapter2/2_2_20.cpp: -------------------------------------------------------------------------------- 1 | //双链表查找元素 再排序 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data,f; 6 | struct lnode *next,*prior; 7 | }lnode,*linklist; 8 | int a[5]={1,2,3,4,5}; 9 | int n=5; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *r=L,*s; 14 | L->prior=NULL; 15 | L->next=L; 16 | for(int i=0;idata=a[i]; 20 | s->f=0; 21 | s->next=r->next; 22 | r->next->prior=s; 23 | r->next=s; 24 | s->prior=r; 25 | r=s; 26 | } 27 | r->next=NULL; 28 | } 29 | void disp(linklist L) 30 | { 31 | lnode *s=L->next; 32 | while(s) 33 | { 34 | cout<data<<" "; 35 | s=s->next; 36 | } 37 | cout<next,*q; 42 | while(p&&p->data!=x) p=p->next; 43 | if(!p) cout<<"没有x这个结点"<f++; 47 | if(p->next!=NULL) p->next->prior=p->prior; 48 | p->prior->next=p->next; 49 | q=p->prior; 50 | while(q!=L&&q->f<=p->f) q=q->prior; 51 | p->next=q->next; 52 | q->next->prior=p; 53 | p->prior=q; 54 | q->next=p; 55 | } 56 | return p; 57 | } 58 | int main() 59 | { 60 | linklist L; 61 | buildlist(L); 62 | disp(L); 63 | Locate(L,5); 64 | Locate(L,5); 65 | Locate(L,4); 66 | Locate(L,4); 67 | disp(L); 68 | return 0; 69 | } -------------------------------------------------------------------------------- /chapter2/2_2_21.cpp: -------------------------------------------------------------------------------- 1 | //单链表查找倒数第k个结点 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[5]={5,4,3,10,1}; 9 | int n=5; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | int findk(linklist L,int k) 24 | { 25 | lnode *p=L->next,*q=L->next; 26 | int num=0; 27 | while(p!=NULL) 28 | { 29 | if(numnext; 31 | p=p->next; 32 | } 33 | if(numdata< 3 | using namespace std; 4 | typedef struct lnode{ 5 | char data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | char a[7]={'l','o','a','d','i','n','g'}; 9 | char b[5]={'b','e','i','n','g'}; 10 | int n1=7,n2=5; 11 | void buildlist(linklist &L,char aa[],int n) 12 | { 13 | L=(linklist)malloc(sizeof(lnode)); 14 | lnode *s,*r=L; 15 | for(int i=0;idata=aa[i]; 19 | r->next=s; 20 | r=r->next; 21 | } 22 | r->next=NULL; 23 | } 24 | void disp(linklist L) 25 | { 26 | lnode *s=L->next; 27 | while(s) 28 | { 29 | cout<data<<" "; 30 | s=s->next; 31 | } 32 | cout<next; 38 | while(s) 39 | { 40 | ans++; 41 | s=s->next; 42 | } 43 | return ans; 44 | } 45 | linklist first(linklist L1,linklist L2) 46 | { 47 | int len1=length(L1),len2=length(L2); 48 | int dist=abs(len1-len2); 49 | lnode *p=L1->next,*q=L2->next; 50 | if(len1>=len2) 51 | { 52 | while(dist--) 53 | { 54 | p=p->next; 55 | } 56 | } 57 | else 58 | { 59 | while(dist--) 60 | { 61 | q=q->next; 62 | } 63 | } 64 | while(p) 65 | { 66 | if(p->data!=q->data) 67 | { 68 | p=p->next; 69 | q=q->next; 70 | } 71 | else return p; 72 | } 73 | return p; 74 | } 75 | int main() 76 | { 77 | linklist L1,L2; 78 | buildlist(L1,a,n1); 79 | buildlist(L2,b,n2); 80 | cout<<"L1:"<data< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[6]={1,-4,2,3,4,-2}; 9 | int n=6; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next!=NULL) 42 | { 43 | s=abs(p->next->data); 44 | if(*(q+s)==0) 45 | { 46 | *(q+s)=1; 47 | p=p->next; 48 | } 49 | else 50 | { 51 | f=p->next; 52 | p->next=f->next; 53 | free(f); 54 | } 55 | } 56 | free(q); 57 | } 58 | int main() 59 | { 60 | linklist L; 61 | buildlist(L); 62 | cout<<"L"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode; 8 | int a[15]={1,2,3,4,5,6,7,8,9,4,5,6,7,8,9}; 9 | int n=15; 10 | void buildlist(lnode *L) 11 | { 12 | lnode *s,*r=L; 13 | r->data=a[0]; 14 | for(int i=1;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(lnode *L) 24 | { 25 | lnode *s=L; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next!=NULL) 37 | { 38 | s=s->next; 39 | f=f->next->next; 40 | if(s->data==f->data) break; 41 | } 42 | if(s==NULL||f->next==NULL) return NULL; 43 | lnode *p=L,*q=s; 44 | while(p->data!=q->data) 45 | { 46 | p=p->next; 47 | q=q->next; 48 | } 49 | return p; 50 | } 51 | int main() 52 | { 53 | lnode list; 54 | lnode *L=&list; 55 | buildlist(L); 56 | cout<<"L:"<data< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[8]={1,2,3,4,5,6,7,8}; 9 | int n=8; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next!=NULL) 38 | { 39 | p=p->next; 40 | q=q->next; 41 | if(q->next!=NULL) q=q->next; 42 | } 43 | q=p->next; 44 | p->next=NULL; 45 | while(q) 46 | { 47 | r=q->next; 48 | q->next=p->next; 49 | p->next=q; 50 | q=r; 51 | } 52 | l=L->next; 53 | q=p->next; 54 | p->next=NULL; 55 | while(q) 56 | { 57 | r=q->next; 58 | q->next=l->next; 59 | l->next=q; 60 | l=q->next; 61 | q=r; 62 | } 63 | } 64 | int main() 65 | { 66 | linklist L; 67 | buildlist(L); 68 | disp(L); 69 | newlist(L); 70 | disp(L); 71 | return 0; 72 | } -------------------------------------------------------------------------------- /chapter2/2_2_3.cpp: -------------------------------------------------------------------------------- 1 | //不带头结点的逆序输出 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode; 8 | int a[4]={1,2,3,4}; 9 | int n=4; 10 | void buildlist(lnode *L) 11 | { 12 | lnode *r=L,*s; 13 | r->data=a[0]; 14 | if(n==1) r->next=NULL; 15 | else 16 | { 17 | for(int i=1;idata=a[i]; 21 | r->next=s; 22 | r=r->next; 23 | } 24 | r->next=NULL; 25 | } 26 | } 27 | void disp(lnode *L) 28 | { 29 | if(L!=NULL) 30 | { 31 | disp(L->next); 32 | cout<<(L->data)<<" "; 33 | } 34 | else return; 35 | } 36 | int main() 37 | { 38 | lnode list; 39 | lnode *L=&list; 40 | buildlist(L); 41 | disp(L); 42 | return 0; 43 | } -------------------------------------------------------------------------------- /chapter2/2_2_4.cpp: -------------------------------------------------------------------------------- 1 | //带头结点的链表删除最小元素（唯一） 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={23,12,5,34}; 9 | int n=4; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *r=L,*s; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next,*q,*r=L,*s; 36 | q=p,s=r; 37 | while(p) 38 | { 39 | if(p->datadata) 40 | { 41 | q=p; 42 | s=r; 43 | } 44 | r=p; 45 | p=p->next; 46 | } 47 | s->next=q->next; 48 | free(q); 49 | } 50 | int main() 51 | { 52 | linklist L; 53 | buildlist(L); 54 | disp(L); 55 | deletemin(L); 56 | disp(L); 57 | return 0; 58 | } -------------------------------------------------------------------------------- /chapter2/2_2_5.cpp: -------------------------------------------------------------------------------- 1 | //头插法逆置链表 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={1,2,3,4}; 9 | int n=4; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *r=L,*s; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next,*r; 36 | L->next=NULL; 37 | while(p) 38 | { 39 | r=p->next; 40 | p->next=L->next; 41 | L->next=p; 42 | p=r; 43 | } 44 | } 45 | int main() 46 | { 47 | linklist L; 48 | buildlist(L); 49 | cout<<"逆置之前"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[4]={8,7,6,5}; 9 | int n=4; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *r=L,*s; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next,*r=p->next,*f; 36 | p->next=NULL; 37 | p=r; 38 | while(p) 39 | { 40 | r=p->next; 41 | f=L; 42 | while(f->next!=NULL&&f->next->datadata) f=f->next; 43 | p->next=f->next; 44 | f->next=p; 45 | p=r; 46 | } 47 | } 48 | int main() 49 | { 50 | linklist L; 51 | buildlist(L); 52 | disp(L); 53 | sortlist(L); 54 | disp(L); 55 | return 0; 56 | } -------------------------------------------------------------------------------- /chapter2/2_2_7.cpp: -------------------------------------------------------------------------------- 1 | //删除链表区间内的结点 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[5]={1,5,3,4,2}; 9 | int n=5; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void disp(linklist L) 24 | { 25 | lnode *s=L->next; 26 | while(s) 27 | { 28 | cout<data<<" "; 29 | s=s->next; 30 | } 31 | cout<next,*r=L; 36 | while(p) 37 | { 38 | if(p->datadata>min) 39 | { 40 | r->next=p->next; 41 | free(p); 42 | p=r->next; 43 | } 44 | else 45 | { 46 | r=p; 47 | p=p->next; 48 | } 49 | } 50 | } 51 | int main() 52 | { 53 | linklist L; 54 | buildlist(L); 55 | disp(L); 56 | deletelist(L,1,4); 57 | disp(L); 58 | return 0; 59 | } -------------------------------------------------------------------------------- /chapter2/2_2_8.cpp: -------------------------------------------------------------------------------- 1 | //找公共结点 2 | #include 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[5]={2,4,3,7,8}; 9 | int b[4]={1,3,7,8}; 10 | int n1=5,n2=4; 11 | void buildlist(linklist &L,int aa[],int n) 12 | { 13 | L=(linklist)malloc(sizeof(lnode)); 14 | lnode *s,*r=L; 15 | for(int i=0;idata=aa[i]; 19 | r->next=s; 20 | r=r->next; 21 | } 22 | r->next=NULL; 23 | } 24 | int length(linklist L) 25 | { 26 | int k=0; 27 | lnode *s=L->next; 28 | while(s) 29 | { 30 | k++; 31 | s=s->next; 32 | } 33 | return k; 34 | } 35 | linklist findd(linklist L1,linklist L2) 36 | { 37 | int len1=length(L1),len2=length(L2); 38 | int dist=0; 39 | linklist long1,short1; 40 | if(len1>len2) 41 | { 42 | long1=L1->next; 43 | short1=L2->next; 44 | dist=len1-len2; 45 | } 46 | else 47 | { 48 | long1=L2->next; 49 | short1=L1->next; 50 | dist=len2-len1; 51 | } 52 | while(dist--) long1=long1->next; 53 | while(long1) 54 | { 55 | if(long1->data==short1->data&&long1->next->data==short1->next->data) return long1; 56 | else 57 | { 58 | long1=long1->next; 59 | short1=short1->next; 60 | } 61 | } 62 | return NULL; 63 | } 64 | linklist findd2(linklist L1,linklist L2) 65 | { 66 | lnode *s1=L1->next; 67 | while(s1) 68 | { 69 | lnode *s2=L2->next; 70 | while(s2) 71 | { 72 | if(s1->data==s2->data&&s1->next->data==s2->next->data) 73 | return s1; 74 | else s2=s2->next; 75 | } 76 | s1=s1->next; 77 | } 78 | return NULL; 79 | } 80 | int main() 81 | { 82 | linklist L1,L2; 83 | buildlist(L1,a,n1); 84 | buildlist(L2,b,n2); 85 | linklist L3=findd2(L1,L2); 86 | cout<data<<" "< 3 | using namespace std; 4 | typedef struct lnode{ 5 | int data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | int a[5]={2,5,3,8,1}; 9 | int n=5; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *r=L,*s; 14 | for(int i=0;idata=a[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | void deletemin(linklist &L) 24 | { 25 | while(L->next!=NULL) 26 | { 27 | lnode *r=L,*p=r->next; 28 | while(p->next!=NULL) 29 | { 30 | if(p->next->datanext->data) 31 | r=p; 32 | p=p->next; 33 | } 34 | cout<<(r->next->data)<<" "; 35 | lnode *q=r->next; 36 | r->next=q->next; 37 | free(q); 38 | } 39 | free(L); 40 | } 41 | int main() 42 | { 43 | linklist L; 44 | buildlist(L); 45 | deletemin(L); 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /chapter3/P141-7.cpp: -------------------------------------------------------------------------------- 1 | //判断是否是完全二叉树 2 | #include 3 | using namespace std; 4 | #define Max 13 5 | typedef struct treenode{ 6 | char data; 7 | struct treenode *lchild,*rchild; 8 | }treenode,*tree; 9 | void buildtree(tree t) 10 | { 11 | char ch; 12 | ch=getchar(); 13 | if(ch=='#') t=NULL; 14 | else 15 | { 16 | t=(treenode *)malloc(sizeof(treenode)); 17 | t->data=ch; 18 | t->lchild=NULL; 19 | t->rchild=NULL; 20 | buildtree(t->lchild); 21 | buildtree(t->rchild); 22 | } 23 | } 24 | struct squeue1{ 25 | struct treenode *data[Max]; 26 | int f,r,tag; 27 | }; 28 | bool isempty(squeue1 s) 29 | { 30 | if(s.f==s.r&&s.tag==0) return true; 31 | return false; 32 | } 33 | bool isfull(squeue1 s) 34 | { 35 | if(s.f==s.r&&s.tag==1) return true; 36 | return false; 37 | } 38 | bool enters(squeue1 s,treenode *p) 39 | { 40 | if(isfull(s)) return false; 41 | s.data[s.r]=p; 42 | s.r=(s.r+1)%Max; 43 | s.tag=1; 44 | return true; 45 | } 46 | bool outs(squeue1 s,treenode *&p) 47 | { 48 | if(isempty(s)) return false; 49 | p=s.data[s.f]; 50 | s.f=(s.f+1)%Max; 51 | s.tag=0; 52 | return 0; 53 | } 54 | bool isok(tree t) 55 | { 56 | squeue1 s; 57 | s.f=s.r=s.tag=0; 58 | if(!t) return true; 59 | enters(s,t); 60 | cout<<"1 "<data<data<lchild); 69 | enters(s,p->rchild); 70 | } 71 | else 72 | { 73 | while(!isempty(s)) 74 | { 75 | outs(s,p); 76 | if(p) return false; 77 | } 78 | } 79 | } 80 | return true; 81 | } 82 | int main() 83 | { 84 | tree t; 85 | buildtree(t); 86 | if(isok(t)) cout<<"是完全二叉树"< 3 | using namespace std; 4 | int n; 5 | bool isok(char s[]) 6 | { 7 | int I=0,O=0; 8 | for(int i=0;iI) return false; 13 | } 14 | if(O==I) return true; 15 | return false; 16 | } 17 | int main() 18 | { 19 | char s[8]={'I','O','I','I','O','I','O','O'}; 20 | n=8; 21 | if(isok(s)) cout<<"合法"< 3 | using namespace std; 4 | typedef struct lnode{ 5 | char data; 6 | struct lnode *next; 7 | }lnode,*linklist; 8 | char s1[4]={'a','b','b','c'}; 9 | int n=4; 10 | void buildlist(linklist &L) 11 | { 12 | L=(linklist)malloc(sizeof(lnode)); 13 | lnode *s,*r=L; 14 | for(int i=0;idata=s1[i]; 18 | r->next=s; 19 | r=r->next; 20 | } 21 | r->next=NULL; 22 | } 23 | bool isok(linklist L,int n) 24 | { 25 | char str[n/2]; 26 | lnode *p=L->next; 27 | int i; 28 | for(i=0;idata; 31 | p=p->next; 32 | } 33 | i--; 34 | if(n%2!=0) p=p->next; 35 | while(p&&p->data==str[i]) 36 | { 37 | i--; 38 | p=p->next; 39 | } 40 | if(i==-1) return true; 41 | return false; 42 | } 43 | int main() 44 | { 45 | linklist L; 46 | buildlist(L); 47 | if(isok(L,n)) cout<<"yes"< 3 | using namespace std; 4 | #define Max 50 5 | typedef struct{ 6 | int data[Max]; 7 | int top[2]; 8 | }stack1; 9 | stack1 s; 10 | int push(int i,int x) 11 | { 12 | if(i!=0&&i!=1){ 13 | cout<<"无栈"< 3 | using namespace std; 4 | #define Max 10 5 | typedef struct{ 6 | int data[Max]; 7 | int f,r,tag; 8 | }squeue; 9 | bool enters(squeue &s,int x) 10 | { 11 | if(s.f==s.r&&s.tag==1) 12 | { 13 | cout<<"队满 进队失败"< 3 | using namespace std; 4 | #define Max 10 5 | struct stack1{ 6 | int data[Max]; 7 | int top; 8 | }; 9 | struct squeue1{ 10 | int data[Max]; 11 | int r,f,tag; 12 | }; 13 | bool entersqueue(squeue1 &s,int x) 14 | { 15 | if(s.f==s.r&&s.tag==1) 16 | { 17 | cout<<"队满 进队失败"< 3 | using namespace std; 4 | #define Max 10 5 | struct stack1{ 6 | int data[Max]; 7 | int top; 8 | }; 9 | bool isempty(stack1 s) 10 | { 11 | if(s.top==-1) return true; 12 | return false; 13 | } 14 | bool isfull(stack1 s) 15 | { 16 | if(s.top==Max-1) return true; 17 | return false; 18 | } 19 | bool enterstack(stack1 &s,int x) 20 | { 21 | if(isfull(s)) return false; 22 | s.data[++s.top]=x; 23 | return true; 24 | } 25 | int outstack(stack1 &s,int &x) 26 | { 27 | if(isempty(s)){ 28 | cout<<"栈空"< 3 | using namespace std; 4 | #define Max 10 5 | struct stack1{ 6 | char data[Max+1]; 7 | int top; 8 | }; 9 | bool isempty(stack1 s) 10 | { 11 | if(s.top==-1) return true; 12 | return false; 13 | } 14 | bool isfull(stack1 s) 15 | { 16 | if(s.top==Max-1) return true; 17 | return false; 18 | } 19 | bool enterstack(stack1 &s,char x) 20 | { 21 | if(isfull(s)) 22 | { 23 | cout<<"栈满"< 3 | using namespace std; 4 | #define Max 10 5 | struct stack1{ 6 | char data[Max]; 7 | int top; 8 | }; 9 | bool isempty(stack1 s) 10 | { 11 | if(s.top==-1)return true; 12 | return false; 13 | } 14 | bool isfull(stack1 s) 15 | { 16 | if(s.top==Max-1) return true; 17 | return false; 18 | } 19 | bool enterstack(stack1 &s,char x) 20 | { 21 | if(isfull(s)) 22 | { 23 | cout<<"栈满"< 3 | using namespace std; 4 | #define Max 10 5 | struct stack1{ 6 | int n; 7 | double pnx; 8 | }st[Max]; 9 | double ans(int n,double x) 10 | { 11 | int top=-1,i; 12 | double fv1=1,fv2=2*x; 13 | for(i=n;i>=2;i--) 14 | { 15 | top++; 16 | st[top].n=i; 17 | } 18 | while(top>=0) 19 | { 20 | st[top].pnx=2*x*fv2-2*(st[top].n-1)*fv1; 21 | fv1=fv2; 22 | fv2=st[top].pnx; 23 | top--; 24 | } 25 | if(n==0) return fv1; 26 | return fv2; 27 | } 28 | int main() 29 | { 30 | double ans1=ans(3,1.9); 31 | cout< 3 | using namespace std; 4 | #define Max 10 5 | struct squeue{ 6 | int data[Max]; 7 | int f,r,tag; 8 | }; 9 | bool isempty(squeue s) 10 | { 11 | if(s.f==s.r&&s.tag==0) return true; 12 | return false; 13 | } 14 | bool isfull(squeue s) 15 | { 16 | if(s.f==s.r&&s.tag==1) return true; 17 | return false; 18 | } 19 | bool entersqueue(squeue &s,int x) 20 | { 21 | if(isfull(s)) return false; 22 | s.data[s.r]=x; 23 | s.r=(s.r+1)%Max; 24 | s.tag=1; 25 | return true; 26 | } 27 | bool outsqueue(squeue &s,int &x) 28 | { 29 | if(isempty(s)) return false; 30 | x=s.data[s.f]; 31 | s.f=(s.f+1)%Max; 32 | s.tag=0; 33 | return true; 34 | } 35 | void disp(squeue &s) 36 | { 37 | while(!isempty(s)) 38 | { 39 | cout< 3 | using namespace std; 4 | struct Tree 5 | { 6 | /* data */ 7 | int data[12]={-1,1,2,3,-1,4,-1,5,-1,-1,-6,-1}; 8 | }; 9 | int Comm(Tree t,int i,int j) 10 | { 11 | if(t.data[i]!=-1&&t.data[j]!=-1) 12 | { 13 | while(i!=j) 14 | { 15 | if(i>j) i/=2; 16 | else j/=2; 17 | } 18 | return t.data[i]; 19 | } 20 | return -1; 21 | } 22 | int main() 23 | { 24 | Tree t; 25 | int ans=Comm(t,7,10); 26 | cout< 3 | using namespace std; 4 | #define Max 15 5 | typedef struct treenode{ 6 | char data; 7 | struct treenode *lchild,*rchild; 8 | }treenode,*tree; 9 | void buildtree(tree &t) 10 | { 11 | char ch; 12 | ch=getchar(); 13 | if(ch=='#') t=NULL; 14 | else 15 | { 16 | t=(treenode *)malloc(sizeof(treenode)); 17 | t->data=ch; 18 | t->lchild=NULL; 19 | t->rchild=NULL; 20 | buildtree(t->lchild); 21 | buildtree(t->rchild); 22 | } 23 | } 24 | struct squeue{ 25 | struct treenode *data[Max]; 26 | int f,r,tag; 27 | }; 28 | bool isempty(squeue s) 29 | { 30 | if(s.f==s.r&&s.tag==0) return true; 31 | return false; 32 | } 33 | bool isfull(squeue s) 34 | { 35 | if(s.f==s.r&&s.tag==1) return true; 36 | return false; 37 | } 38 | bool enters(squeue &s,treenode *p) 39 | { 40 | if(isfull(s)) return false; 41 | s.data[s.r]=p; 42 | s.r=(s.r+1)%Max; 43 | s.tag=1; 44 | return true; 45 | } 46 | bool outs(squeue &s,treenode *&p) 47 | { 48 | if(s.f==s.r&&s.tag==0) return false; 49 | p=s.data[s.f]; 50 | s.f=(s.f+1)%Max; 51 | s.tag=0; 52 | return true; 53 | } 54 | bool isok(tree t) 55 | { 56 | squeue s; 57 | s.f=s.r=s.tag=0; 58 | bool flag=true,ans=true; 59 | if(t==NULL) ans=true; 60 | if(!t->lchild&&!t->rchild) ans=true; 61 | enters(s,t); 62 | treenode *p; 63 | while(!isempty(s)) 64 | { 65 | outs(s,p); 66 | if(!p->lchild) 67 | { 68 | flag=false; 69 | if(p->rchild) ans=false; 70 | } 71 | else//有左孩子 72 | { 73 | if(flag)//之前不存在缺孩子的节点 74 | { 75 | enters(s,p->lchild); 76 | if(p->rchild) enters(s,p->rchild); 77 | else flag=false; 78 | } 79 | else//之前存在缺孩子的节点 80 | ans=false; 81 | } 82 | } 83 | if(ans) return true; 84 | return false; 85 | } 86 | int main() 87 | { 88 | 89 | tree t; 90 | buildtree(t); 91 | if(isok(t)) cout<<"yes"< 3 | using namespace std; 4 | typedef struct TreeNode{ 5 | char data; 6 | struct TreeNode *lchild,*rchild; 7 | int tag; 8 | }TreeNode,*Tree; 9 | void creattree(Tree &t) 10 | { 11 | char ch; 12 | ch=getchar(); 13 | if(ch=='#') t=NULL; 14 | else 15 | { 16 | t=(TreeNode *)malloc(sizeof(TreeNode)); 17 | t->data=ch; 18 | t->tag=0; 19 | t->lchild=NULL; 20 | t->rchild=NULL; 21 | creattree(t->lchild); 22 | creattree(t->rchild); 23 | } 24 | } 25 | void back(Tree t) 26 | { 27 | struct TreeNode *stack[100]; 28 | int top=-1; 29 | TreeNode *p=t; 30 | TreeNode *x; 31 | while(p||top!=-1) 32 | { 33 | if(p) 34 | { 35 | top++; 36 | stack[top]=p; 37 | p=p->lchild; 38 | } 39 | else 40 | { 41 | p=stack[top]; 42 | if(p->rchild&&p->rchild->tag==0) 43 | p=p->rchild; 44 | else 45 | { 46 | p=stack[top]; 47 | top--; 48 | cout<data<<" "; 49 | p->tag=1; 50 | p=NULL; 51 | } 52 | } 53 | } 54 | } 55 | int main() 56 | { 57 | Tree t; 58 | creattree(t); 59 | back(t); 60 | return 0; 61 | } 62 | //ABDEC 63 | //ABD##E##C## -------------------------------------------------------------------------------- /chapter5/P141_4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define Max 10 4 | typedef struct treenode{ 5 | char data; 6 | struct treenode *lchild,*rchild; 7 | }treenode,*tree; 8 | void buildtree(tree &t) 9 | { 10 | char ch; 11 | ch=getchar(); 12 | if(ch=='#') t=NULL; 13 | else 14 | { 15 | t=(treenode *)malloc(sizeof(treenode)); 16 | t->data=ch; 17 | t->lchild=NULL; 18 | t->rchild=NULL; 19 | buildtree(t->lchild); 20 | buildtree(t->rchild); 21 | } 22 | } 23 | typedef struct stack1{ 24 | struct treenode *data[Max]; 25 | int top; 26 | }stack1; 27 | bool isempty(stack1 s) 28 | { 29 | if(s.top==-1) return true; 30 | return false; 31 | } 32 | bool isfull(stack1 s) 33 | { 34 | if(s.top==Max-1) return true; 35 | return false; 36 | } 37 | bool enters(stack1 &s,treenode *p) 38 | { 39 | if(isfull(s)) 40 | { 41 | cout<<"栈满"<lchild) entersqueue(q,p->lchild); 100 | if(p->rchild) entersqueue(q,p->rchild); 101 | } 102 | while(!isempty(s)) 103 | { 104 | outs(s,p); 105 | cout<data<<" "; 106 | } 107 | } 108 | } 109 | int main() 110 | { 111 | tree t; 112 | buildtree(t); 113 | solve(t); 114 | return 0; 115 | } 116 | //ABD##E##CF##G## -------------------------------------------------------------------------------- /chapter5/P141_5.cpp: -------------------------------------------------------------------------------- 1 | //非递归计算二叉树的高度 2 | #include 3 | using namespace std; 4 | typedef struct treenode{ 5 | char data; 6 | struct treenode *lchild,*rchild; 7 | }treenode,*tree; 8 | void buildtree(tree &t) 9 | { 10 | char ch; 11 | ch=getchar(); 12 | if(ch=='#') t=NULL; 13 | else 14 | { 15 | t=(treenode *)malloc(sizeof(treenode)); 16 | t->data=ch; 17 | t->lchild=NULL; 18 | t->rchild=NULL; 19 | buildtree(t->lchild); 20 | buildtree(t->rchild); 21 | } 22 | } 23 | int dept(tree t) 24 | { 25 | if(!t) return 0; 26 | tree q[10]; 27 | int f=-1,r=-1; 28 | int L=0,ans=0; 29 | q[++r]=t; 30 | tree p; 31 | while(flchild) q[++r]=p->lchild; 35 | if(p->rchild) q[++r]=p->rchild; 36 | if(f==L) 37 | { 38 | ans++; 39 | L=r; 40 | } 41 | } 42 | return ans; 43 | } 44 | int main() 45 | { 46 | tree t; 47 | buildtree(t); 48 | cout<<"树的高度为:"< 3 | using namespace std; 4 | typedef struct treenode{ 5 | char data; 6 | struct treenode *lchild,*rchild; 7 | }treenode,*tree; 8 | int pos=0; 9 | tree build(char a[],char b[],int s,int e) 10 | { 11 | if(s<=e) 12 | { 13 | treenode *root=(treenode *)malloc(sizeof(treenode)); 14 | root->data=a[pos]; 15 | int i; 16 | for(i=s;i<=e;i++) if(b[i]==root->data) break; 17 | pos++; 18 | root->lchild=build(a,b,s,i-1); 19 | root->rchild=build(a,b,i+1,e); 20 | return root; 21 | } 22 | return NULL; 23 | } 24 | void disp(tree t) 25 | { 26 | if(t) 27 | { 28 | disp(t->lchild); 29 | disp(t->rchild); 30 | cout<data<<" "; 31 | } 32 | } 33 | int main() { 34 | char a[]={'A','B','D','E','C','F'};//先序序列 35 | char b[]={'D','B','E','A','F','C'};//中序序列 36 | tree root=build(a,b,0,5); 37 | cout<<"后序序列为:"< 3 | using namespace std; 4 | typedef struct treenode{ 5 | char data; 6 | struct treenode *lchild,*rchild; 7 | }treenode,*tree; 8 | void buildtree(tree &t) 9 | { 10 | char ch; 11 | ch=getchar(); 12 | if(ch=='#') t=NULL; 13 | else 14 | { 15 | t=(treenode *)malloc(sizeof(treenode)); 16 | t->data=ch; 17 | t->lchild=NULL; 18 | t->rchild=NULL; 19 | buildtree(t->lchild); 20 | buildtree(t->rchild); 21 | } 22 | } 23 | int num(tree t) 24 | { 25 | if(!t) return 0; 26 | else if(t->lchild&&t->rchild) return num(t->lchild)+num(t->rchild)+1; 27 | else return num(t->lchild)+num(t->rchild); 28 | } 29 | int main() 30 | { 31 | tree t; 32 | buildtree(t); 33 | cout<<"该二叉树中双分结点有 "< 3 | using namespace std; 4 | typedef struct treenode{ 5 | char data; 6 | struct treenode *lchild,*rchild; 7 | }treenode,*tree; 8 | void buildtree(tree &t) 9 | { 10 | char ch; 11 | ch=getchar(); 12 | if(ch=='#') t=NULL; 13 | else 14 | { 15 | t=(treenode *)malloc(sizeof(treenode)); 16 | t->data=ch; 17 | t->lchild=NULL; 18 | t->rchild=NULL; 19 | buildtree(t->lchild); 20 | buildtree(t->rchild); 21 | } 22 | } 23 | void swap(tree &t) 24 | { 25 | treenode *p; 26 | if(t) 27 | { 28 | swap(t->lchild); 29 | swap(t->rchild); 30 | p=t->lchild; 31 | t->lchild=t->rchild; 32 | t->rchild=p; 33 | } 34 | } 35 | void disp(tree t) 36 | { 37 | if(t) 38 | { 39 | cout<data<<" "; 40 | disp(t->lchild); 41 | disp(t->rchild); 42 | } 43 | } 44 | int main() 45 | { 46 | tree t; 47 | buildtree(t); 48 | cout<<"交换过后的二叉树为(前序序列):"< 3 | using namespace std; 4 | //结构体 5 | typedef struct treenode{ 6 | //结点的值 7 | char data; 8 | //结点的左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 赋值结点 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | ch=getchar(); 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //对结点就行内存分配 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //对结点进行赋值 22 | t->data=ch; 23 | //初始化 左右孩子结点为空 24 | t->lchild=NULL; 25 | t->rchild=NULL; 26 | //递归去赋值左右子树 27 | buildtree(t->lchild); 28 | buildtree(t->rchild); 29 | } 30 | } 31 | //先序遍历 递归 32 | 33 | //计数器 34 | int i=1; 35 | //字符 36 | char ch; 37 | char PreNode(tree t,int k) 38 | { 39 | if(t==NULL) return '#'; 40 | if(i==k) return t->data; 41 | i++; 42 | ch=PreNode(t->lchild,k); 43 | if(ch!='#') return ch; 44 | ch=PreNode(t->rchild,k); 45 | return ch; 46 | } 47 | //主函数 测试 48 | int main() 49 | { 50 | tree t; 51 | buildtree(t); 52 | cout< 3 | using namespace std; 4 | //结构体 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //结点的左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 赋值结点 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | ch=getchar(); 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //分配内存空间给结点 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //给结点赋值 22 | t->data=ch; 23 | //将左右孩子结点置为空 24 | t->lchild=NULL; 25 | t->rchild=NULL; 26 | //递归去赋值结点的左右孩子 27 | buildtree(t->lchild); 28 | buildtree(t->rchild); 29 | } 30 | } 31 | //递归释放结点 32 | void Release(tree &t) 33 | { 34 | if(!t) return; 35 | Release(t->lchild); 36 | Release(t->rchild); 37 | free(t); 38 | } 39 | //前序遍历 40 | void delete_x(tree &T,char x) 41 | { 42 | if(T==NULL) return; 43 | if(T->data==x) 44 | { 45 | //递归释放结点 46 | Release(T); 47 | //手动去设置结点为NULL 物理内存的一个释放 48 | T=NULL; 49 | } 50 | if(T!=NULL) 51 | { 52 | delete_x(T->lchild,x); 53 | delete_x(T->rchild,x); 54 | } 55 | } 56 | //打印 57 | void disp(tree t) 58 | { 59 | if(t) 60 | { 61 | cout<data<<" "; 62 | disp(t->lchild); 63 | disp(t->rchild); 64 | } 65 | } 66 | //主函数 测试 67 | int main() 68 | { 69 | tree t; 70 | buildtree(t); 71 | delete_x(t,'A'); 72 | disp(t); 73 | return 0; 74 | } 75 | /* 76 | 77 | A 78 | B C 79 | D E F G 80 | 81 | ABD##E##CF##G## 82 | 83 | */ -------------------------------------------------------------------------------- /chapter5/P150_12.cpp: -------------------------------------------------------------------------------- 1 | //设一棵二叉树的结点结构为(LLINK, INFO, RLINK)，ROOT为指向该二叉树根结点的指针，p和q分别为指向该二叉树中任意两个结点的指针，试编写算法ANCESTOR(ROOT,P,q,r)，找到P和q的最近公共祖先结点r。 2 | #include 3 | using namespace std; 4 | //树结点结构体 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //结点栈的结构体 12 | typedef struct{ 13 | //树的结点 14 | treenode *t; 15 | //左右孩子访问变量 tag=0 左孩子访问过 =1右孩子访问过 16 | int tag; 17 | }Stack; 18 | //建树 赋值结点 19 | void buildtree(tree &t) 20 | { 21 | char ch; 22 | ch=getchar(); 23 | if(ch=='#') t=NULL; 24 | else 25 | { 26 | //给结点分配空间 27 | t=(treenode *)malloc(sizeof(treenode)); 28 | //对结点赋值 29 | t->data=ch; 30 | //左右孩子置空 31 | t->lchild=NULL; 32 | t->rchild=NULL; 33 | //递归赋值左右孩子 34 | buildtree(t->lchild); 35 | buildtree(t->rchild); 36 | } 37 | } 38 | //非递归后序遍历 39 | tree Ancestor(tree t,treenode *p,treenode *q) 40 | { 41 | //两个辅助栈 42 | Stack S1[10],S2[10]; 43 | //栈顶指针的初始化 44 | int top1=0,top2; 45 | //遍历二叉树指针 46 | treenode *tt=t; 47 | //大循环体条件：当前遍历的结点不能为空或者栈1顶指针>0（栈不为空） 48 | while(tt!=NULL||top1>0) 49 | { 50 | //向左延伸压入栈 51 | while(tt!=NULL) 52 | { 53 | S1[++top1].t=tt;//压入栈中 54 | S1[top1].tag=0;//左孩子访问过 55 | tt=tt->lchild;//继续指向左孩子 56 | } 57 | while(top1!=0&&S1[top1].tag==1)//栈1不为空并且栈顶结点的tag=1 58 | { 59 | //如果栈顶的结点就是p 就复制到栈2中 栈2的栈顶指针此时赋值 top1 60 | if(S1[top1].t==p) 61 | { 62 | for(int i=1;i<=top1;i++) 63 | { 64 | S2[i]=S1[i]; 65 | } 66 | top2=top1; 67 | } 68 | //如果栈顶的结点就是q 与栈一进行匹配 69 | if(S1[top1].t==q) 70 | { 71 | for(int i=top1;i>0;i--) 72 | { 73 | for(int j=top2;j>0;j--) 74 | { 75 | if(S2[j].t==S1[i].t) 76 | return S1[i].t; 77 | } 78 | } 79 | } 80 | top1--; //退栈 81 | } 82 | //栈不空时 将栈顶结点的tag=1 并且当前的一个结点指向该结点的右孩子 83 | if(top1!=0) 84 | { 85 | S1[top1].tag=1; 86 | tt=S1[top1].t->rchild; 87 | } 88 | } 89 | return NULL; 90 | } 91 | //主函数 测试 92 | int main() 93 | { 94 | tree t; 95 | buildtree(t); 96 | treenode *p=t->rchild->lchild,*q=t->rchild->rchild; 97 | cout<data< 3 | using namespace std; 4 | //树结点结构体 5 | typedef struct treenode{ 6 | // 结点值 7 | char data; 8 | // 左右孩子的指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //结点队列的结构体 12 | typedef struct{ 13 | tree data[10]; 14 | int level[10]; 15 | int f,r; 16 | }Qu; 17 | //建树 赋值结点 18 | void buildtree(tree &t) 19 | { 20 | char ch; 21 | ch=getchar(); 22 | if(ch=='#') t=NULL; 23 | else 24 | { 25 | //给结点分配空间 26 | t=(treenode *)malloc(sizeof(treenode)); 27 | //赋值 28 | t->data=ch; 29 | //左右孩子先置空 30 | t->lchild=NULL; 31 | t->rchild=NULL; 32 | //递归去赋值左右孩子 33 | buildtree(t->lchild); 34 | buildtree(t->rchild); 35 | } 36 | } 37 | //层次遍历 38 | int width(tree b) 39 | { 40 | //队列 41 | Qu Q; 42 | //出队结点的指向 43 | tree p; 44 | //保存出队的结点层次 45 | int k; 46 | //头尾指针初始化 47 | Q.f=Q.r=-1; 48 | //尾指针后移用来根结点入队 49 | Q.r++; 50 | //根结点入队 51 | Q.data[Q.r]=b; 52 | //根结点层次为1 53 | Q.level[Q.r]=1; 54 | //循环体 头指针小于尾指针可执行 55 | while(Q.flchild!=NULL) 65 | { 66 | //尾指针后移 用来入队 67 | Q.r++; 68 | //左孩子进入队列 69 | Q.data[Q.r]=p->lchild; 70 | //进入队列的结点的层次为出队结点的层次+1 71 | Q.level[Q.r]=k+1; 72 | } 73 | if(p->rchild!=NULL) //右孩子进队 74 | { 75 | //尾指针后移 用来入队 76 | Q.r++; 77 | //右孩子进入队列 78 | Q.data[Q.r]=p->rchild; 79 | //进入队列的结点的层次为出队结点的层次+1 80 | Q.level[Q.r]=k+1; 81 | } 82 | } 83 | //遍历的时候最大值的更新，遍历下标，计算每层的个数 84 | int maxx=0,i=0,n; 85 | //从第一层开始 86 | k=1; 87 | //循环条件 遍历的下标小于队列尾部 88 | while(i<=Q.r) 89 | { 90 | //一开始每层默认0个 91 | n=0; 92 | //当下标小于队列长度并且遍历的下标对应的层次为k的时候 93 | while(i<=Q.r&&Q.level[i]==k) 94 | { //每层个数递增 95 | n++; 96 | //遍历的下标后移 97 | i++; 98 | } 99 | //下一层的层次 100 | k=Q.level[i]; 101 | //更新最大值 102 | if(n>maxx) maxx=n; 103 | } 104 | return maxx; 105 | } 106 | //主函数 测试 107 | int main() 108 | { 109 | tree t; 110 | buildtree(t); 111 | cout< 3 | using namespace std; 4 | //树结点结构体 5 | typedef struct treenode{ 6 | // 结点值 7 | char data; 8 | // 左右孩子的指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //结点队列的结构体 12 | typedef struct{ 13 | tree data[10]; 14 | int level[10]; 15 | int f,r; 16 | }Qu; 17 | //建树 赋值结点 18 | void buildtree(tree &t) 19 | { 20 | char ch; 21 | ch=getchar(); 22 | if(ch=='#') t=NULL; 23 | else 24 | { 25 | //给结点分配空间 26 | t=(treenode *)malloc(sizeof(treenode)); 27 | //赋值 28 | t->data=ch; 29 | //左右孩子先置空 30 | t->lchild=NULL; 31 | t->rchild=NULL; 32 | //递归去赋值左右孩子 33 | buildtree(t->lchild); 34 | buildtree(t->rchild); 35 | } 36 | } 37 | //层次遍历 38 | int width(tree b) 39 | { 40 | //队列 41 | Qu Q; 42 | //出队结点的指向 43 | tree p; 44 | //保存出队的结点层次 45 | int k; 46 | //头尾指针初始化 47 | Q.f=Q.r=-1; 48 | //尾指针后移用来根结点入队 49 | Q.r++; 50 | //根结点入队 51 | Q.data[Q.r]=b; 52 | //根结点层次为1 53 | Q.level[Q.r]=1; 54 | //循环体 头指针小于尾指针可执行 55 | while(Q.flchild!=NULL) 65 | { 66 | //尾指针后移 用来入队 67 | Q.r++; 68 | //左孩子进入队列 69 | Q.data[Q.r]=p->lchild; 70 | //进入队列的结点的层次为出队结点的层次+1 71 | Q.level[Q.r]=k+1; 72 | } 73 | if(p->rchild!=NULL) //右孩子进队 74 | { 75 | //尾指针后移 用来入队 76 | Q.r++; 77 | //右孩子进入队列 78 | Q.data[Q.r]=p->rchild; 79 | //进入队列的结点的层次为出队结点的层次+1 80 | Q.level[Q.r]=k+1; 81 | } 82 | } 83 | //遍历的时候最大值的更新，遍历下标，计算每层的个数 84 | int maxx=0,i=0,n; 85 | //从第一层开始 86 | k=1; 87 | //循环条件 遍历的下标小于队列尾部 88 | while(i<=Q.r) 89 | { 90 | //一开始每层默认0个 91 | n=0; 92 | //当下标小于队列长度并且遍历的下标对应的层次为k的时候 93 | while(i<=Q.r&&Q.level[i]==k) 94 | { //每层个数递增 95 | n++; 96 | //遍历的下标后移 97 | i++; 98 | } 99 | //下一层的层次 100 | k=Q.level[i]; 101 | //更新最大值 102 | if(n>maxx) maxx=n; 103 | } 104 | return maxx; 105 | } 106 | //主函数 测试 107 | int main() 108 | { 109 | tree t; 110 | buildtree(t); 111 | cout< 3 | using namespace std; 4 | //递归交换过程 5 | void PrePost(char pre[],int l1,int h1,char post[],int l2,int h2) 6 | { 7 | int half;//左右子树临界 8 | if(l1<=h1)//递归条件 9 | { 10 | post[h2]=pre[l1]; 11 | half=(h1-l1)/2; 12 | PrePost(pre,l1+1,l1+half,post,l2,l2+half-1); 13 | PrePost(pre,l1+half+1,h1,post,l2+half,h2-1); 14 | } 15 | } 16 | //主函数 测试 17 | int main() 18 | { 19 | char pre[8]="ABDECFG",post[8]; 20 | PrePost(pre,0,6,post,0,6); 21 | for(int i=0;i<7;i++) 22 | { 23 | cout< 3 | using namespace std; 4 | //树结点结构体 5 | typedef struct treenode{ 6 | // 结点值 7 | char data; 8 | // 左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 赋值结点 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | ch=getchar(); 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //先内存非配给结点 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //赋值 22 | t->data=ch; 23 | //左右孩子置空 24 | t->lchild=NULL; 25 | t->rchild=NULL; 26 | //递归去赋值 27 | buildtree(t->lchild); 28 | buildtree(t->rchild); 29 | } 30 | } 31 | //全局 头结点 前驱结点 类型仍然是树结点的一个结构体 通过rchild连接起来 32 | tree head=(treenode *)malloc(sizeof(treenode)),pre=NULL; 33 | //中序遍历 34 | tree Inorder(tree t) 35 | { 36 | //递归条件 结点不为空 37 | if(t) 38 | { 39 | //将根结点左孩子作为参数 一直递归向左延伸 40 | Inorder(t->lchild); 41 | //找到叶子结点 42 | if(t->lchild==NULL&t->rchild==NULL) 43 | { 44 | //如果是第一个 45 | if(pre==NULL) 46 | { 47 | //头结点赋值 48 | head=t; 49 | //保留前驱结点 前驱结点为当前的一个结点 保证后面再次遇到叶子结点的时候知道前驱结点是谁 并能够连接起来 50 | pre=t; 51 | } 52 | //若不是第一个 53 | else 54 | { 55 | //就将前驱结点的右指针指向当前的结点 56 | pre->rchild=t; 57 | //更新前驱结点 保证后面再次遇到叶子结点的时候知道前驱结点是谁 并能够连接起来 58 | pre=t; 59 | } 60 | } 61 | //左子树递归完成了 向左递归右子树 62 | Inorder(t->rchild); 63 | //右子树递归完成后可以将最后一个结点也就是更新后的前驱结点的右指针指向空 64 | pre->rchild=NULL; 65 | } 66 | //最后返回头结点即可 可以通过头结点来遍历整个结点链 67 | return head; 68 | } 69 | 70 | //主函数 测试 71 | int main() 72 | { 73 | tree t; 74 | buildtree(t); 75 | Inorder(t); 76 | while(head) 77 | { 78 | cout<data<<" "; 79 | head=head->rchild; 80 | } 81 | 82 | return 0; 83 | } 84 | 85 | /* 86 | 87 | A 88 | B C 89 | D E F G 90 | 91 | ABD##E##CF##G## 92 | 93 | */ -------------------------------------------------------------------------------- /chapter5/P150_17.cpp: -------------------------------------------------------------------------------- 1 | //P150（17）试设计判断两科二叉树是否相似的算法。所谓二叉树T1和T2相似，指的是T1和T2都是空的二叉树或都只有一个根结点；或T1的左子树和T2的左子树是相似的，且T1的右子树和T2的右子树是相似的 2 | #include 3 | using namespace std; 4 | //树结点结构体 5 | typedef struct treenode{ 6 | //结点的值 7 | char data; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 赋值结点 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //分配内存 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //赋值 22 | t->data=ch; 23 | //左右孩子置空 24 | t->lchild=NULL; 25 | t->rchild=NULL; 26 | //递归的去赋值左右子树 27 | buildtree(t->lchild); 28 | buildtree(t->rchild); 29 | } 30 | } 31 | //递归比较左右子树 空+空 1 空+非空 0 32 | int similar(tree t1,tree t2) 33 | { 34 | int left,right; 35 | if(t1==NULL&&t2==NULL) return 1; 36 | else if(t1==NULL||t2==NULL) return 0; 37 | else 38 | { 39 | left=similar(t1->lchild,t2->lchild); 40 | right=similar(t1->rchild,t2->rchild); 41 | return (left&&right); 42 | } 43 | } 44 | //主函数 测试 45 | int main() 46 | { 47 | tree t1,t2; 48 | buildtree(t1); 49 | buildtree(t2); 50 | cout< 3 | using namespace std; 4 | //线索二叉树结点结构体 5 | typedef struct treenode{ 6 | //结点的值 7 | char data; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | //ltag rtag 11 | int ltag,rtag; 12 | }treenode,*tree; 13 | //建树 赋值结点 14 | void buildtree(tree &t) 15 | { 16 | char ch; 17 | cin>>ch; 18 | if(ch=='#') t=NULL; 19 | else 20 | { 21 | //分配内存 22 | t=(treenode *)malloc(sizeof(treenode)); 23 | //赋值给结点 24 | t->data=ch; 25 | //初始化 26 | t->lchild=NULL; 27 | t->rchild=NULL; 28 | t->ltag=t->rtag=0; 29 | //递归赋值 30 | buildtree(t->lchild); 31 | buildtree(t->rchild); 32 | } 33 | } 34 | tree pre; 35 | //遍历二叉树的保留的前驱结点 36 | //中序线索化 37 | void zx(tree &t) 38 | { 39 | //递归的条件 40 | if(t) 41 | { 42 | //向左延伸 找叶子结点 43 | zx(t->lchild); 44 | if(t->lchild==NULL) //左孩子空 45 | { 46 | t->ltag=1; 47 | t->lchild=pre; 48 | } 49 | else t->ltag=0; 50 | if(pre!=NULL&&pre->rchild==NULL)//没有右孩子 51 | { 52 | pre->rtag=1;//前驱结点有后继结点 53 | pre->rchild=t;//后继结点指向当前 54 | } 55 | pre=t;//更新前驱结点 56 | zx(t->rchild); 57 | } 58 | } 59 | //找后继的前驱结点 60 | tree Inpostpre(tree t,treenode *p) 61 | { 62 | //结果指针 63 | treenode *q; 64 | //该结点有右孩子 结果就是右孩子 65 | if(p->rtag==0) q=p->rchild; 66 | //该结点没有右孩子的情况下 有左孩子 结果就是左孩子 67 | else if(p->ltag==0) q=p->lchild; 68 | // 该结点的前驱为空 即为中序第一个结点 无后序前驱 69 | else if(p->lchild==NULL) q=NULL; 70 | //其他 71 | else 72 | { 73 | //不断沿着线索找祖先结点 74 | while(p->ltag==1&&p->lchild!=NULL) 75 | p=p->lchild; 76 | if(p->ltag==0) q=p->lchild; 77 | //若找到祖先结点 且有左孩子 结果就是左孩子 78 | else q=NULL; 79 | //最后就是没有后序前驱 80 | } 81 | return q; 82 | } 83 | 84 | //主函数 测试 85 | int main() 86 | { 87 | tree t; 88 | buildtree(t); 89 | zx(t); 90 | cout<rchild)->data< 3 | using namespace std; 4 | //结构体 5 | typedef struct treenode{ 6 | //结点的值 7 | char weight; 8 | //左右孩子指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //分配空间 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //赋值 22 | t->weight=ch; 23 | //初始化 24 | t->lchild=NULL; 25 | t->rchild=NULL; 26 | //递归赋值 27 | buildtree(t->lchild); 28 | buildtree(t->rchild); 29 | } 30 | } 31 | //计算WPL 32 | int wplpre(tree t,int deep) 33 | { 34 | //静态变量 存储结果值并函数末尾返回 35 | static int ans=0; 36 | //若是叶子结点 累加值 37 | if(t->lchild==NULL&&t->rchild==NULL) 38 | ans+=(deep*((t->weight)-'0')); 39 | if(t->lchild!=NULL) 40 | wplpre(t->lchild,deep+1); 41 | //若不是叶子结点 递归遍历左子树找叶子结点同时层数+1 42 | if(t->rchild!=NULL) 43 | wplpre(t->rchild,deep+1); 44 | //若不是叶子结点 递归遍历左子树找叶子结点同时层数+1 45 | return ans; 46 | } 47 | //主函数测试 48 | 49 | int main() 50 | { 51 | tree t; 52 | buildtree(t); 53 | cout< 3 | using namespace std; 4 | //结构体 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左右孩子的指针 9 | struct treenode *lchild,*rchild; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //分配内存空间 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //赋值 22 | t->data=ch; 23 | //初始化 24 | t->lchild=NULL; 25 | t->rchild=NULL; 26 | //递归去赋值 27 | buildtree(t->lchild); 28 | buildtree(t->rchild); 29 | } 30 | } 31 | //转化函数 32 | void toexp(tree t,int deep) 33 | { 34 | if(t==NULL) return; 35 | else if(t->lchild==NULL&&t->rchild==NULL) 36 | { 37 | cout<data; 38 | } 39 | else 40 | { 41 | if(deep>1) cout<<"("; 42 | toexp(t->lchild,deep+1); 43 | cout<data; 44 | toexp(t->rchild,deep+1); 45 | if(deep>1) cout<<")"; 46 | } 47 | } 48 | //主函数测试 49 | int main() 50 | { 51 | tree t; 52 | buildtree(t); 53 | toexp(t,1); 54 | return 0; 55 | } 56 | 57 | /* 58 | 59 | * 60 | + * 61 | a b c - 62 | *+a##b##*c##-#d## 63 | 64 | + 65 | * - 66 | a b - 67 | c d 68 | 69 | +*a##b##-#-c##d## 70 | 71 | 72 | + 73 | a b 74 | +a##b## 75 | */ -------------------------------------------------------------------------------- /chapter5/P175_4.cpp: -------------------------------------------------------------------------------- 1 | //P175(4)编程求以孩子兄弟表示法存储的森林的叶子结点数。 2 | #include 3 | using namespace std; 4 | //结构体 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左孩子域 右兄弟域 指向 9 | struct treenode *child,*rbro; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //分配内存 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //赋值 22 | t->data=ch; 23 | //初始化 24 | t->child=NULL; 25 | t->rbro=NULL; 26 | //递归赋值 27 | buildtree(t->child); 28 | buildtree(t->rbro); 29 | } 30 | } 31 | //递归找叶子结点 32 | int leaves(tree t) 33 | { 34 | //空结点 返回0 35 | if(t==NULL) return 0; 36 | //孩子为空即左孩子域为空 为叶子结点 结果加1还要加上右兄弟子树的叶子结点 37 | if(t->child==NULL) return 1+leaves(t->rbro); 38 | //有孩子 结果为左孩子子树和右兄弟子树的叶子结点个数之和 39 | else return leaves(t->child)+leaves(t->rbro); 40 | } 41 | //主函数测试 42 | int main() 43 | { 44 | tree t; 45 | buildtree(t); 46 | cout< 3 | using namespace std; 4 | //结构体 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左孩子域 右兄弟域 指针 9 | struct treenode *child,*rbro; 10 | }treenode,*tree; 11 | //建树 12 | void buildtree(tree &t) 13 | { 14 | char ch; 15 | cin>>ch; 16 | if(ch=='#') t=NULL; 17 | else 18 | { 19 | //分配空间 20 | t=(treenode *)malloc(sizeof(treenode)); 21 | //赋值 22 | t->data=ch; 23 | //初始化 24 | t->child=NULL; 25 | t->rbro=NULL; 26 | //递归赋值 27 | buildtree(t->child); 28 | buildtree(t->rbro); 29 | } 30 | } 31 | //递归计算深度 32 | int height(tree t) 33 | { 34 | //空树 返回0 35 | if(t==NULL) return 0; 36 | else 37 | { 38 | //递归计算左孩子子树高度 39 | int l=height(t->child); 40 | //递归计算右兄弟子树高度 41 | int r=height(t->rbro); 42 | return max(l+1,r); 43 | } 44 | } 45 | //主函数测试 46 | int main() 47 | { 48 | tree t; 49 | 50 | buildtree(t); 51 | cout< 3 | using namespace std; 4 | //结构体 5 | typedef struct treenode{ 6 | //结点值 7 | char data; 8 | //左右孩子指针 左孩子右兄弟 9 | struct treenode *child,*rbro; 10 | }treenode,*tree; 11 | //构造链表 12 | void creat(tree &t,char e[],int degree[],int n) 13 | { 14 | 15 | //动态申请结点数组 16 | tree *point=new tree[10]; 17 | for(int i=0;idata=e[i]; 23 | point[i]->child=point[i]->rbro=NULL; 24 | } 25 | //孩子结点序号 26 | int k=0; 27 | //按照给的结点顺序访问结点 28 | for(int i=0;ichild=point[k]; 39 | //剩余的孩子 每个结点依次为前一个结点的兄弟结点 40 | for(int j=2;j<=d;j++) 41 | { 42 | //孩子序号递增 43 | k++; 44 | //前一个结点的右兄弟指针指向现在孩子序号的结点 45 | point[k-1]->rbro=point[k]; 46 | } 47 | } 48 | } 49 | t=point[0]; 50 | 51 | //链表的头为第一个结点 52 | delete [] point; 53 | //动态申请的内存要进行一个释放 防止内存泄漏 54 | 55 | } 56 | //输出最后孩子兄弟表示的树的先序序列进行验证 57 | void disp(tree t) 58 | { 59 | if(t) 60 | { 61 | cout<data<<" "; 62 | disp(t->child); 63 | disp(t->rbro); 64 | } 65 | } 66 | 67 | //主函数测试 68 | int main() 69 | { 70 | //树 71 | tree t; 72 | //层次遍历序列 73 | char e[8]="ABCDEFG"; 74 | //每个结点度数数组 75 | int degree[8]={3,2,1,0,0,0,0}; 76 | //构造这样的函数 77 | creat(t,e,degree,7); 78 | //输出这样的二叉树验证 79 | disp(t); 80 | return 0; 81 | } 82 | 83 | /* 84 | 85 | A 86 | B C D 87 | E F G 88 | 89 | A 90 | B 91 | E C 92 | F G D 93 | 94 | ABCDEFG 95 | 3210000 96 | 先序:ABECFGD 97 | 98 | */ --------------------------------------------------------------------------------