c语言链表的基本操作

链表
#include 
typedef struct LNode    //后面用到struct LNode 的地方都能用LNode代替
{
    int data;
    struct LNode *next;   //单链表
}LNode,*list;//list定义指向结构体变量的指针变量
typedef struct node
{
    char name[20];
    struct node *link;
}stud;
typedef struct Node//双向链表节点
{
    int data;
    struct Node *next;
    struct Node *prior;
}Node;

void Creat(stud **head) //注意必须是指针的指针才能创建链表
{
    stud *p,*s;
    int i;
    *head=(stud *)malloc(sizeof(stud));
    if(*head==NULL)
    {
        printf("不能分配内存空间!\n");
        exit(0);
    }
    (*head)->name[0]='\0';
    (*head)->link=NULL;
    p=*head;
    for(i=0;i<10;i++){
        s=(stud *)malloc(sizeof(stud));
        if(s==NULL)
        {
            printf("不能分配内存空间!\n");
            exit(0);
        }
        p->link=s;
        printf("请输入第%d个人的姓名:",i+1);
        scanf("%s",s->name);
        s->link=NULL;p=s;
    }
}

void CreateList(LNode **HL)
{
    LNode *tail,*p;
    int a=0;
    *HL=(LNode *)malloc(sizeof(LNode));//申请头结点空间
    (*HL)->next=NULL;
    p=(*HL);
    while(1)
    {
        printf("input a number:\n");
        scanf("%d",&a);
        if(a!=-1)
        {
            tail=(LNode *)malloc(sizeof(LNode));
            p->next = tail;
            tail->data = a;
            p=tail;
            tail->next = NULL;
        }
        else break;
    }
    
}

LNode *CreateList1(void)
{
    list HL;
    int a;
    LNode *tail,*p;
    HL=(list *)malloc(sizeof(list));
    HL->next=NULL;
    p=HL;
    while(1)
    {
        printf("input a number:\n");
        scanf("%d",&a);
        if(a!=-1)
        {
            tail=(LNode *)malloc(sizeof(LNode));
tail->data = a;
p->next= tail;
p=tail;
        }
        else break;
}
tail->next = NULL;
    return (HL);
}

int MaxValue(LNode *HL)//未说明数据类型时用ElemType
{
    if(HL == NULL)
    {
        printf("error!\n");
        exit(1);
    }
    int max = HL->data;
    LNode *p = HL->next;
    while (p != NULL) {
        if(max < p->data)
            max = p->data;
        p = p->next;
    }
    return max;
}

int Count(LNode *HL,int x)//求单链表中结点的值等于x的结点数
{
    int n=0;
    LNode *p = HL;
    while (p != NULL) {
        if(p->data == x) n++;
        p = p->next;
    }
    return n;
}

int Count12(LNode *HL,int x1,int x2)//统计单链表中值大于x1小于x2的值的个数
{
    LNode *p = HL;
    int sum=0;
    while (p!=NULL)
    {
        if(p->data>=x1 && p->data<=x2)
            sum++;
        p=p->next;
    }
    return sum;
}

void verse(int A[],int n)//一维数组A[size]中前n个数组元素位置上，线性表原地逆置
{
    int i=0;
    int j=n-1;
    while (i<j) {
        int temp = A[i];
        A[i++]=A[j];
        A[j--]=temp;
    }
}

void del_x(LNode *h,int x)//设h为代表头节点的循环链表的头指针，删除数据域值为x的所有节点
{
    LNode *p,*q;
    p=h->next;
    q=h;
    while(p!=h)
    {
        if(p->data==x)
        {
            q->next=p->next;
            delete (p);
            p=q->next;
        }
        else
        {
            q=p;
            p=p->next;
        }

    }
}

void del_xs(Node *h,int x)//h为带表头节点的双向链表的头指针，删除表中数据域值为x的节点
{
    Node *p,*q;
    p=h->next;
    while(p!=h)
    {
        if(p->data==x)
        {
            q=p->next;
            p->prior->next=p->next;
            p->next->prior=p->prior;
            delete (p);
            p=q;
        }
        else
        {
            q=p;
            p=p->next;
        }
        
    }
}

void main()
{
//    int number;
//    stud *head,*p;
//    number=10;
//    Creat(&head);
//    CreateList(&HL);
//    q=HL->next;
//    p=head;
    LNode *p,*q;
    int max,count,x12;
    p=CreateList1();
    q=p->next;
    while(q)
    {
        printf("%d\n",q->data);
        q=q->next;
    }
    max=MaxValue(p);
    count=Count(p, 1);
    x12=Count12(p, 0, 8);
    printf("%d and %d and %d\n",max,count,x12);
}

二叉树
#include 
typedef char Datatype;
typedef struct Node
{
    Datatype data;
    struct Node  *lchild;
    struct Node  *rchild;
}BinTreeNode;

typedef BinTreeNode *BinTree;

void CreatBinTree(BinTree *T)//创建二叉树
{
    char ch;
    if((ch=getchar())==' ')
        *T = NULL;
    else{
        *T=(BinTreeNode *)malloc(sizeof(BinTreeNode));
        (*T)->data=ch;
        CreatBinTree(&(*T)->lchild);
        CreatBinTree(&(*T)->rchild);
    }
}

int GetLeaves(BinTree root)//求叶子节点总数
{
    static int leaf = 0;
    if(root)
    {
        if(!(root->lchild||root->rchild))
            leaf++;
        GetLeaves(root->lchild);
        GetLeaves(root->rchild);
    }
    return leaf;
}

int Depth(BinTree T)//递归求二叉树高度
{//对于非空二叉树，其深度等于某子树的深度加1
    int dep1=0,dep2=0;
    if(T==NULL) return 0;
    else
    {
        dep1 = Depth(T->lchild);
        dep2 = Depth(T->rchild);
        return (dep1>dep2?dep1:dep2)+1;
    }
}

void level(BinTree p)//BinTreeNode *p  层次遍历
{
    int front,rear;
    int Maxsize=50;
    BinTreeNode *que[Maxsize];
    front=rear=0;//定义循环队列
    BinTreeNode *q;
    if(p!=NULL)
    {
        rear=(rear+1)%Maxsize;
        que[rear]=p;//根节点入队
        while (front!=rear) {
            q=que[front];//队头节点出队（队头节点出队后，其子孩子节点入队，则输出为层次遍历）
            //visit(q);
            if(q->lchild!=NULL)
            {
                rear=(rear+1)%Maxsize;
                que[rear]=q->lchild;
            }
            if(q->rchild!=NULL)
            {
                rear=(rear+1)%Maxsize;
                que[rear]=q->rchild;
            }
        }
        
    }
}