本文介绍了多种编程算法，包括使用二分查找法在有序数组中寻找特定值，递归和非递归实现斐波那契数列，字符串排序，哈夫曼编码，以及计算四则运算表达式的值。还涉及了数组反转、字符串定位、图的路径查找等算法问题。
1 二分查找返回关键值key在长度为len的数组arr[]中的位置，没有key则返回-1
（1） int bi_search( int key, int arr[], int len )
int bi_search( int key, int arr[], int len )
{
int low=0;
int high=len-1;
int mid;
while(low<=high){
mid=(low+high)/2;
if(key==arr[mid]){
return mid;
}
else if(key<arr[mid]){
high=mid-1;
}
else{
low=mid+1;
}
}
return -1;
}
2 实现指定整数的三种查询方法：
- int linear_search( int arr[], int len, int key )
int linear_search(int arr[],int len,int key){
int m=-1;
for(int i=0;i<len;i++){
if(arr[i]==key)
m=i;
}
return m;
}
- int better_search( int arr[], int len, int key )
int better_search(int arr[],int len,int key){
for(int i=0;i<len;i++){
if(arr[i]==key) {
return i;
}
}
return -1;
}
- int sentinel_linear_search( int arr[], int len, int key )
int sentinel_linear_search( int arr[], int len, int key ){
int last = arr[len-1];
arr[len-1] = key;
int i = 0;
while(arr[i]!=key){
i++;
}
arr[len-1] = last;
if(i < len-1 || last == key){
return i;
}
return -1;
}
3 用递归的方法求解斐波那契数列第n项的值：
（1）long fib( int n ) // 返回斐波那契数列第n项的值
long fib( int n ){
if(n <= 0) {return -1;}
if(0 < n && n < 3) {return n-1 == 0 ? 0 :1;} //斐波那契数列为:0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610....
return fib(n-1) + fib(n-2);
}
4 数组反转，给定长度为len的数组arr[]，请将里面的元素反转，
如开始为{1,5,6,2,6,7,8} 反转后为{8,7,6,2,6,5,1}
（1）void reverse( int arr[], int len )
void reverse( int arr[], int len ){
for(len--;len>=0;printf("%d ",arr[len--]));
}
5 给定一个字符串，若里面含有相同的字母则返回1，否则返回0.
（1）
int hasDup(char arr[]){
int arr1[999];
for(int i=0;i<sizeof(arr)-1;i++){
arr1[i]=arr[i]-'0';
}
int n = sizeof(arr);
for(int i=0; i<n-1; i++){
for(int j=i+1; j<n; j++) {
if (arr1[j] == arr1[i])
return 1;
}
}
return 0;
}
难度：2
1 递归实现：二分查找返回关键值key在长度为len的数组arr[]中的位置，没有key则返回-1
- int rec_bi_search( int key, int arr[], int low, int high )
int rec_bi_search( int key, int arr[], int low, int high ){
if(low > high) {
return -1;
}
int mid = (low + high)/2;
int midVal = arr[mid];
if(key > midVal) {
return rec_bi_search(key,arr, mid+1, high);
}else if(key < midVal) {
return rec_bi_search(key,arr, low, mid-1);
}else {
return mid;
}
}
2 用优化递归方法，求解斐波那契数列第n项的值：
（1）long fib( int n, long result[], int len )
返回斐波那契数列第n项的值,，result[i]存储第i项的值，len是result的长度。
long fib( int n, long result[], int len ){
if(n < len){
if(result[n] == -1) {
result[n] = fib(n-1,result,len) + fib(n-2,result,len);
}
return result[n];
}
return fib(n-1,result,len) + fib(n-2,result,len);
}
3 用选择排序的方法实现对整型数据由小到大进行排序
（1）void select_sort( int arr[], int len )
arr为数组名，len为数组的长度。
void select_sort(int arr[],int len){
for (int i = len-1; i>0; i--){
int max = i;
for (int j = 0; j<i; j++)
{
if (arr[j]>arr[max]) max = j;
}
if(max!=i){
int tmp = arr[i];
arr[i] = arr[max];
arr[max] = tmp;
}
}
}
4 用插入排序的方法实现对整型数据由小到大进行排序
void insert_sort( int arr[], int len )
arr为数组名，len为数组的长度。
void insert_sort( int arr[], int len ){
int i,j,key;
for(i = 1;i < len;i++){
key = arr[i];
j = i - 1;
while((j >= 0)&&(arr[j] >= key)){
arr[j+1] = arr[j];
j--;
}
arr[j+1] = key;
}
}
难度：3
1 判断字符串中的括号是否正确匹配，如正确的匹配()、()[]{}、{[]}、{([])}、错误的匹配{)、{[)}等等
正确返回1，错误返回0
（1）int IsMatch（char *str,int start,int end）
int IsMatch(char *str, int start, int end){
char chLeft; // 左括号
char chRight; // 右括号
while((start<=end) && (str[start] != '\0')){
switch(str[start]){
case '(':
chLeft = str[start];
chRight = ')';
break;
case '[':
chLeft = str[start];
chRight = ']';
break;
case '{':
chLeft = str[start];
chRight = '}';
break;
case ')':
case ']':
case '}':
return 0;
default:
chLeft = '\0';
break;
}
if(str[start] == chLeft){
int a = 1;
int b=0;
int t = start+1;
while((t<=end) && (str[t] != '\0')){ // 搜索匹配的右括号
if(str[t] == chLeft)
++a;
if(str[t] == chRight)
++b;
if(b>a)
return 0;
if(a == b){ // 再对匹配括号里面的括号进行匹配
if(0 == IsMatch(str, start+1, t-1)) // 递归调用
return 0;
start=t;
break;
}
++t;
}
if(a>b)
return 0;
}
++start;
}
return 1;
}
2 用快速排序的方法实现对整型数据由小到大进行排序
（1）void quick_sort(int arr[],int low,int high)
void quick_sort(int arr[], int low, int high) {
int start;
int end;
int key = arr[low];
int i=0;
while(arr[i]<=key&&i<=high){
i++;
}
start=end=i;
for(i=i+1;i<=high;i++){
if(arr[i]>key){
end++;
}
else{
int temp = arr[start];
arr[start] =arr[i];
arr[i] =temp;
start++;
end++;
}
}
printf("%d\n",start);
printf("%d\n",end);
int tmp = arr[start-1];
arr[start-1] = arr[low];
arr[low]=tmp;
if(low!=high&&low<high){
quick_sort_2(arr, low, start-1);
quick_sort_2(arr, start, high);
}
}
3 给定长度为len的数组arr，打印出数组元素的所有排序。
如arr[4]={3,5,2,7},则输出这4个整数的24种排列形式
- void Perm(int a[],int n,int s,int r[],int m)
主函数执行：Perm(a,n,0,r,n);
void Perm(int a[], int n, int s, int r[], int m) {
int i, j, k, flag = 0;
int b[100];
for (i = 0; i < n; ++i) {
flag = 1;
r[s] = a[i];
j = 0;
for (k = 0; k < n; k++)
if (i != k) {
b[j] = a[k];
j++;
}
Perm(b, n - 1, s + 1, r, m);
}
if (flag == 0) {
printf("\n");
for (k = 0; k < m; k++)
printf("%d", r[k]);
}
}
4 字符串定位:返回字符串str，在字符串dest中出现的位置（第一个字母）,没有出现则返回-1
（1）int locate（char* dest,char* str）
例如 locate( "fadbabdabcda" ,"abc") 则返回7
int locate(char* dest,char* str){
if(dest==NULL||str==NULL){//先检查是否为空
printf("这是一个空字符串\n");
return-1;
}
int origStrLen=strlen(dest);
int targetLen=strlen(str);
int pos=-1;
int prePos=pos;
int i=0;
int j=0;
while(i<origStrLen && j<targetLen){//i,j都从0开始
if(dest[i]==str[j]){
++i;
++j;
}
else{
i=i-j+1;//i退回到上次匹配首位的下一位
j=0;//每次从头开始从新查找子串
}
}
if(j==targetLen)//判断j是否等于targetLen如果是则可以获取位置
{
prePos=pos;
pos=i-j;//获取第一个匹配的位置
}
return pos;
}
难度：4
1 计算正确的四则整形运算表达式的值。输入一个正确四则整形运算表达式字符串，输出计算结果（除法可以直接执行整数除，不考虑小数，如5/4等于1）。如输入“(17+3)/4+2"，输出7。
（1）
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define n 50
//数字栈
typedef struct nodeFirst{
int a[n];
int size;// 表示栈中含有的元素数量
} stackFirst;
//符号栈
typedef struct nodeSecond{
char a[n];
int size;
} stackSecond;
//数字栈出栈
int pop(stackFirst *p) {
if (p -> size == 0)
//printf("空栈");
return 0;
else {
--(p -> size);
return p -> a[p -> size];
}
}
//符号栈出栈
char popSecond(stackSecond *p) {
if (p -> size == 0)
return 0;
else {
--(p -> size);
return p -> a[p -> size];
}
}
//返回数字栈栈顶元素
int top(stackFirst *p) {
if (p -> size == 0)
return 0;//输出0表示空
else {
return p -> a[p -> size - 1];
}
}
//返回符号栈栈顶元素
char topSecond(stackSecond *p) {
if (p -> size == 0)
return 0;//输出0表示空
else {
return p -> a[p -> size - 1];
}
}
//将数字栈置空
int empty(stackFirst *p) {
return p -> size == 0;
}
//将符号栈置空
int emptySecond(stackSecond *p) {
return p -> size == 0;
}
//数字栈入栈
void push(stackFirst *p, double b) {
p -> a[p -> size] = b;
++p -> size;
}
//符号栈入栈
void pushSecond(stackSecond *p, char b) {
p -> a[p -> size] = b;
++p -> size;
}
//比较符号优先级
int compare(char str) {
if (str == '+' || str == '-') {
return 1;
} else if (str == '*' || str == '/') {
return 2;
} else {
return 0;
}
}
//计算
int counter(int x, int y, char str) {
int ans = 0;
if (str == '-') {
ans = x - y;
} else if (str == '+') {
ans = x + y;
} else if (str == '*') {
ans = x * y;
} else {
ans = x / y;
}
return ans;
}
主函数：
int main(void) {
//数字栈
stackFirst *first;
first = (stackFirst *) malloc(sizeof(stackFirst));
first -> size = 0;
//符号栈
stackSecond *second;
second = (stackSecond *) malloc(sizeof(stackSecond));
second -> size = 0;
char a[100];
printf("请输入需要计算的算术表达式：\n");
scanf("%s", a);
int length = (int)strlen(a);
//在用户所输入的式子后面加‘#’号
a[length] = '#';
length = length + 1;
int i = 0;
int x = 0;
//出栈用于计算的符号
char strtest;
//出栈用于计算的数字
int numFirst, numSecond;
//用于保存当次计算结果
int res;
while (a[i] != '#') {
x = 0;
//如果是数字就入数字栈
if (a[i] >= '0' && a[i] <= '9') {
while (a[i] >= '0' && a[i] <= '9') {
x *= 10;
x += a[i++] - '0';
}
//数字进栈
push(first, x);
continue;
}
//如果是符号，且符号栈为空，符号直接进符号栈
if (second -> size == 0 && (a[i] == '+' || a[i] == '-' || a[i] == '*' || a[i] == '/' || a[i] == '(' || a[i] == ')')) {
pushSecond(second, a[i]);
++i;
continue;
}
//如果是左括号，直接入栈
if (a[i] == '(') {
pushSecond(second, a[i]);
++i;
continue;
}
//如果是右括号，循环取出符号栈中的符号，跟数字栈中两个数字参与运算后入数字栈，直到碰到左括号为止
if (a[i] == ')') {
while (topSecond(second) != '(') {
strtest = popSecond(second);
numFirst = pop(first);
numSecond = pop(first);
res = counter(numSecond, numFirst, strtest);
//计算结果入数据栈
push(first, res);
}
//左括号出栈
popSecond(second);
++i;
continue;
}
//最后一种情况是要入符号栈
while (compare(a[i]) <= compare(topSecond(second))) {
strtest = popSecond(second);
numFirst = pop(first);
numSecond = pop(first);
res = counter(numSecond, numFirst, strtest);
//计算结果入数据栈
push(first, res);
}
//入符号栈
pushSecond(second, a[i]);
++i;
}
//如果符号栈还不为空的情况
while (second -> size > 0) {
strtest = popSecond(second);
numFirst = pop(first);
numSecond = pop(first);
res = counter(numSecond, numFirst, strtest);
//计算结果入数据栈
push(first, res);
}
//输出最终计算结果
printf("%d\n", top(first));
return 0;
}
2 对n个等长(长度为len)的字符串进行字典顺序排序
（1）sort_str( char str[80][80], int len, int n )
void sort_str(char str[80][80],int len,int n){
int i,j;
char s[999];
for(i=0; i<n-1; i++)
for(j=0; j<len-i-1; j++)
if(strcmp(str[j],str[j+1])>=0){
strcpy(s,str[j]);
strcpy(str[j],str[j+1]);
strcpy(str[j+1],s);
}
}
3 建立10个节点的有向图，由用户输入节点对来完成。由用户指定一个源点,输出所有与之连通的所有结点的最短路径及路径长度。
#define N 10
int graph[N][N];
int shortest[N];
int pred[N];
（1）void create_graph( void )
（2）void dijkstra(int source,int graph[][N],int shortest[N],int pred[N])
（3）void show_shortest_path(int source,int shortest[],int pred[])
（1）
void create_graph(void){
int graph[N][N];
int shortest[N],pred[N];
int index = 0;
printf("请输入各个节点的路径：\n");
for(int i = 0;i<N;i++){
for(int j = 0;j<N;j++){
scanf("%d,",&graph[i][j]);
}
}
for(int i = 0;i<N;i++){
shortest[i] = 99999;
pred[i] = -1;
}
printf("请输入源点\n");
scanf("%d",&index);
dijkstra(index,graph,shortest,pred);
}
（2）
void dijkstra(int source,int graph[][N],int shortest[N],int pred[N]){
int i=0,min;
shortest[source] = 0;
while(i<N){
for(int j=0;j<N;j++){
if (graph[source][j] < 99999 && graph[source][j] + shortest[source] < shortest[j]) {
shortest[j] = graph[source][j] + shortest[source];
pred[j] = source;
min = j;
}
}
shortest[source]= -shortest[source];
for(int k = 0;k<N;k++){
if((shortest[k]>0&&shortest[k]<shortest[min])||shortest[min]<0){
min = k;
}
}
source = min;
i++;
}
show_shortest_path(source,shortest,pred);
}
（3）
void show_shortest_path(int source,int shortest[],int pred[]){
for(int i=0;i<N;i++){
int j =i;
if(i==source) continue;
printf("%4d->%4d的倒序路径为 %d",source,j,i);
while(pred[j]>0&&pred[j]!=source){
printf("%d,",pred[j]);
j = pred[j];
}
printf("%d\n",source);
}
}
4 利用数组实现堆的三种基本操作，
（1）插入元素：void insert( int x, int heap[], int len)
（2）删除元素：int delete( int heap[], int len )
（3）更新元素：void update( int x, int pos, int heap[], int len )
x 为插入或新元素， heap为堆，len是堆的尺寸，pos是新元素的位置。
（1）
void insert(int x,int heap[],int len){
len++;
heap[len]=x;
while(heap[(len)/2]>x&&len>1){
heap[len] = heap[(len)/2];
heap[(len)/2] = x;
len = len/2;
}
heap[0]++;
}
（2）
void insert(int x,int heap[],int len){
len++;
heap[len]=x;
while(heap[(len)/2]>x&&len>1){
heap[len] = heap[(len)/2];
heap[(len)/2] = x;
len = len/2;
}
heap[0]++;
}
（3）
void insert(int x,int heap[],int len){
len++;
heap[len]=x;
while(heap[(len)/2]>x&&len>1){
heap[len] = heap[(len)/2];
heap[(len)/2] = x;
len = len/2;
}
heap[0]++;
}
5 输入一段文本，打印输出对应的哈夫曼编码：
（1）void hfm()
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 128
#define INF 0x3f3f3f3f
typedef struct {
char c;
unsigned int weight ;
unsigned int parent, lchild, rchild ;
}HTNode, *HuffmanTree; //按照教材定义Huffmantree
typedef char ** HuffmanCode; //Huffman编码表
char appearChar[N + 1]; //出现的字符
unsigned int charIdx[N+1]; //按照ascii值为下标，找在Huffman编码表中的下标
unsigned int charCount[N + 1]; //字符的出现次数，按照ascii值为下标
int cnt = 0; //总共出现的字符数
HuffmanTree HT;
HuffmanCode HC;
void Select(int n, int* s1, int* s2) { //选择最小的两个节点
int min1 = INF; //最小
int min2 = INF; //次小
int x,y,i; //下标
for (i = 1; i <= n; i++) {
if (HT[i].parent == 0) {
if (HT[i].weight <= min1) {
min2 = min1;
min1 = HT[i].weight;
y = x;
x = i;
}else if (HT[i].weight < min2) {
min2 = HT[i].weight;
y = i;
}
}
}
*s1 = x;
*s2 = y;
}
void HuffmanCoding(const int n) {
int m, i, s1=0, s2=0, c, f;
HTNode* p;
char* cd;
if (n <= 1) return;
m = 2 * n - 1;
HT = (HTNode*)malloc((m + 1) * sizeof(HTNode));
//初始化
for (p = HT,i = 1; i <= n; i++) {
p[i].c = appearChar[i];
p[i].weight = charCount[appearChar[i]];p[i].lchild = 0;
p[i].rchild = 0;p[i].parent = 0;
}
for (; i <= m; i++) {
p[i].weight = 0;p[i].lchild = 0;
p[i].rchild = 0;p[i].parent = 0;
}
for (i=n+1; i<=m; ++i) { //建树
Select (i-1, &s1, &s2);
HT[s1].parent = i; HT[s2].parent = i;
HT[i].lchild = s1; HT[i].rchild = s2;
HT[i].weight = HT[s1].weight + HT[s2].weight;
}
HC = (HuffmanCode)malloc((n + 1) * sizeof(char*));
cd = (char*)malloc(n * sizeof(char));
cd[n - 1] = '\0';
for (i = 1; i <= n; i++) {
int start = n - 1;
for (c = i, f = HT[i].parent; f != 0; c = f, f = HT[f].parent) {
if (HT[f].lchild == c)
cd[--start] = '0';
else
cd[--start] = '1';
}
HC[i] = (char*)malloc((n - start) * sizeof(char));
strcpy(HC[i], &cd[start]);
}
free(cd);
}
void hfm(){
printf("请输入字符串：\n");
char str[10000];
getchar();
scanf("%[^\n]",str);
for(int i=0;str[i]!=0;i++){
if(charCount[str[i]]==0){
appearChar[++cnt]=str[i];
charIdx[str[i]]=cnt;
}
charCount[str[i]]++;
}
HuffmanCoding(cnt);
printf("\n字符串的Huffman编码为：\n");
int num=0;
for(int i=0;str[i]!=0;i++){
char *tp=HC[charIdx[str[i]]];
for(int j=0;tp[j]!=0;j++){
printf("%c",tp[j]);
num++;
if(num%100==0) puts("");
}
}
}
主函数：
int main(){
hfm();
return 0;
}
6 建立6个节点的无向图。由用户指定一个源点、一个终点，输出从源点到终点的所有路径及长度。
（1）
#include<stdio.h>
#include <malloc.h>
#define maxn 10
//栈的结构体
typedef struct
{
int top;
int num[maxn];
}Stack;
//邻接表的边结点
typedef struct
{
int data;
int quan;
struct Arcnode* next;
}Arcnode;
//邻接表的头结点
typedef struct
{
int data;
Arcnode* first;
}Vnode;
//图的结构体
typedef struct
{
int vexnum,arcnum;
Vnode Vnode[maxn];
}ALGraph;
//图的创建
int CreateGraph(ALGraph *G){
int i;
//先输入图的点数和边数
printf("请输入图的点数和边数\n");
scanf("%d%d",&G->vexnum,&G->arcnum);
for(i=0;i<G->vexnum;i++){
printf("请输入第%d个顶点的值\n",i+1);
scanf("%d",&G->Vnode[i].data);
G->Vnode[i].first=NULL;
}
for(i=0;i<G->arcnum;i++){
int j,k;
Arcnode* p,*q;
printf("请输入第%d条边的两个点\n",i+1);
scanf("%d%d",&j,&k);
p = (Arcnode*)malloc(sizeof(Arcnode));
p->data = k;
p->next = G->Vnode[j].first;
G->Vnode[j].first = p;
q = (Arcnode*)malloc(sizeof(Arcnode));
q->data = j;
q->next = G->Vnode[k].first;
G->Vnode[k].first = q;
}
}
//初始化栈
Stack* init(){
Stack *s;
s = (Stack*)malloc(sizeof(Stack));
if(s==NULL){
printf("分配失败\n");
return 0;
}
s->top=-1;
return s;
}
void push(Stack *s,int v){
if(s->top == maxn -1)
return;
s->num[++s->top] = v;
}
int pop(Stack *s){
if(s->top == -1)
return 0;
else
return s->num[s->top--];
}
//查看顶点是否在栈中
int check(Stack *s,int v){
int i;
for(i=0;i<=s->top;i++){
if(v==s->num[i])
return 1;
}
return 0;
}
//输出栈内数据，也就是路径
void show(Stack* s){
int m = s->top;
int a = 0;
while(a<=m){
if(a<m) printf("%d->",s->num[a++]);
else printf("%d",s->num[a++]);
}
printf("\n");
}
//找到该结点紧邻的第一个顶点
int findfirst(ALGraph *G,int i){
Arcnode *p;
if(G->Vnode[i].first){
p=G->Vnode[i].first;
return p->data;
}
else{
return -1;
}
}
//找到该结点紧邻的下一个顶点
int findnext(ALGraph *G,int i,int v){
Arcnode *p,*q;
if(G->Vnode[v].first){
p=G->Vnode[v].first;
while(p->data!=i)
p=p->next;
q = p->next;
if(q){
return q->data;
}
else
return -1;
}
else
return -1;
}
//深度优先算法
void DFS(int B,int E,Stack* s,ALGraph *G){
int i;
push(s,B);
if(E==B){
show(s);
pop(s);
return;
}
for(i=findfirst(G,B);i!=-1;i=findnext(G,i,B)){
if(check(s,i)&&i!=E)
continue;
DFS(i,E,s,G);
}
pop(s);
}
主函数：
int main(){
ALGraph G;
Stack *s;
s = init();
CreateGraph(&G);
DFS(2,5,s,&G);
}
7 在2行5列的格子中填入1到10的数字。要求：相邻的格子中的数，右边的大于左边的，下边的大于上边的。请你计算一共有多少种可能的方案，并输出所有的方案。
（1）
#include<stdio.h>
int map[3][6];
int flag[15];
int sum=0;
int check(){
int i,j;
for(i=0;i<2;i++)
for(j=0;j<5;j++){
if((map[i][j]>map[i][j+1]) || (map[i][j]>map[i+1][j]))
return 0;
}
return 1;
}
void dfs(int count){
int i,j;
if (count==10){
if(check()){
for(i=0;i<2;i++){
for(j=0;j<5;j++)
printf("%d ",map[i][j]);
printf("\n");
}
printf("\n");
sum++;
}
return;
}
{
for(i=1;i<=10;i++){
if(!flag[i]){
flag[i]=1;
map[count/5][count%5]=i;
dfs(count+1);
flag[i]=0;
}
}
}
}
int main (){
int i;
map[0][5]=map[1][5]=100;
for(i=0;i<5;i++)
map[2][i]=100;
dfs(0);
printf("总共方案数量为：%d\n",sum);
return 0;
}
难度：5
1 计算四则运算表达式的值。输入一个正确四则运算表达式字符串，表达式正确则输出计算结果，错误则给出提示。
（1）
#include<stdio.h>
#include<string.h>
#include <ctype.h>
int a[100001];//存储符号
char b[100001];//存储数字
char c[100001];//中转栈
int topc=-1;
int topab=-1;
int ji[10001];
topj=-1;
char s[100001];
int pan(int len){
int i;
int t;
int acc=0,bcc=0;
for(i=0;i<len-1;i++){
if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/'){
if(s[i+1]=='+'||s[i+1]=='-'||s[i+1]=='*'||s[i+1]=='/')
return 1;
}
else if(s[i]==')'){
if(s[i+1]=='(')
return 1;
}
else if(s[i]=='('){
if(s[i+1]==')')
return 1;
}
}
if(s[len-1]=='+'||s[len-1]=='-'||s[len-1]=='*'||s[len-1]=='/')
return 1;
for(i=len-1;i>=0;i--){
if(s[i]==')')
bcc++;
else if(s[i]=='(')
acc++;
}
if(acc!=bcc){
return 1;
}
char pei[10001];
int toppei=-1;
i=0;
while(i<len){
if(s[i]=='('){
toppei++;
pei[toppei]=s[i];
i++;
}
else if(s[i]==')'&&toppei>=0){
toppei--;
i++;
}
else if(s[i]==')'&&toppei==-1)
return 1;
else
i++;
}
if(toppei!=-1)
return 1;
return 0;
}
int main(){
int num=0;
int flag=0;
while(~scanf("%s",s)){
int len=strlen(s);
int i,j;
for(i=0;i<len;i++)
a[i]=9999;
//for(i=0;i<10;i++)
//printf("%d\n",a[i]);
flag=pan(len);
//printf("%d",flag);
i=0;
while(i<len&&flag!=1){
if(isdigit(s[i])==1){
while(isdigit(s[i])==1){
num*=10;
num+=s[i]-48;
i++;
}
topab++;
a[topab]=num;
num=0;
}
else if(s[i]=='('){
topc++;
c[topc]=s[i];
i++;
}
else if(s[i]==')'){
while(c[topc]!='('&&topc>=0){
topab++;
b[topab]=c[topc];//printf("%c\n",b[topab]);
topc--;
if(topc==-1){flag=1;break;}
}
topc--;
i++;
}
else{
if(s[i]=='-'){
if(i==0){
flag=1;
break;
}
else{
if(s[i-1]=='('){
flag=1;
break;
}
else{
while(c[topc]!='('&&topc>=0){
topab++;
b[topab]=c[topc];//printf("%c\n",b[topab]);
topc--;
if(topc==-1)
break;
}
topc++;
c[topc]=s[i];
i++;
}
}
}
else if(s[i]=='+'){
while(c[topc]!='('&&topc>=0){
topab++;
b[topab]=c[topc];//printf("%c\n",b[topab]);
topc--;
if(topc==-1)
break;
}
topc++;
c[topc]=s[i];
i++;
}
else if(s[i]=='*'||s[i]=='/'){
while((c[topc]=='*'||c[topc]=='/')&&topc>=0){
topab++;
b[topab]=c[topc];//printf("%c\n",b[topab]);
topc--;
if(topc==-1)
break;
}
topc++;
c[topc]=s[i];
i++;
}
}
}
while(topc>=0){
topab++;
b[topab]=c[topc];//printf("%c\n",b[topab]);
topc--;
}
for(i=0;i<=topab;i++){
if(a[i]!=9999){
topj++;
ji[topj]=a[i];
}
else{
if(topj-1>=0){
switch(b[i]){
case '+':ji[topj-1]=ji[topj-1]+ji[topj];topj--;break;
case '-':ji[topj-1]=ji[topj-1]-ji[topj];topj--;break;
case '*':ji[topj-1]=ji[topj-1]*ji[topj];topj--;break;
case '/':if(ji[topj]!=0){
ji[topj-1]=ji[topj-1]/ji[topj];
topj--;
}
else{
flag=1;
}
break;
default:break;
}
}
else{flag=1;break;}
}
}
if(flag==0){
if(ji[0]>=0)
printf("%d\n",ji[0]);
else
printf("error\n");
}
else{
printf("error\n");
}
flag=0;
topab=-1;
topj=-1;
}
return 0;
}
2 对n个不等长的字符串进行字典顺序排序，str为需要排序的字符串二维数组
（1）sort_str( char（* str）[100], int n )
#include <stdio.h>
#include<string.h>
void sort_str(char (*str)[100],int n){
int i,j;
for(i=0;i<n-1;i++){
for(j=0;j<n-i-1;j++){
if(strcmp(str[j+1],str[j])<0){
char t[100]={0};
strcpy(t,str[j]);
strcpy(str[j],str[j+1]);
strcpy(str[j+1],t);
}
}
}
}
主函数：
int main(){
int n;
printf("请需要排序的字符串数量并在下面依次输入需要排序的字符串：");
scanf("%d\n",&n);
getchar();
char str[n][100];
for(int i=0;i<n;i++){
gets(str[i]);
str[i][strlen(str[i])]='\0';
}
sort_str(str,n);
printf("排序后的字符串如下：\n");
for(int k=0;k<n;k++)
puts(str[k]);
return 0;
}
3 0-1背包问题。假设你有一个背包，最多能承重C千克，这里有k个物品，其重量分别为w1、w2、……、wk，在背包所能承受的重量下，尽可能得使背包里的物品重量最大。
（1）void bag(int weight,int thing[],int i,int solution[])
#include<stdio.h>
int x=0,y=0;
void bag(int weight,int thing[],int i,int solution[]){
int j=i;
if(weight==0){
printf("第%d种解法：",++x);
while(j--){
printf(" %d",solution[y++]);
}
printf("\n");
y=0;
return;
}
if(weight<0||thing[0]==0) return;
bag(weight,&thing[1],i,solution);
solution[i]=thing[0];
bag(weight-thing[0],&thing[1],++i,solution);
}
主函数：
int main(void){
int weight,number,i;
int thing[30]={0},solution[30]={0};
printf("请输入背包装载量和物品个数：\n");
scanf("%d %d",&weight,&number);
printf("请输入各物品的重量:\n");
for(i=0;i < number;++i)
scanf("%d",&thing[i]);
i=0;
bag(weight,thing,i,solution);
if(!x) printf("无解！！！");
return 0;
}
扫一扫
1246
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
