qq_44700756的博客

#include <string.h>#include <stdlib.h>#include <iostream>#define N 20#define MAX 10000 typedef struct { char word[N]; int count; }Word;int check(char ch){ if((ch>='A' && ch<='Z') || (ch>='a' && ch<

#include <string.h>#include <stdlib.h>#include void swap(char *a,char *b){char tmp=*a;*a=*b;*b=tmp;}void AllRange(char *str,int k,int m){if(k==m){printf("%s
",str);}else{int i;for(i=k;i<=m;i++){swap(&str[i],&str[

#include <string.h>#include <stdlib.h>#include <iostream> void swap(char *a,char *b){ char tmp=*a; *a=*b; *b=tmp;} void AllRange(char *str,int k,int m){ if(k==m) { static int s_i=1; printf("第%d个排列是%s
",s_i++,str); } e

#include <string.h>#include <stdlib.h>#include <iostream>void Combine(int n,int r,char a[],int b[],int R){ if(r==0) { int i=0; while(i<R) { printf("%c",a[b[i++]]); } printf("
"); } else { int j; for(j=n;j&

根据前缀表达式构建一个二叉树，其后序遍历就是它的后缀表达式建树：从前缀表达式第一位往后建#include <string.h>#include <stdlib.h>#include <iostream> typedef struct btnode{ char data; struct btnode *lchild; struct btnode *rchild;}btnode;char A[]="*+ab/cd";int n=strlen(A)

根据后缀表达式构建一个二叉树，其前序遍历就是它的前缀表达式#include <string.h>#include <stdlib.h>#include <iostream> typedef struct btnode{ char data; struct btnode *lchild; struct btnode *rchild;}btnode;char A[]="abc*+def/*/";int n=strlen(A)-1;int ju

/中缀转前缀：进栈元素：) + * - /进栈规则：从后往前扫中缀表达式若栈顶元素比目前元素的优先级小，出栈，直到优先级相等；若栈顶元素与当前元素优先级相等，入栈；若当前元素为’)‘入栈若当前元素为’(’，出栈顶元素直到遇到’)‘位置，并且’('不表达遇到操作数直接入栈/#include <stdio.h>#include <math.h>#include <stdlib.h> #define N 10void fun(char A[]){ c

/前缀表达式计算：中缀表达式为 a-(b+c)(d/e) 前缀表达式为 -a*+bc/de中缀表达式储存在数组A[]中，创建栈stack[]，从后往前扫，从数组中取出字符，遇到数字进栈，遇到运算符就出栈两次，进行计算，计算结果入栈注意字符类型转换*/#include <stdio.h>#include <math.h>#include <stdlib.h>#define N 100int judge_char(char c){ switch(c) {

计算中缀表达式、中缀转后缀表达式、中缀转前缀表达式一般思想：两个栈：临时存储stack[ ], 结果存储result[ ]stack进栈元素：计算中缀表达式，中缀转后缀 ：( + * - /中缀转前缀：） + * - /stack进栈规则：计算中缀表达式，中缀转后缀：从前往后扫表达式若当前元素为’(‘入栈若当前元素为’)’，出栈顶元素直到遇到’(‘位置，并且’)'不表达中缀转前缀：从后往前扫表达式若当前元素为’）‘入栈 ，若当前元素为’（’，出栈顶元素直到遇到’）‘位置，并且’（'

/中缀转后缀：进栈元素：( + * - /进栈规则：若栈顶元素比自己的优先级小，出栈，直到优先级相等；若栈顶元素优先级相等，入栈；若当前元素为’(‘入栈 ，若当前元素为’)’，出栈顶元素直到遇到’(‘位置，并且’)'不表达遇到操作数直接表达/#include <stdio.h>#include <math.h>#include <stdlib.h> #define N 10void fun(char A[]){ char stack[N]; in

/*中缀表达式计算：中缀表达式为 （a+b)*c中缀表达式储存在数组A[]中，创建栈stack1[]用来存放运算符，从数组中取出字符：如果是’+’ ‘-’,栈顶元素出栈，直到栈空或者 ‘**’ ‘/’,再入栈如果是 * ‘/’,如果栈顶是 * /,出栈直到栈空或者 * /，再入栈如果是’(‘入栈如果是’)'出栈直到遇到 ‘(’创建stack2[ ]用来存放数字注意字符类型转换 */#include <stdio.h>#include <math.h>#i

/后缀表达式计算：中缀表达式为 a-(b+c)(d/e) 后缀表达式为 abc+de/-后缀表达式储存在数组A[]中，创建栈stack[]，从数组中取出字符，遇到数字进栈，遇到运算符就出栈两次，进行计算，计算结果入栈注意字符类型转换/#include <stdio.h>#include <math.h>#include <stdlib.h>#define N 9 int judge_char(char c){ switch(c) { case

#include <stdio.h>#include <stdlib.h>#include <string.h>#define N 100typedef struct btnode{ char data; btnode *lchild; btnode *rchild; }btnode;btnode *create_tree(char pre_order[],char in_order[],int pre_l,int pre_r,int in_l,i

#include <stdio.h>#include <stdlib.h>#include <string.h>#define N 100/*一棵具有n个节点的完全二叉树以顺序方式存储在数组A[]中，设计一个算法构造二叉树的二叉链式存储结构构造函数，传入数组A，传入根节点bt,bt->data=i,bt->lchild->data=2*i+1,bt->rchild->data=2*i+2*/typedef struct btno

#include <stdio.h>#include <stdlib.h>#define N 100/*二叉树非递归*/ typedef struct btnode{ char data; btnode *lchild; btnode *rchild; }btnode;int i=0;int aa[]={55,10,7,-1,-1,22,-1,-1,66,-1,100,-1,-1};char bt[]={'a','b','c','#','#','d','g

#include <stdio.h>#include <stdlib.h>#define N 100/*二叉树非递归*/ typedef struct btnode{ char data; btnode *lchild; btnode *rchild; }btnode;int i=0;int aa[]={55,10,7,-1,-1,22,-1,-1,66,-1,100,-1,-1};char a[]={'a','b','c','#','#','d','#'

#include <stdio.h>/Dijkstra算法：解决最短路径问题，从一个初始点v0出发，设置lowcost[]数组，记录初始点到每一个顶点的最短路径，设置path[]数组记录初始点到每个点最短路径所经过的每一个点，设置visit[]数组，记录已经选入lowcost数组的点设置为 1 ，下次经过不再选中。思想：选择初始点v，遍历每个点，若两个点之间存在路径，记录权值到lowcost数组，然后对每个点进行判断，每次挑选一个最小权值进入lowcost数组并更新最小边/#defin

/直接插入排序：对数组中未排好序的序列向排好序的序列进行插入，从排好序的序列最后一位向前找，直到找到比他小的元素插入到它后面用一个暂时变量代表目标元素，每一个比它大的都往后移动一位传入数组a[ ],大小 n/#include <stdio.h>void insert_sort(int a[],int n){ int i,j,temp; for(i=1;i<n;++i) { temp=a[i]; for(j=i-1;j>=0;--j) { if(te

/*冒泡排序：目标数字，与前一个数字就行比较，如果前一个较大，则交换一下从数组第一位向最后一位进行冒泡，每完成一次，最后一位减一 ,如果一次排序没有发生交换，则排序完成break传入数组a[ ]，大小 n */#include <stdio.h>void pop_sort(int a[],int n){ int i,j,temp; int tag; for(i=n-1;i>=1;--i) { j=1;tag=0; while(j<=i) { if

/快速排序：每次选择一个基点，进行排序，基点左边都小于它，右边都大于它传入数组，左边界，右边界/#include <stdio.h>void quick_sort(int a[],int Left,int Right){ int L=Left,R=Right; int tag=a[L]; if(L>=R) return; else { while(L<R) { while(a[R]>=tag && L<R) R--;