王道C语言督学营oj练习（全部更新完成）

（本人是2022年3月跟着王道C语言训练营学习过的，代码只供学习参考，但都是ac成功了的，如果存在ac不了的情况就检查一下自己的代码，注意运行语言有时候是C有时候是C++）

初级阶段

week1-day1作业

#include <stdio.h>

int main()
{
    printf("hello wangdao\n");
    
    return 0;
}

week1-day2作业

#define _CRT_SECURE_NO_WARNINGS //解决scanf编译报错问题(考试不需要写)
#include<stdio.h>

int main()
{
    int a,b;
    scanf("%d%d", &a,&b);//一定要在变量前加取地址符&
    printf("%d\n", a+b);
}

week1-day3作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int a;
    scanf("%d", &a);
    if (65 < a < 122)
        printf("%c", a);
    return 0;
} 

week2-day4作业1

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int year;
    scanf("%d", &year);
    if (year % 400 == 0 || year % 4 == 0 && year % 100 != 0)//能被4整除但不能被100整除或者能被400整除
    {
        printf("yes\n");

    }
    else {
        printf("no\n");
    }

}

week2-day5作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//一个scanf读多种类型的数据
//混合输入时每次在%c之前需要加入一个空格
int main()
{
    int i;
    char j;
    float k;
    scanf("%d %c%f", &i, &j, &k);
    //printf("%.2f",(float)i+(float)j+k);
    printf("%0.2f\n", i + j + k);
    return 0;
}

week2-day6作业

 #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//把最初输入的整型数a，反过来后，再存到另外一个整形数b，判断a和b是否相等，如果相等就输出yes，不等就输出no
int main() 
{
    int a,b,c,tmp;
    while (scanf("%d", &a) != EOF)
    {
        b = 0;
        c = a;
        while (a)
        {
            tmp = a % 10;
            b = b * 10 + tmp;
            a = a / 10;
        }
        if (c == b)
        {
            printf("yes\n");
        }
        else
        {
            printf("no\n");
        }
    }
    return 0;
}

week3-day7作业1

//while循环

 #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int n;
    int i = 1;
    int total = 1;//存储最终的和
    scanf("%d", &n);
    while (i <= n)//while后面不能加分号，否则会进入死循环
    {
        total = total * i;
        i++;
    }
    printf("%d\n", total);
}

 //for循环

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int n;
    int i, total;
    scanf("%d", &n);//读取输入
    //for语句中只能有两个分号
    for (i = 1, total = 1; i <= n; i++)
    {
        total = total * i;
    }
    printf("%d\n", total);
}

week3-day7作业2

#include<stdio.h>
int main() 
{
    int i, j, k, m, sum = 0;
    for (i = 1; i <= 40; i++)
    {
        for (j = 1; j <= 40; j++)
        {
            for (k = 1; k <= 40; k++)
            {
                for (m = 1; m <= 40; m++)
                {
                    if (i + j + k + m == 40 && 10 * i + 5 * j + k + m * 2 == 100)
                    {
                        sum++;
                    }
                }
            }
        }
    }
    printf("%d", sum);
    return 0;
    
} 

week3-day8作业

 #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int a[100], n, k = 0;
    scanf("%d", &n);//接下来要输入多少个元素
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);//如何往数组里元素读取数据
        if (a[i] == 2)
        {
            k++;
        }
    }
    printf("%d\n",k);
}

week3-day9作业

 #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main()
{
    char a[20];
    char b[20];
    int len;
    gets(a);
    len = strlen(a);//读取数组a的长度
    for (int i = 0; i < len; i++)
    {
        b[i] = a[len - i - 1];//将a数组的下标存的数据赋值给逆转后b数组的下标
    }
    b[len] = '\0';//在b数组中，数据结束后添加结束符
    if (strcmp(a, b) > 0)//判断原字符串是否大于逆转后的字符串
    {
        printf("1");
    }
    else if (strcmp(a, b) < 0)
    {
        printf("-1");
    }
    else
    {
        printf("0");
    }
}

week4-day10作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void change(int *j)//j称为形参，j=&i
{
    *j = *j/2;//指针的间接访问
}

int main()
{
    int i;//i是局部变量
    scanf("%d",&i);
    change(&i);//函数调用时，把&i称为实参
    printf("%d\n", i);
    return 0;
}

week4-day11作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//malloc可以帮我们实现动态数组
int main()
{
    int i;//申请多大的空间
    scanf("%d", &i);
    char* p;
    p = malloc(i);//malloc申请空间的单位是字节
    char c;
    scanf("%c", &c);//为了去除缓冲区里边的\n
    gets(p);//如果不通过上面的scanf去消除\n，gets不会卡住
    puts(p);
    return 0;
}

week4-day12作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h> 

int step(int n)
{
    if (1 == n || 2 == n)//递归的结束条件
    {
        return n;
    }
    return step(n - 1) + step(n - 2);//递归公式
}

int main()
{
    int n;//存储台阶
    scanf("%d", &n);
    printf("%d\n", step(n));
    return 0;
}

中级阶段

中级-day1

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

//结构体指针
struct student
{
    int num;
    char name[20];
    char sex;
};//结构体类型声明，注意最后一定要加分号
int main()
{
    struct student sarr[1];
    int i=0;
        scanf("%d%s %c", &sarr[i].num, sarr[i].name, &sarr[i].sex);
        printf("%d %s %c\n", sarr[i].num, sarr[i].name, sarr[i].sex);
    
    return 0;
}

中级-day2作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
void modify_pointer(char*&p) {
    p = (char*)malloc(100);
    fgets(p, 100, stdin);//如果使用fgets传入的是一个指针变量，中间参数是指针指向的空间大小

}
int main() {
    char* p;
    modify_pointer(p);
    puts(p);
    return 0;
}

中级day3作业

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

#define MaxSize 50
typedef int ElemType;//顺序表中元素的类型
//静态分配
typedef struct {
    ElemType data[MaxSize];//定义的数组，用来存元素
    int length;//当前顺序表中有多少个元素
}SqList;

//i代表插入的位置，从1开始，e要插入的元素
bool ListInsert(SqList& L, int i, ElemType e)
{
    if (i<1 || i>L.length + 1)//判断要插入的位置是否合法
        return false;
    if (L.length >= MaxSize)//超出了空间,元素存储满了，不能再存了
        return false;
    for (int j = L.length; j >= i; j--)//移动顺序表中的元素
        L.data[j] = L.data[j - 1];
    L.data[i - 1] = e;//数组下标从零开始，插入第一个位置，访问的下标为零
    L.length++;
    return true;//插入成功，返回true
}
//删除使用元素e的引用的目的是拿出对应的值
bool ListDelete(SqList& L, int i, ElemType& e)
{
    if (i<1 || i>L.length)//如果删除的位置是不合法
        return false;
    if (L.length == 0)//顺序表中没有元素，无需删除
    {
        return false;
    }
    e = L.data[i - 1];//获取顺序表中对应的元素，赋值给e
    for (int j = i; j < L.length; j++)//从i的位置依次把元素往前覆盖
        L.data[j - 1] = L.data[j];
    L.length--;
    return true;//删除一个元素，顺序表长度减1
}
//打印顺序表元素
void PrintList(SqList& L)
{
    for (int i = 0; i < L.length; i++)
    {
        printf("%3d", L.data[i]);//要求所有元素打印到一排
    }
    printf("\n");
}
//要不要加引用，就是看是不是在子函数中去改变主函数中对应的变量，要改就要加
int main()
{
    
    SqList L;//顺序表的名称
    bool ret;//查看返回值，布尔型是true，或者false
    ElemType del;//用来存要删除的元素
    //首先手动在顺序表中赋值
    L.data[0] = 1;
    L.data[1] = 2;
    L.data[2] = 3;
    L.length = 3;//总计三个元素
    int i;
    scanf("%d\n", &i);
    ret = ListInsert(L, 2, i);//往第二个位置插入6这个元素
    if (ret)
    {
        PrintList(L);//打印成功后的顺序表
    }
    else {
        printf("插入失败\n");
    }
    int k;
    scanf("%d\n", &k);
    ret = ListDelete(L,k,del);//删除第一个位置的元素，把元素输出
    if (ret)
    {
        PrintList(L);
    }
    else {
        printf("false\n");
    }
    return 0;
}

中级-day4作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode {
    ElemType data;
    struct LNode* next;//指向下一个节点
}LNode,*LinkList;
//头插法新建链表
LinkList CreatList1(LinkList& L)//list_head_insert
{
    LNode* s; int x;
    L = (LinkList)malloc(sizeof(LNode));//带头结点的链表
    L->next = NULL;//L->data里边没放东西
    scanf("%d", &x);//从标准输入读取数据
    //3 4 5 6 9999
    while (x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));//申请一个新空间给s，强制类型转换
        s->data = x;//把读取到的值，给新空间中的data成员
        s->next = L->next;//让新结点的next指针指向链表的第一个元素（第一个放我们数据的元素）
        L->next = s;//让s作为第一的元素
        scanf("%d", &x);//读取标准输入
    }
    return L;
}
//尾插法新建链表
LinkList CreatList2(LinkList &L)//list_tail_insert
{
    int x;
    L = (LinkList)malloc(sizeof(LNode));//带头结点的链表
    LNode* s, * r = L;//LinkList s,r=L;也可以，r代表链表表尾结点，指向链表尾部
    //3 4 5 6 9999
    scanf("%d\n", &x);
    while (x!=9999)
    {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;//让尾部节点指向新节点
        r = s;//r指向新的表尾结点
        scanf("%d\n", &x);
    }
    r->next = NULL;//尾结点的next指针赋值为null
    return L;
    
}
//打印链表中每个结点的值
void PrintList(LinkList L)
{
    L = L->next;
    while (L != NULL)//NULL是为了代表一张空的藏宝图
    {
        printf("%3d", L->data);//打印当前节点数据
        L = L->next;//指向下一个节点
        if (L != NULL)
        {
            printf(" ");
        }
    }
    printf("\n");
}
int main()
{
    LinkList L;
    LinkList search;
    CreatList1(L);//输入数据可以为3 4 5 6 7 9999，头插法新建链表
    PrintList(L);//链表打印
    CreatList2(L);//输入数据可以为3 4 5 6 7 9999，尾插法新建链表
    PrintList(L);
    return 0;
} 

中级-day5作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode {
    ElemType data;
    struct LNode* next;//指向下一个节点
}LNode,*LinkList;
//尾插法建立链表
LinkList CreatList(LinkList& L)//list_tail_insert
{
    int x;
    L = (LinkList)malloc(sizeof(LNode));//带头结点的链表
    LNode* s, * r = L;//LinkList s,r=L;也可以，r代表链表表尾结点，指向链表尾部
    //3 4 5 6 7 9999
    scanf("%d", &x);
    while (x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;//让尾部节点指向新节点
        r = s;//r指向新的尾部节点
        scanf("%d", &x);
    }
    r->next = NULL;
    return L;
}
//按序号查找结点值
LNode* GetElem(LinkList L, int i)
{
    int j = 1;
    LNode* p = L->next;
    if (i == 0)
        return L;
    if (i < 1)
        return NULL;
    while (p&&j<i)
    {
        p = p->next;
        j++;
    }
    return p;
}
//新结点插入第i个位置
bool LinstFrontInsert(LinkList L, int i, ElemType e)
{
    LinkList p = GetElem(L, i - 1);
    if (NULL == p)
    {
        return false;
    }
    LinkList s = (LNode*)malloc(sizeof(LNode));//为新插入的节点申请空间
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
//删除第i个节点
bool ListDelete(LinkList L, int i)
{
    LinkList p = GetElem(L, i - 1);
    if (NULL == p)
    {
        return false;
    }
    LinkList q;
    q = p->next;
    p->next = q->next;//断链
    free(q);//释放对应节点的空间
    return true;
}
//打印链表中每个节点的位置
void PrintList(LinkList L)
{
    L = L->next;
    while (L!=NULL)
    {
        printf("%3d", L->data);
        L = L->next;//指向下一个节点
    }
    printf("\n");
}

int main()
{
    LinkList L;
    LinkList search;
    CreatList(L);
    //PrintList(L);
    search = GetElem(L, 2);//查找第二个位置的元素的值
    if (search != NULL)
    {
        printf("%d\n", search->data);

    }
    LinstFrontInsert(L, 2, 99);//新结点插入第i个位置
    PrintList(L);
    ListDelete(L, 4);//删除第4个节点
    PrintList(L);
}

中级-day6作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];//数组
    int top;
}SqStack;
//栈初始化
void InitStack(SqStack& S)
{
    S.top = -1;//代表栈为空
}

//入栈
bool Push(SqStack& S, ElemType x)
{
    if (S.top == MaxSize - 1)//数组的大小不能改变，避免访问越界
    {
        return false;
    }
    S.data[++S.top] = x;
    return true;
}
//出栈
bool Pop(SqStack& S, ElemType& x)
{
    if (-1 == S.top)
        return false;
    x = S.data[S.top--];
    printf(" %d", x);
    return true;
}
//队列
typedef struct {
    ElemType data[5];//数组，存放MaxSize-1个元素
    int front, rear;//队列头，队列尾
}SqQueue;
//队列初始化
void InitQueue(SqQueue& Q)//初始化队列
{
    Q.rear = Q.front = 0;
}
//入队
bool EnQueue(SqQueue& Q, ElemType x)
{
    if ((Q.rear + 1) % MaxSize == Q.front)//判断是否队满
        return false;
    Q.data[Q.rear] = x;//3 4 5 6 7
    Q.rear = (Q.rear + 1) % MaxSize;
    return true;
}
//出队
bool DeQueue(SqQueue& Q, ElemType& x)
{
    if (Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];//先进先出
    Q.front = (Q.front + 1) % MaxSize;
    printf(" %d", x);
    return true;
}
int main()
{
    SqStack S;//后进先出LIFO
    ElemType m;//用来存放拿出的元素
    InitStack(S);//初始化
    ElemType a, b, c;
    scanf("%d %d %d\n", &a, &b, &c);
    Push(S, a);
    Push(S, b);
    Push(S, c);
    SqQueue Q;
    ElemType element;//存储出队元素
    InitQueue(Q);//初始化队列
    //入队
    int n = 1;
    int n1;
    while (n < 5)
    {
        scanf("%d", &n1);
        EnQueue(Q, n1);
        n = n + 1;
    }
    Pop(S, m);
    Pop(S, m);
    Pop(S, m);
    printf("\n");
    if (n > 4)printf("false\n");
    for(int i=1;i<n;i++)
    {
        DeQueue(Q, element);
    }
    return 0;

}

中级-day7作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef char BiElemType;
typedef struct BiTNode {
    BiElemType c;//C就是书籍上的data
    struct BiTNode* lchild;
    struct BiTNode* rchild;
}BiTNode, * BiTree;

typedef struct tag {
    BiTree p;
    struct tag* pnext;
}tag_t, * ptag_t;
//队列的相关数据结构
typedef struct LinkNode {
    ElemType data;
    struct LinkNode* next;
}LinkNode;
typedef struct {
    LinkNode* front, * rear;
}LinkQueue;
void InitQueue(LinkQueue& Q);
bool IsEmpty(LinkQueue Q);
void EnQueue(LinkQueue& Q, ElemType x);
bool DeQueue(LinkQueue& Q, ElemType& x);

//带头结点的队列
void InitQueue(LinkQueue& Q)
{
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}

bool IsEmpty(LinkQueue Q)
{
    if (Q.front == Q.rear)
        return true;
    else
        return false;
}

void EnQueue(LinkQueue& Q, ElemType x)
{
    LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
    s->data = x; s->next = NULL;
    Q.rear->next = s;
    Q.rear = s;
}

bool DeQueue(LinkQueue& Q, ElemType& x)
{
    if (Q.front == Q.rear) return false;
    LinkNode* p = Q.front->next;//头结点什么都没存，所以头结点的下一个节点才有数据
    x = p->data;
    Q.front->next = p->next;
    if (Q.rear == p)
        Q.rear = Q.front;
    free(p);
    return true;
}

//前序遍历
void preOrder(BiTree p)
{
    if (p != NULL)
    {
        putchar(p->c);//等价于visit函数
        preOrder(p->lchild);
        preOrder(p->rchild);
    }
}

int main()
{
    BiTree pnew;
    int i, j, pos;
    char c;
    BiTree tree = NULL;//树根
    ptag_t phead = NULL, ptail = NULL, listpnew = NULL, pcur = NULL;//phead是队列头，ptail是队列尾
    while (scanf("%c", &c) != EOF)
    {
        if (c == '\n')
        {
            break;
        }
        pnew = (BiTree)calloc(1, sizeof(BiTNode));//calloc申请空间并对空间进行初始化，赋值为0
        pnew->c = c;//数据放进去
        listpnew = (ptag_t)calloc(1, sizeof(tag_t));//给队列结点申请空间
        listpnew->p = pnew;
        if (NULL == tree)
        {
            tree = pnew;//树的根
            phead = listpnew;//队列头
            ptail = listpnew;//队列尾
            pcur = listpnew;
            continue;
        }
        else
        {
            ptail->pnext = listpnew;//新节点放入链表，通过尾插法
            ptail = listpnew;//ptail指向队列尾部
        }//pcur始终指向要插入的位置
        if (NULL == pcur->p->lchild)//如何把新节点放入树
        {
            pcur->p->lchild = pnew;//把新节点放到要插入结点的左边
        }
        else if (NULL == pcur->p->rchild)
        {
            pcur->p->rchild = pnew;//把新节点放到要插入结点的右边
            pcur = pcur->pnext;//左右都放了结点后，pcur指向队列的下一个
        }

    }
    preOrder(tree);
}

中级-day8作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef char BiElemType;
typedef struct BiTNode {
    BiElemType c;//c就是书籍上的data
    struct BiTNode* lchild;
    struct BiTNode* rchild;
}BiTNode, * BiTree;

typedef struct tag {
    BiTree p;//树的某一个结点的地址值
    struct tag* pnext;
}tag_t, * ptag_t;
#define MaxSize 50
typedef BiTree ElemType;
//队列的相关数据结构
typedef struct LinkNode {
    ElemType data;
    struct LinkNode* next;
}LinkNode;
typedef struct {
    LinkNode* front, * rear;
}LinkQueue;
void InitQueue(LinkQueue& Q);
bool IsEmpty(LinkQueue Q);
void EnQueue(LinkQueue& Q, ElemType x);
bool DeQueue(LinkQueue& Q, ElemType& x);
//带头结点的队列
void InitQueue(LinkQueue& Q)
{
    Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
    Q.front->next = NULL;
}

bool IsEmpty(LinkQueue Q)
{
    if (Q.front == Q.rear)
        return true;
    else
        return false;
}

void EnQueue(LinkQueue& Q, ElemType x)
{
    LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
    s->data = x; s->next = NULL;
    Q.rear->next = s;
    Q.rear = s;
}

bool DeQueue(LinkQueue& Q, ElemType& x)
{
    if (Q.front == Q.rear) return false;
    LinkNode* p = Q.front->next;//头结点什么都没存，所以头结点的下一个节点才有数据
    x = p->data;
    Q.front->next = p->next;
    if (Q.rear == p)
        Q.rear = Q.front;
    free(p);
    return true;
}

//中序遍历  hdibjeafcg
void InOrder(BiTree p)
{
    if (p != NULL)
    {
        InOrder(p->lchild);
        putchar(p->c);
        InOrder(p->rchild);
    }
}
//hidjebfgca  后序遍历
void PostOrder(BiTree p)
{
    if (p != NULL)
    {
        PostOrder(p->lchild);
        PostOrder(p->rchild);
        putchar(p->c);
    }
}

//层次遍历,层序遍历，广度优先遍历
void LevelOrder(BiTree T)
{
    LinkQueue Q;//辅助队列
    InitQueue(Q);//初始化队列
    BiTree p;
    EnQueue(Q, T);//树根入队
    while (!IsEmpty(Q))
    {
        DeQueue(Q, p);//出队当前结点并打印
        putchar(p->c);
        if (p->lchild != NULL) //入队左孩子
            EnQueue(Q, p->lchild);
        if (p->rchild != NULL)  //入队右孩子
            EnQueue(Q, p->rchild);
    }
}
int main()
{
    BiTree pnew;
    int i, j, pos;
    char c;
    BiTree tree = NULL;//树根
    ptag_t phead = NULL, ptail = NULL, listpnew = NULL, pcur = NULL;//phead就是队列头，ptail就是队列尾
    //abcdefghij
    while (scanf("%c", &c) != EOF)
    {
        if (c == '\n')
        {
            break;
        }
        pnew = (BiTree)calloc(1, sizeof(BiTNode));//calloc申请空间并对空间进行初始化，赋值为0
        pnew->c = c;//数据放进去
        listpnew = (ptag_t)calloc(1, sizeof(tag_t));//给队列结点申请空间
        listpnew->p = pnew;
        if (NULL == tree)
        {
            tree = pnew;//树的根
            phead = listpnew;//队列头
            ptail = listpnew;//队列尾
            pcur = listpnew;
            continue;
        }
        else {
            ptail->pnext = listpnew;//新结点放入链表，通过尾插法
            ptail = listpnew;//ptail指向队列尾部
        }//pcur始终指向要插入的结点的位置
        if (NULL == pcur->p->lchild)//如何把新结点放入树
        {
            pcur->p->lchild = pnew;//把新结点放到要插入结点的左边
        }
        else if (NULL == pcur->p->rchild)
        {
            pcur->p->rchild = pnew;//把新结点放到要插入结点的右边
            pcur = pcur->pnext;//左右都放了结点后，pcur指向队列的下一个
        }
    }
    InOrder(tree);
    printf("\n");
    PostOrder(tree);
    printf("\n");
    LevelOrder(tree);
    printf("\n");
}

中级-day9作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int KeyType;
typedef struct BSTNode {
    KeyType key;
    struct BSTNode* lchild, * rchild;
}BSTNode, * BiTree;
//54 20 66 40 28 79 58
int BST_Insert(BiTree& T, KeyType k)
{
    if (NULL == T)
    {
        //为新节点申请空间
        T = (BiTree)malloc(sizeof(BSTNode));
        T->key = k;
        T->lchild = T->rchild = NULL;
        return 1;//代表插入成功
    }
    else if (k == T->key)
        return 0;//发现相同元素，就不插入
    else if (k < T->key)
        return BST_Insert(T->lchild, k);
    else
        return BST_Insert(T->rchild, k);
}

//创建二叉排序树
void Create_BST(BiTree& T, KeyType str[], int n)
{
    T = NULL;
    int i = 0;
    while (i < n)
    {
        BST_Insert(T, str[i]);
        i++;
    }
}
//中序遍历
void InOrder(BiTree T, KeyType str[], int& pos)
{
    if (T != NULL)
    {
        InOrder(T->lchild, str, pos);
        printf("%3d", T->key);
        str[pos++] = T->key;//输出的同时存入数组
        InOrder(T->rchild, str, pos);
    }
}
typedef int ElemType;
typedef struct {
    ElemType* elem;//整形指针
    int TableLen;
}SSTable;
int Binary_Search(SSTable L, ElemType key)
{
    int low = 0, high = L.TableLen - 1, mid;
    while (low <= high)
    {
        mid = (low + high) / 2;
        if (L.elem[mid] == key)
            return mid;
        else if (L.elem[mid] > key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return -1;
}
int main()
{
    BiTree T = NULL;
    BiTree parent;//存储父亲节点的地址值
    BiTree search;
    KeyType str[10];//将要进入二叉排序树的元素值
    int i;
    for (i = 0; i < 10; i++)
    {
        scanf("%d", &str[i]);
    }
    Create_BST(T, str, 10);
    int pos = 0;
    InOrder(T, str, pos);//中序遍历把有序数组的结果存到str数组中
    printf("\n");
    SSTable L;
    L.elem = str;
    L.TableLen = 10;
    pos = Binary_Search(L, 21);
    printf("%d\n", pos);
    return 0;

}

中级-day10作业

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

int main()
{
    char j;
    scanf("%c",&j);
    int i;
    int arr[9] = { 0,1,1,2,2,3,1,1,2 };
    for (i = 0; i < 9; i++)
    {
        printf("%2d", arr[i]);
    }
    return 0;
}

中级day11-作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#include<string.h>

typedef int ElemType;
typedef struct {
    ElemType* elem;//存储元素的起始地址
    int TableLen;
}SSTable;
void ST_Init(SSTable& ST, ElemType A[],int len)
{
    ST.TableLen = len;
    ST.elem = (ElemType*)malloc(sizeof(ElemType) * ST.TableLen);
    int i;
    for (i = 0; i < ST.TableLen; i++)
    {
        ST.elem[i] = A[i];
    }

}
void ST_print(SSTable ST)
{
    for (int i = 0; i < ST.TableLen; i++)
    {
        printf("%3d", ST.elem[i]);
    }
    printf("\n");
}
void swap(ElemType& a, ElemType& b)
{
    ElemType tmp;
    tmp = a;
    a = b;
    b = tmp;
}
void BubbleSort1(ElemType A[], int n)
{
    int i, j, flag;
    for (i = 0; i < n - 1; i++)//i是控制有多少个有序了
    {
        flag = 0;
        for (j = n - 1; j > i; j--)//内层控制比较，交换
        {
            if (A[j - 1] > A[j])
            {
                swap(A[j - 1], A[j]);
                flag = 1;
            }
        }
    }
}
int Partition(int* arr, int left, int right)
{
    int k, i;
    for (k = i = left; i < right; i++)
    {
        if (arr[i] < arr[right])
        {
            swap(arr[i], arr[k]);
            k++;
        }
    }
    swap(arr[k], arr[right]);
    return k;
}

//递归实现
void QuickSort(ElemType A[], int low, int high)
{
    if (low < high)
    {
        int pivotpos = Partition(A, low, high);//分割点左边的元素都比分割点要小，右边的比分割点大
        QuickSort(A, low, pivotpos - 1);
        QuickSort(A, pivotpos + 1, high);
    }
}
void InsertSort(ElemType A[], int n)
{
    int i, j;
    for (i = 2; i < n; i++)
    {
        if (A[i] < A[i - 1])
        {
            A[0] = A[i];//放到暂存位置，A[0]既是暂存，也是哨兵
            for (j = i - 1; A[0] < A[j]; --j)//移动元素，内层循环控制有序序列中的每一个元素和要插入的元素比较
                A[j + 1] = A[j];
            A[j + 1] = A[0];//把暂存元素插入到对应位置
        }
    }
}
int main()
{
    SSTable ST;
    ElemType A[10];
    int i;
    for (i = 0; i < 10; i++)
    {
        scanf("%d", &A[i]);
    }
    ST_Init(ST,A, 10);//初始化
    BubbleSort1(ST.elem, 10);//冒泡排序
    ST_print(ST);
    QuickSort(ST.elem, 0, 9);//快速排序
    ST_print(ST);
    InsertSort(ST.elem, 10);//插入排序
    ST_print(ST);
}

 

中级day12-作业

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
typedef int ElemType;
typedef struct {
    ElemType* elem;
    int TableLen;
}SSTable;

void ST_Init(SSTable& ST, ElemType A[], int len)
{
    ST.TableLen = len;
    ST.elem = (ElemType*)malloc(sizeof(ElemType) * ST.TableLen);
    int i;
    for (i = 0; i < ST.TableLen; i++)
    {
        ST.elem[i] = A[i];
    }

}
void ST_print(SSTable ST)
{
    for (int i = 0; i < ST.TableLen; i++)
    {
        printf("%3d", ST.elem[i]);
    }
    printf("\n");
}
void swap(ElemType& a, ElemType& b)
{
    ElemType tmp;
    tmp = a;
    a = b;
    b = tmp;
}
void SelectSort(ElemType A[], int n)
{
    int i, j, min;//min记录最小的元素的下标
    for (i = 0; i < n - 1; i++)//最多可以为8
    {
        min = i;
        for (j = i + 1; j < n; j++)//j最多可以为9
        {
            if (A[j] < A[min])
                min = j;
        }
        if (min != i)
        {
            swap(A[i], A[min]);
        }
    }
}
//调整子树
void AdjustDown1(ElemType A[], int k, int len)
{
    int dad = k;
    int son = 2 * dad + 1;
    while (son <= len)
    {
        if (son + 1 <= len && A[son] < A[son + 1])//看下有没有右孩子，比较左右孩子选大的
        {
            son++;
        }
        if (A[son] > A[dad])//比较孩子和父亲
        {
            swap(A[son], A[dad]);
            dad = son;
            son = 2 * dad + 1;
        }
        else {
            break;
        }
    }
}

void HeapSort1(ElemType A[], int len)
{
    int i;
    for (i = len / 2; i >= 0; i--)
    {
        AdjustDown1(A, i, len);
    }
    swap(A[0], A[len]);//交换顶部和数组最后一个元素
    for (i = len - 1; i > 0; i--)
    {
        AdjustDown1(A, 0, i);//剩下元素调整为大根堆
        swap(A[0], A[i]);
    }
}
//选择排序与堆排序
int main()
{
    SSTable ST;
    ElemType A[10]; 
    int i;
    for (i = 0; i < 10; i++)
    {
        scanf("%d", &A[i]);
    }
    ST_Init(ST,A, 10);//初始化
    memcpy(ST.elem, A, sizeof(A));
    SelectSort(ST.elem,10);
    ST_print(ST);
    HeapSort1(ST.elem, 9);//零号元素不参与排序
    ST_print(ST);
    return 0;
}

高级阶段

高级day1-作业

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define N 10
typedef int ElemType;
void Merge(ElemType A[], int low, int mid, int high)
{
    ElemType B[N];//为了降低操作次数
    int i, j, k;
    for (k = low; k <= high; k++)//复制元素到B中
        B[k] = A[k];
    for (i = low, j = mid + 1, k = i; i <= mid && j <= high; k++)//合并两个有序数组
    {
        if (B[i] <= B[j])
            A[k] = B[i++];
        else
            A[k] = B[j++];
    }
    while (i <= mid)//如果有剩余元素，接着放入即可
        A[k++] = B[i++];
    while (j <= high)
        A[k++] = B[j++];
}
void MergeSort(ElemType A[], int low, int high)//递归分割
{
    if (low < high)
    {
        int mid = (low + high) / 2;
        MergeSort(A, low, mid);
        MergeSort(A, mid + 1, high);
        Merge(A, low, mid, high);
    }
}
void print(int* a)
{
    for (int i = 0; i < N; i++)
    {
        printf("%3d", a[i]);
    }
    printf("\n");
}
// 归并排序
int main()
{
    int A[10];
    int i;
    for (i = 0; i < 10; i++)
    {
        scanf("%d", &A[i]);
    }
    MergeSort(A, 0, 9);
    print(A);
    return 0;
}

高级day2-作业

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

#define MAX 100
#define isLetter(a)  ((((a)>='a')&&((a)<='z')) || (((a)>='A')&&((a)<='Z')))
#define LENGTH(a)  (sizeof(a)/sizeof(a[0]))

// 邻接表中表对应的链表的顶点
typedef struct _ENode
{
    int ivex;                   // 该边所指向的顶点的位置,是数组的下标
    struct _ENode* next_edge;   // 指向下一条弧的指针
}ENode, * PENode;

// 邻接表中表的顶点
typedef struct _VNode
{
    char data;              // 顶点信息
    ENode* first_edge;      // 指向第一条依附该顶点的弧
}VNode;

// 邻接表
typedef struct _LGraph
{
    int vexnum;             // 图的顶点的数目
    int edgnum;             // 图的边的数目
    VNode vexs[MAX];
}LGraph;

/*
 * 返回ch在matrix矩阵中的位置
 */
static int get_position(LGraph g, char ch)
{
    int i;
    for (i = 0; i < g.vexnum; i++)//去顶点结构体数组中遍历每个顶点
        if (g.vexs[i].data == ch)
            return i;//返回的是对应顶点的下标
    return -1;
}
/*
 * 读取一个输入字符
 */
 static char read_char()
 {
     char ch;
 
     do {
         ch = getchar();
     } while (!isLetter(ch));
 
     return ch;
 }

/*
 * 将node链接到list的末尾
 */
static void link_last(ENode* list, ENode* node)
{
    ENode* p = list;

    while (p->next_edge)
        p = p->next_edge;
    p->next_edge = node;
}

/*
 * 深度优先搜索遍历图的递归实现
 */
static void DFS(LGraph G, int i, int* visited)
{
    ENode* node;

    visited[i] = 1;//要访问当前结点了，所以打印
    printf(" %c", G.vexs[i].data);
    node = G.vexs[i].first_edge;//拿当前顶点的后面一个顶点
    while (node != NULL)
    {
        if (!visited[node->ivex])//只要对应顶点没有访问过，深入到下一个顶点访问
            DFS(G, node->ivex, visited);
        node = node->next_edge;//某个顶点的下一条边，例如B结点的下一条边
    }
}

/*
 * 深度优先搜索遍历图
 */
void DFSTraverse(LGraph G)
{
    int i;
    int visited[MAX];       // 顶点访问标记

    // 初始化所有顶点都没有被访问
    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;
    //从A开始深度优先遍历
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
            DFS(G, i, visited);
    }
    printf("\n");
}

/*
 * 广度优先搜索（类似于树的层次遍历）
 */
void BFS(LGraph G)
{
    int head = 0;
    int rear = 0;
    int queue[MAX];     // 辅组队列
    int visited[MAX];   // 顶点访问标记
    int i, j, k;
    ENode* node;

    //每个顶点未被访问
    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;
    //从零号顶点开始遍历
    for (i = 0; i < G.vexnum; i++)//对每个连同分量均调用一次BFS
    {
        if (!visited[i])//如果没访问过，就打印，同时入队,最初是A
        {
            visited[i] = 1;//标记已经访问过
            printf(" %c", G.vexs[i].data);
            queue[rear++] = i;  // 入队列
        }
        while (head != rear) //第一个进来的是A，遍历A的每一条边
        {
            j = queue[head++];  // 出队列
            node = G.vexs[j].first_edge;
            while (node != NULL)
            {
                k = node->ivex;
                if (!visited[k])
                {
                    visited[k] = 1;
                    printf(" %c", G.vexs[k].data);
                    queue[rear++] = k;//类似于树的层次遍历，遍历到的同时入队
                }
                node = node->next_edge;
            }
        }
    }
    printf("\n");
}

/*
 * 创建邻接表对应的图(有向图)
 */
LGraph* create_example_lgraph_directed()
{
    char c1, c2;
    char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
    char edges[][2] = {
        {'A', 'B'},
        {'B', 'C'},
        {'B', 'E'},
        {'B', 'F'},
        {'C', 'E'},
        {'D', 'C'},
        {'E', 'B'},
        {'E', 'D'},
        {'F', 'G'} };
    int vlen = LENGTH(vexs);
    int elen = LENGTH(edges);
    int i, p1, p2;
    ENode* node1;
    LGraph* pG;
    if ((pG = (LGraph*)malloc(sizeof(LGraph))) == NULL)
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = vlen;
    pG->edgnum = elen;
    // 初始化"邻接表"的顶点
    for (i = 0; i < pG->vexnum; i++)
    {
        pG->vexs[i].data = vexs[i];
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for (i = 0; i < pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        c1 = edges[i][0];
        c2 = edges[i][1];

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);
        // 初始化node1
        node1 = (ENode*)calloc(1, sizeof(ENode));
        node1->ivex = p2;
        // 将node1链接到"p1所在链表的末尾"
        if (pG->vexs[p1].first_edge == NULL)
            pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
    }
      
    return pG;
}
int main()
{
    LGraph* pG;
    pG = create_example_lgraph_directed();
    DFSTraverse(*pG);//深度优先遍历
    BFS(*pG);//广度优先遍历
    return 0;
}

高级day3-作业

#include<stdio.h>

int main()
{
    printf("%3d%3d\n", 0, 13);
    return 0;
}

高级day4-作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int i;
    scanf("%d", &i);
    printf("%2d\n", i << 1);
    printf("%2d\n", i >> 1);
        return 0;
}

高级day5-作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
    int i;
    int arr[5];
    for (i = 0; i < 5; i++)
    {
        scanf("%d", arr + i);

    }
    int result=0;
    for (i = 0; i < 5; i++)
    {
        result ^= arr[i];
    }
    printf("%d\n", result);
        return 0;
}

高级day6-作业

#include<stdio.h>

int main()
{
    printf("mov\npush\npop\n");
    return 0;
}