链表，树，顺序表操纵

//
//  main.c
//  2020专业课
//
//  Created by cj on 2020/11/16.
//  Copyright © 2020 cj. All rights reserved.
//

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#define MaxSize 10
typedef struct{
    int data[MaxSize];
    int length;
}SqNode,*SqList;

typedef struct LNode{
    int data;
    struct LNode * next;
}LNode,*LinkList;

typedef struct Node{
    char data;
    struct Node * lchild;
    struct Node * rchild;
}Node,*Tree;

//初始化单链表
LinkList InitSqLink(){
    LNode *rear,*L;
    LNode *pnew;
    L=(LinkList)malloc(sizeof(LNode));
    rear=L;
    for(int i=1;i<4;i++){
        pnew=(LNode *)malloc(sizeof(LNode));
        printf("请输入第%d个节点的值：",i);
        int x;
        scanf("%d",&x);
        pnew->data=x;
        rear->next=pnew;
        rear=pnew;
    }
    rear->next=NULL;
    return L;
}
//初始化顺序表
SqList InitSqList(SqList L){
    
    L=(SqList)malloc(sizeof(SqNode));
    
    for (int i=0; i<4; i++) {
        int x;
        printf("请输入第%d个值：",i+1);
        scanf("%d",&x);
        L->data[i]=x;
    }
    
    L->length=4;
    return L;
   
}

//循环单链表
void foreachLink(LNode *L){
    LNode *p=L->next;
    while(p!=NULL){
        printf("%d\t",p->data);
        p=p->next;
    }
    printf("\n");
}
//循环数组
void foreachArr(SqNode *L){
    for (int i=0; i<L->length; i++) {
        printf("%d\t",L->data[i]);
    }
    printf("\n");
}
//删除数据表中最小的一个元素，并把删除元素用最后一个元素替代
void deleteMin(SqList L){
    
    int min=L->data[0],pos=0;
    for (int i=0; i<L->length; i++) {
        if(min>L->data[i]){
            min=L->data[i];
            pos=i;
        }
    }
    L->data[pos]=L->data[L->length-1];
   
}
//顺序表中多少个最大节点数
int countMax(SqList L){
    int max=L->data[0],k=1;
    for(int i=0;i<L->length;i++){
        if(max<L->data[i]){
            k=1;
            max=L->data[i];
        }else{
            k++;
        }
    }
    return k;
}
//顺序表删除所有值为x的元素
void deleteX(SqList L,int x){
    int k=0;
    for (int i=0; i<L->length; i++) {
        if(L->data[i]==x){
            k++;
        }else{
            L->data[i-k]=L->data[i];
        }
    }
    L->length-=k;
}
//有序表删除给定值s与t之间的元素
void deleteS_T(SqList L,int s,int x){
    int k=0;
    for (int i=0; i<L->length; i++) {
        if(L->data[i]>s && L->data[i]<x){
            k++;
        }else{
            L->data[i-k]=L->data[i];
        }
    }
    L->length-=k;
}

//链表删除所有值为x的元素
void deleteXList(LinkList L,int x){
    LNode *p=L->next,*pre=L,*temp;
    while (p!=NULL) {
        if(p->data==x){
            temp=p;
            pre->next=p->next;
            free(p);
            p=p->next;
        }else{
            pre=p;
            p=p->next;
        }
    }
}
//单链表删除s与t之间的数
void deleteS_TLink(LinkList L,int x,int t){
    LNode *p=L->next,*pre=L,*temp;
    while(p!=NULL){
        if(p->data>x && p->data<t){
            temp=p;
            pre->next=p->next;
            p=p->next;
            free(temp);
        }else{
            pre=p;
            p=p->next;
        }
    }
}
//有序链表删除重复的元素
void deleteSameLink(LinkList L){
    LNode *p=L->next->next,*pre=L->next,*temp;
    while (p!=NULL) {
        if(pre->data==p->data){
            temp=p;
            pre->next=p->next;
            p=p->next;
            free(temp);
        }else{
            pre=p;
            p=p->next;
        }
    }
    
}
//单链表逆置
void reserve(LinkList L){
    LNode *p=L->next,*r;
    L->next=NULL;
    while (p!=NULL) {
        r=p->next;
        p->next=L->next;
        L->next=p;
        p=r;
    }
}
//两个递增的单链表合并，成一个递减的
void merge(LinkList La,LinkList Lb){
    LNode *r,*pa=La->next,*pb=Lb->next;
    La->next=NULL;
  
    while (pa && pb) {
        if(pa->data<pb->data){
            r=pa->next;
            pa->next=La->next;
            La->next=pa;
            pa=r;
        }else{
            r=pb->next;
            pb->next=La->next;
            La->next=pb;
            pb=r;
        }
    }
    if(pa){
        pb=pa;
    }
    while (pb) {
        r=pb->next;
        pb->next=La->next;
        La->next=pb;
        pb=r;
    }
}
//二叉树的前序
void preforeach(Tree T){
    if(T){
        printf("%c\n",T->data);
        preforeach(T->lchild);
        preforeach(T->rchild);
    }
}
//中序
void orderforeach(Tree T){
    if(T){
        orderforeach(T->lchild);
        printf("%c\n",T->data);
        orderforeach(T->rchild);
    }
}
//统计叶子结点
int count(Tree T){
    if(T==NULL){
        return 0;
    }
    if(T->lchild==NULL && T->rchild==NULL){
        return 1;
    }else{
        return count(T->lchild)+count(T->rchild);
    }
}
//求树的高度
int height(Tree T){
    int lheight,rheight;
    if(T==NULL){
        return 0;
    }else{
        lheight=height(T->lchild);
        rheight=height(T->rchild);
    }
    if(lheight>rheight){
        return lheight+1;
    }else{
        return rheight+1;
    }
}
//输入两个正整数 m,n,求其最大公约和最小公倍数
void find(){
    int m,n,temp,r,p;
       printf("请输入两个正整数：\n");
       scanf("%d%d",&m,&n);
       if(m<n){//把大数放在m中
           temp=m;m=n;n=temp;
       }
       r=m%n;
       p=m*n;//p存放两者乘积，p除以最大公约数即为最小公倍数
       while(r!=0){//求两者公约数
           
           m=n;n=r;r=m%n;
           
           printf("m:%d,n:%d,r:%d",m,n,r);
       }
       printf("最大公约数为：%d\n",n);
       printf("最小公倍数为：%d\n",p/n);
        
}
//4～100的偶数拆成两个素数之和
int isPrime(int n){
    for (int i=2; i<=n/2; i++) {
        if(n%i==0){
            return 0;
        }
    }
    return 1;
}
void chai(){
    for (int i=4; i<100; i+=2) {
        for (int n=2; n<i;n++) {
            if(isPrime(n) && isPrime(i-n)){
                printf("%d=%d+%d\t",i,n,i-n);
                break;
            }
        }
    }
}
//一个灯塔有9层，共有1022灯，每一层的灯都是相邻上层的两倍，请按升序输出每一层的灯
void deng(){
    int top,bottom;
    for(int i=1;i<=9;i++){
        
    }
}
//打印出一百以内的水仙花数
void xianhua(){
    int i,j,k,n;
     
    for(i=1;i<10;i++)
     for(j=0;j<10;j++)
      for(k=0;k<10;k++)
      {
       n=i*100+j*10+k;
       if((i*100+j*10+k)==((i*i*i)+(j*j*j)+(k*k*k)))
        printf("水仙花数为:%d\n",n);
      }
}
//字符串转换成浮点数
void strtofloat(){
   
}
//输入一行字符，统计其中分别多少个单词和空格
void wordkong(){
    char c[100];
    int word=0;
    
    gets(c);
    for (int i=0;c[i]!='\0'; i++) {
        if(c[i]==' '){
            word++;
        }
    }
    printf("单词%d\n",word+1);
    printf("空格%d",word);
    puts(c);
}
 


int main() {
//    LNode *L=NULL,*Lb=NULL;
//    L=InitSqLink();
    
//    foreachLink(L);
//    deleteXList(L, 3);
//    deleteS_TLink(L, 2, 6);
//    foreachLink(L);
//    deleteSameLink(L);
//    foreachLink(L);
//    reserve(L);
//    foreachLink(L);
    
//    Lb=InitSqLink();
//
//    foreachLink(L);
//    foreachLink(Lb);
//     merge(L, Lb);
//    foreachLink(L);
//    foreachLink(L);
    
    
//    SqNode *arr=NULL;
//    arr=InitSqList(arr);
//
//    foreachArr(arr);
//
//    printf("%d",countMax(arr));
//    deleteMin(arr);
//    foreachArr(arr);
//    deleteX(arr, 9);
//    foreachArr(arr);
//    deleteS_T(arr, 2, 6);
//    foreachArr(arr);
    
//    Tree T=NULL,A,B,C,D;
//    T=(Node *)malloc(sizeof(Node));
//    A=(Node *)malloc(sizeof(Node));
//    B=(Node *)malloc(sizeof(Node));
//    C=(Node *)malloc(sizeof(Node));
//    D=(Node *)malloc(sizeof(Node));
//        T
//    A       B
//C       D
//    T->data='T';
//    A->data='A';
//    B->data='B';
//    C->data='C';
//    D->data='D';
//    T->lchild=A;
//    T->rchild=B;
//    A->lchild=C;
//    A->rchild=D;
//    C->lchild=NULL;
//    C->rchild=NULL;
//    D->lchild=NULL;
//    D->rchild=NULL;
//    B->lchild=NULL;
//    B->rchild=NULL;
//    preforeach(T);
//    orderforeach(T);
//    printf("%d",count(T));
//    printf("%d\n",height(T));
//    short b=65536;
//    printf("%d",b);
    
    
//    find();
//    chai();
//    xianhua();
    wordkong();
    return 0;
}