oj习题

以下oj练习均独立完成

统计单词：

编一个程序，读入用户输入的，以“.”结尾的一行文字，统计一共有多少个单词，并分别输出每个单词含有多少个字符。 （凡是以一个或多个空格隔开的部分就为一个单词）

#include<stdio.h>
int main(){
    int i=0;
    int wordcount=0;
    char arr[1000];
    
    while(gets(arr)!=NULL){
        while(arr[i]!='.'){
            if(arr[i]!=' '){
                wordcount++;
                i++;
            }else{
                if(arr[i-1]!=' '){//防连续空格
                    printf("%d",wordcount);

                    printf(" ");

                    wordcount=0;
                    i++;
                }else{
                    i++;
                }
            }      
        }
        printf("%d",wordcount);
    }
    return 0;
}

ip地址：

输入一个ip地址串，判断是否合法。

#include<stdio.h>
#include<stdlib.h>    //atoi
#include<malloc.h>    //malloc
#include<string.h>    //strcpy、strncpy
int main(){
    int i=0;int j=0;
    char arr[50];char *IP[4];//定义字符串指针数组，用于存四块ip
    while(scanf("%s",arr)!=EOF){
        while(arr[i]!='\0'){
            if(arr[i]=='.'){
                IP[j]=(char*)malloc((i+1)*sizeof(char));//为指针分配内存空间
                
                strncpy(IP[j],arr,i);//复制arr字符数组的前i个字符到ip字符数组中，strcpy参数是字符串指针，atoi函数也是。
                strcpy(arr,arr+i+1);//将剩下的字符串覆盖之前的字符串
                i=0;//并令i=0重新开始判断
                j++;
            }else{
            i++;
            }
       }
        IP[j]=(char*)malloc((i+1)*sizeof(char));//处理最后一个ip块
        strncpy(IP[j],arr,i);
        //printf("%d.%d.%d.%d\n",atoi(IP[0]),atoi(IP[1]),atoi(IP[2]),atoi(IP[3]));
        if((atoi(IP[0]))>=0 && (atoi(IP[0]))<=255 && (atoi(IP[1]))>=0 && (atoi(IP[1]))<=255 && (atoi(IP[2]))>=0 && (atoi(IP[2]))<=255 && (atoi(IP[3]))>=0 && (atoi(IP[3]))<=255){            
            printf("Yes!");
        }else{
            printf("No!");
        }
    }
    return 0;
}

二叉排序树：

二叉排序树，也称为二叉查找树。可以是一颗空树，也可以是一颗具有如下特性的非空二叉树： 1. 若左子树非空，则左子树上所有节点关键字值均不大于根节点的关键字值； 2. 若右子树非空，则右子树上所有节点关键字值均不小于根节点的关键字值； 3. 左、右子树本身也是一颗二叉排序树。 现在给你N个关键字值各不相同的节点，要求你按顺序插入一个初始为空树的二叉排序树中，每次插入后成功后，求相应的父亲节点的关键字值，如果没有父亲节点，则输出-1。 

例子输入：

5
2 5 1 3 4

输出：

-1
2
2
5
3

插入节点时加个递归

#include<stdio.h>
#include<malloc.h>

struct Node{
    int key;
    struct Node *right;
    struct Node *left;
    struct Node *parent;
};
typedef struct Node BitNode;
typedef struct Node *BitTree;

void insertnode(int data,BitTree keynode){
    BitTree m;
    if(data==keynode->key){printf("关键字已经存在！！");return;} //判断一下节点是否存在，存在则直接返回
    else if(data<keynode->key){//判断要插入的data比目前这个节点的关键字小，则往左边插
        if(keynode->left!=NULL){ //左边不为空就继续比较
            insertnode(data,keynode->left);
        }else{
            m=(BitTree)malloc(sizeof(BitNode));//为空，则插
            m->key=data;
            m->right=NULL;
            m->left=NULL;
            m->parent=keynode;
            printf("%d\n",keynode->key);//输出父节点关键字
            keynode->left=m;
        }
    }else if(data>keynode->key){
        if(keynode->right!=NULL){
            insertnode(data,keynode->right);
        }else{
            m=(BitTree)malloc(sizeof(BitNode));
            m->key=data;
            m->right=NULL;
            m->left=NULL;
            m->parent=keynode;
            printf("%d\n",keynode->key);
            keynode->right=m;
        }
    }
    return;
}

void freespace(BitTree keynode){
    while(keynode){
        if(keynode->left==NULL && keynode->right==NULL){
            free(keynode);
        }else{
            freespace(keynode->right);
            freespace(keynode->left);
        }
    }
    
}
  

int main(){
    int n;
    while(scanf("%d",&n)!=EOF){
        BitTree head;
        int d[100];
        int data;int i=0;
        for(i=0;i<n;i++){
            scanf("%d",&d[i]);  //存一下按序输入的节点关键字，也可以直接在下面for循环里输入
        }
        for(i=0;i<n;i++){
            data=d[i];
            if(i==0){ //第一个节点
                head=(BitTree)malloc(sizeof(BitNode));
                head->key=data;
                printf("-1\n");
                head->right=NULL;
                head->left=NULL;
                head->parent=NULL;
            }else{ //后面的节点就开始插入
                insertnode(data,head);
            }
        }
        //freespace(head);
    }
    return 0;
}

字符串连接

不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来。

输入描述:

每一行包括两个字符串，长度不超过100。

输出描述:

可能有多组测试数据，对于每组数据，
不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来。
输出连接后的字符串。

要实现字符串无冗余即一个一个读取字符，动态扩充内存连接字符，碰到回车符认为一组数据输入完毕，补上结束符打印输出，暂时不知道怎么样书写进行多数据测试

#include<stdio.h>
#include<stdlib.h>

int main(){
    char a;//用于接收一个一个的字符
    char *d;//用于动态分配内存，连接字符
    d=NULL;
    int j=0;//用j来指示合并后的字符串的大小
    while((a=getchar())!='\n'){
        if(a!=' '){
            j++;
            d=(char*)realloc(d,sizeof(char)*(1+j)); //多分配一个内存空间，用于循环结束后添加结束符'\0'
            *(d+j-1)=a;
        }
    }
    *(d+j)='\0';
    printf("%s\n",d);
    return 0;
}

a+b

实现一个加法器，使其能够输出a+b的值。

输入描述:

输入包括两个数a和b，其中a和b的位数不超过1000位。

输出描述:

可能有多组测试数据，对于每组数据，
输出a+b的值。

求大数和，由于位数得限制，只能用char型数组来存，并计算

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(){
    char a[10001];char b[10001];char sum[10001];
    int i=0;int j=0;int k=0;int c=0;
    int lena;int lenb;int lensum;
    while(scanf("%s%s",a,b)!=EOF){
        memset(sum,0,1000);
        lena=strlen(a);i=lena-1; 
        lenb=strlen(b);j=lenb-1; //得到两个数字字符串得位数长度
        if(lena>lenb){
            k=lena;
        }else{
            k=lenb;
        }
        lensum=k;                //得到两个位数中最长的作为最后结果的长度，并多存一位防止进位
        while(i>=0 && j>=0){     //从最低位开始相加两个字符数组的每一位,并把每一位对应存储到sum
            sum[k]=a[i]+b[j]-'0'+c;
            c=0;
            if(sum[k]>'9'){
                sum[k]=sum[k]-10;