王道C语言督学营OJ代码（初级中级高级）

初级

week4-day11作业

输入一个整型数，然后申请对应大小空间内存，然后读取一个字符串，字符串的输入长度小于最初输入的整型数大小，最后输出输入的字符串即可（无需考虑输入的字符串过长，超过了内存大小）；

#include <stdio.h>
#include <stdlib.h>
int main()
{
char *p;
int n;
char c;

scanf("%d",&n);

p=malloc(n);

scanf("%c",&c);//注意在scanf和gets中间使用scanf("%c",&c),去除换行

gets(p);

puts(p);

return 0;
}

week4 day12

假如有n个台阶，一次只能上1个台阶或2个台阶，请问走到第n个台阶有几种走法？为便于读者理解题意，这里举例说明如下：假如有3个台阶，那么总计就有3种走法：第一种为每次上1个台阶，上3次；第二种为先上2个台阶，再上1个台阶；第三种为先上1个台阶，再上2个台阶。输入为n，输出为走到第n个台阶有几种走法

#include <stdio.h>
#include <stdlib.h>
int result (int n)
{
    if (n==1)
    {
        return 1;
    }
    else if (n==2)
    {
        return 2;
    }
    else
    {
        return (result(n-1) + result(n-2));
    }
}

int main()
{

int n;

scanf("%d",&n);

int a =result(n);

printf("%d",a);

return 0;
}

中级

day1

输入一个学生的学号，姓名，性别，用结构体存储，通过scanf读取后，然后再通过printf打印输出

#include <stdio.h>
#include <stdlib.h>
struct student{
    int sno;
    char sname[20];
    char sex[10];
};

int main()
{

struct student s;
scanf("%d%s%s",&s.sno,s.sname,s.sex);

printf("%d %s %s",s.sno,s.sname,s.sex);

return 0;
}

——————————————————————————————————————————

以下代码编译器都要选择C++

中级day2

使用C++的引用，注意提交时把代码选为C++；在主函数定义字符指针 char *p,然后在子函数内malloc申请空间，通过fgets读取字符串，然后在主函数中进行输出；要求子函数使用C++的引用，注意在C++中从标准输入读取字符串，需要使用fgets(p,100,stdin)

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
void readp(char *&p)
{
    p = (char *)malloc(100);
    fgets(p,100,stdin);
}

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

day3

初始化顺序表（顺序表中元素为整型），里边的元素是1,2,3，然后通过scanf读取一个元素（假如插入的是6），插入到第2个位置，打印输出顺序表，每个元素占3个空格，格式为1  6  2  3，然后scanf读取一个整型数，是删除的位置（假如输入为1），然后输出顺序表  6  2  3，假如输入的位置不合法，输出false字符串。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define maxsize 50
using namespace std;

typedef int ElemType;

typedef struct{
     ElemType Data[maxsize];
     int length;
}SeqList;


bool InsertList(SeqList &L,int i,int n){

if((i<1)||(i>L.length+1))
{
    return false;
}
else if(L.length+1>maxsize){
    return false;
}
else{
    int j=0;
    for(j=L.length;j>i-1;j--){
        L.Data[j]=L.Data[j-1];
    }
    L.Data[i-1]=n;
    L.length++;
    return true;
}
}

bool DeleteList(SeqList &L,int n){

if((n<1)||(n>L.length)){
    return false;
}
else{
    int j =0;
    int e =0;
    e=L.Data[n-1];
    for(j=n;j<L.length;j++)
    {
        L.Data[j-1]=L.Data[j];
    }
    L.length--;
    return true;
}
}

void PrintList(SeqList L){

int i =0;
for(i=0;i<L.length;i++){
    printf("%3d",L.Data[i]);
}
    printf("\n");
}

int main()
{
    int n =0;
    bool ret;
    SeqList L;
    L.Data[0]=1;
    L.Data[1]=2;
    L.Data[2]=3;
    L.length=3;
    scanf("%d",&n);
    ret=InsertList(L,2,n);
    if(ret){
        PrintList(L);}
    else{
        printf("false");}
    scanf("%d",&n);
    ret=DeleteList(L,n);
    if(ret){
        PrintList(L);}
    else{
        printf("false");}
    return 0;
}

中级day4

输入3 4 5 6 7 9999一串整数，9999代表结束，通过头插法新建链表，并输出，通过尾插法新建链表并输出

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

typedef int ElemType;

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


void PrintList(LinkList L)
{
L=L->next;
while(L!=NULL)
{
printf("%d",L->data);///打印当前结点数据

L=L->next;///指向下一个结点

if(L!=NULL)
{
printf(" ");
}
}
printf("\n");
}

LinkList touInsertList(LinkList &L)
{
    LNode *p;
    int x;
    L = (LinkList) malloc(sizeof(LinkList));///*LinkList p = (*LinkList) malloc(10*sizeof(*LinkList));
    L->next=NULL;
    scanf("%d",&x);
    while(x!=9999)
    {
        p = (LinkList) malloc(sizeof(LinkList));
        p->data = x;
        p->next=L->next;///p指向l的下一个节点
        L->next=p;///l的下一个节点指向p
        scanf("%d",&x);
    }

    return L;

}

LinkList weiInsertList(LinkList &L)
{

    int x;
    L = (LinkList)malloc(sizeof(LinkList));
    LinkList p=L;///LinkList p;
    LinkList r=L;///LinkList r=NULL;
    ///L->next = r;
    scanf("%d",&x);
    while(x!=9999)
    {
        p=(LinkList)malloc(sizeof(LinkList));
        p->data=x;
        ///p->next=NULL;
        r->next=p;
        r=p;
        scanf("%d",&x);
    }
    r->next=NULL;
    return L;
}

int main()
{
    LinkList L;   
    touInsertList(L);
    PrintList(L);

    LinkList M;  
    weiInsertList(M);
    PrintList(M);
    return 0;
}

day6

新建一个栈，读取标准输入3个整数3 4 5，入栈3 4 5，依次出栈，打印 5 4 3，新建循环队列（Maxsize为5），读取标准输入3 4 5 6 7，入队7时，队满，打印false，然后依次出队，输出 3 4 5 6

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define maxsize 10
#define maxsize1 5

using namespace std;
///读取标准输入3个整数3 4 5，入栈3 4 5，依次出栈，打印 5 4 3
///新建循环队列（Maxsize为5，读取标准输入5个整数，入队7时，队满，打印false，然后依次出队，输出 3 4 5 6
typedef int ElemType;

typedef struct Sqtack{
     ElemType data[maxsize];
     int top;
}SqStack;
typedef struct SQueue{
     ElemType data[maxsize1];
     int rear,qfront;
}SqQueue;


void initSqStack(SqStack &s)
{
    s.top=-1;
}
void initSqQueue(SqQueue &s)
{
    s.qfront=s.rear=0;
}

bool push(SqStack &s,ElemType x)
 {
     if(s.top==maxsize)
     {
         return false;
     }
     s.data[++s.top]=x;
     return true;
 }
 bool insertQueue(SqQueue &s,ElemType x)
 {
    if(s.qfront==(s.rear+1)%maxsize1)
    {
        printf("false\n");
        return false;
    }
     s.data[s.rear]=x;
     s.rear=(s.rear+1)%maxsize1;

     return true;
 }
 bool pop(SqStack &s,ElemType &x)
 {
     if(s.top==-1)
     {
         return false;
     }
     x=s.data[s.top--];
     return true;
 }
 bool DeQueue(SqQueue &s,ElemType &x)
 {
     if(s.qfront==s.rear)
     {
         return false;
     }
     x=s.data[s.qfront];
     s.qfront=(s.qfront+1)%maxsize1;
     return true;
 }
int main()
{
    ElemType x=1,e;
    int i;
    SqStack s;
    initSqStack(s);
    for(i=0;i<3;i++)
    {
      scanf("%d",&e);
      push(s,e);
    }
      for(i=0;i<3;i++)
    {
      pop(s,x);
      printf("%2d",x);
    }
    printf("\n");
    SqQueue m;
    initSqQueue(m);

    for(i=0;i<5;i++)
    {
      scanf("%d",&e);
      insertQueue(m,e);
    }
    while(m.qfront!=m.rear)
    {
      DeQueue(m,e);
      printf("%2d",e);
    }
    printf("\n");
    return 0;
}

day7

读取字符串abcdefghij，然后层次建树建立一颗二叉树，然后前序遍历输出abdhiejcfg，注意不要打印前序遍历几个汉字

#include <stdio.h>
#include <stdlib.h>
//#include<string>///不是#include<string.h>
//using namespace std;///不加这一句会报错: 'str' was not declared in this scope
//#define MaxSize 100
typedef char BiElemType;
typedef int ElemType;
typedef struct BiTNode{

    BiElemType data;
    struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;

typedef struct tag{
    BiTree p;///树的某一个节点的地址值
    struct tag *pnext;
}tag,*tag_t;

typedef struct LinkNode{
    ElemType qdata;
    struct LinkNode *next;

}LinkNode;
typedef struct LinkQueue{

    LinkNode *pfront,*prear;
}LinkQueue;

void InitQueue(LinkQueue &Q)
{
    Q.pfront=(LinkNode*)malloc(sizeof(LinkNode));
    Q.prear=(LinkNode*)malloc(sizeof(LinkNode));
    Q.pfront->next=NULL;
}

bool isEmpty(LinkQueue Q)
{
    if(Q.pfront==Q.prear)
        return true;
    else
        return false;
}

void EnQueue(LinkQueue &Q,ElemType x)
{
    LinkNode *p=(LinkNode*)malloc(sizeof(LinkNode));
    p->qdata=x;
    p->next=NULL;
    Q.prear->next=p;
    Q.prear=p;
}
bool DeQueue(LinkQueue &Q,ElemType &x)
{
    if(isEmpty(Q))
        return false;
    else{
        LinkNode *p=Q.pfront->next;
        x=p->qdata;
        Q.pfront->next=p->next;
        if (Q.prear == p)
		Q.prear = Q.pfront;
	free(p);
	return true;

    }
}
void PreOrder(BiTree T)
{
    if(T!=NULL)
    {
        putchar(T->data);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }

}

///读取字符串abcdefghij，然后层次建立一颗二叉树，然后前序遍历输出abdhiejcfg，注意不要打印前序遍历几个汉字

int main() {
	/*char s[50]; ///元素自动定为空字符（即'\0' )
    //gets(s);
    for(int i=0;s[i]=='\0';i++)///s[i]!="0","0"是字符串的首地址,ISO C++ forbids comparison between pointer and integer
    {
       printf("a");
    }
    //puts(s);
    char str[50] = {0};
    scanf("%s", str);
    int i = 0;
    BiTree root = creatTree(str, &i);
    preprint(root);*/
  BiTree pnew;
	char c;
    BiTree tree = NULL;///树根
	tag_t phead = NULL, ptail = NULL, listpnew, pcur;///phead就是队列头，ptail就是队列尾
    while(scanf("%c",&c)!=EOF)///c可以将读入的字符串拆成一个一个的
    {
        if(c=='\n')
        {
            break;
        }
            pnew = (BiTree)calloc(1, sizeof(BiTNode));///sizeof(BiTNode)错.calloc申请空间并对空间进行初始化，赋值为0
            pnew->data = c;///数据放进去
            listpnew = (tag_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

读取字符串abcdefghij，然后层次建树建立一颗二叉树，然后中序遍历输出 hdibjeafcg，后序遍历输出 hidjebfgca，层序遍历输出abcdefghij，注意不要输出汉字

#include <stdio.h>
#include <stdlib.h>
using namespace std;

///读取字符串abcdefghij，然后层次建树建立一颗二叉树，然后中序遍历输出 hdibjeafcg，后序遍历输出 hidjebfgca，层序遍历输出abcdefghij，注意不要输出汉字
typedef char BiElemType;


typedef struct BiTNode{

    BiElemType data;
    struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;

typedef BiTree ElemType;

typedef struct tag{
    BiTree p;///树的某一个节点的地址值
    struct tag *pnext;
}tag,*tag_t;

typedef struct LinkNode{
    ElemType qdata;
    struct LinkNode *next;

}LinkNode;
typedef struct {

    LinkNode *pfront,*prear;
}LinkQueue;

void InitQueue(LinkQueue &Q)
{
    Q.pfront=Q.prear=(LinkNode*)malloc(sizeof(LinkNode));
    Q.pfront->next=NULL;
}

bool isEmpty(LinkQueue Q)
{
    if(Q.pfront==Q.prear)
        return true;
    else
        return false;
}

void EnQueue(LinkQueue &Q,ElemType x)
{
    LinkNode *p=(LinkNode*)malloc(sizeof(LinkNode));
    p->qdata=x;
    p->next=NULL;
    Q.prear->next=p;
    Q.prear=p;
}
bool DeQueue(LinkQueue &Q,ElemType &x)
{
    if(isEmpty(Q))
        return false;
    else{
        LinkNode *p=Q.pfront->next;
        x=p->qdata;
        Q.pfront->next=p->next;
        if (Q.prear == p)
		Q.prear = Q.pfront;
	free(p);
	return true;

    }
}
void PreOrder(BiTree T)
{
    if(T!=NULL)
    {
        putchar(T->data);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }

}
void InOrder(BiTree T)
{
    if(T!=NULL)
    {

        InOrder(T->lchild);
        putchar(T->data);
        InOrder(T->rchild);
    }

}
void PostOrder(BiTree T)
{
    if(T!=NULL)
    {

        PostOrder(T->lchild);
        PostOrder(T->rchild);
        putchar(T->data);
    }

}
void LevelOrder(BiTree T)
{
    LinkQueue Q;
    InitQueue(Q);
    BiTree p;
    EnQueue(Q,T);
   while(!isEmpty(Q))
    {
        DeQueue(Q,p);
        putchar(p->data);
        if(p->lchild!=NULL)
            EnQueue(Q,p->lchild);
        if(p->rchild!=NULL)
            EnQueue(Q,p->rchild);

    }

}
///读取字符串abcdefghij，然后层次建立一颗二叉树，然后前序遍历输出abdhiejcfg，注意不要打印前序遍历几个汉字

int main() {
	/*char s[50]; ///元素自动定为空字符（即'\0' )
    //gets(s);
    for(int i=0;s[i]=='\0';i++)///s[i]!="0","0"是字符串的首地址,ISO C++ forbids comparison between pointer and integer
    {
       printf("a");
    }
    //puts(s);
    char str[50] = {0};
    scanf("%s", str);
    int i = 0;
    BiTree root = creatTree(str, &i);
    preprint(root);*/
  BiTree pnew;
	char c;
    BiTree tree = NULL;///树根
	tag_t phead = NULL, ptail = NULL, listpnew, pcur;///phead就是队列头，ptail就是队列尾
    while(scanf("%c",&c)!=EOF)///c可以将读入的字符串拆成一个一个的。
    {
        if(c=='\n')
        {
            break;
        }
            pnew = (BiTree)calloc(1, sizeof(BiTNode));///sizeof(BiTNode)错.calloc申请空间并对空间进行初始化，赋值为0
            pnew->data = c;///数据放进去
            listpnew = (tag_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);
    InOrder(tree);
    printf("\n");
    PostOrder(tree);
    printf("\n");
    LevelOrder(tree);
    printf("\n");
}

day9

读取10个元素 87  7 60 80 59 34 86 99 21  3，然后建立二叉查找树，中序遍历输出3  7 21 34 59 60 80 86 87 99，针对有序后的元素，存入一个长度为10的数组中，通过折半查找找到21的下标（下标为2），然后输出2

#include <stdio.h>
#include <stdlib.h>
using namespace std;
///读取10个元素 87  7 60 80 59 34 86 99 21  3，然后建立二叉查找树，
///中序遍历输出3  7 21 34 59 60 80 86 87 99，针对有序后的元素，存入一个长度为10的数组中，
///通过折半查找找到21的下标（下标为2），然后输出2
typedef int ElemType;

typedef struct BiTNode{

    ElemType key;
    struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;

int Insert_Tree(BiTree &T,int key)
{
    if(T==NULL)
    {
        T=(BiTNode*)malloc(sizeof(BiTNode));
        T->key=key;
        T->lchild=NULL;
        T->rchild=NULL;
        return 1;
    }
    else if(T!=NULL&&key>T->key)
    {
        Insert_Tree(T->rchild,key);
        return 1;
    }
    else if(T!=NULL&&key<T->key)
       {
          Insert_Tree(T->lchild,key);
          return 1;
       }
    else
        return 0;
}

void InOrder(BiTree T,int* b,int &j)
{
    if(T!=NULL)
    {
        InOrder(T->lchild,b,j);
        printf("%3d",T->key);
        b[j]=T->key;
        j++;
        InOrder(T->rchild,b,j);
    }

}

int BinarySearch(int *b,int key)
{
    int low=0,hight=9,mid;
    while(low<=hight){
      mid=(low+hight)/2;
    if(key==b[mid])
    {
        return mid;
    }
    else if(key>b[mid])
    {
        low = mid +1 ;
    }
     else if(key<b[mid])
    {
        hight = mid - 1 ;
    }

    }
    return -1;
}

int main() {
	int a[10],i,b[10]={0},j=0,pos=-1;
	BiTree T = NULL;
	for(i=0;i<10;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i=0;i<10;i++)
    {
       Insert_Tree(T,a[i]);
    }
    InOrder(T,b,j);
    printf("\n");
    pos=BinarySearch(b,21);
    printf("%d",pos);
    return 0;
}

day11

读取10个整型数据12 63 58 95 41 35 65  0 38 44，然后通过冒泡排序，快速排序，插入排序，分别对该组数据进行排序，输出3次有序结果，每个数的输出占3个空格

#include <stdio.h>
#include <stdlib.h>
using namespace std;
///day11 读取10个整型数据12 63 58 95 41 35 65  0 38 44，然后通过冒泡排序，快速排序，插入排序，
///分别对该组数据进行排序，输出3次有序结果，每个数的输出占3个空格

void InsertSort(int *a,int n)
{
    int i,j,temp;
    for(i=1;i<n;i++)
    {
        if(a[i]<a[i-1])
        {
            temp=a[i];
            for(j=i-1;j>=0&&a[j]>temp;--j){/// for(j=i-1;j>=0&&a[j]>a[i];--j)错 ，为什么呢
                a[j+1]=a[j];
            }
            a[j+1]=temp;
        }
    }
}

int partitionsort(int *a,int low,int high)
{
    int data=a[low];
    while(low<high)
    {
        while((low<high)&&(data<=a[high]))///while((low<high)&&(a[low]<=a[high]))错
            --high;///high--;错
            a[low]=a[high];
        while((low<high)&&(a[low]<=data))///while((low<high)&&(a[low]<=a[high]))错
            ++low;///++low;错
            a[high]=a[low];
    }
    a[low]=data;

    return low;
}

void quickSort(int *a,int low,int high)
{
    if(low<high)
    {
        int pos=partitionsort(a,low,high);
        quickSort(a,low,pos-1);
        quickSort(a,pos+1,high);
    }
}

void BubbleSort(int *a,int n)
{
    int i,j;
    for(i=0;i<n-1;i++)
    {
        int flag=0;
        for(j=n-1;j>i;j--)
        {
            if(a[j-1]>a[j])
            {
                int temp;
                temp=a[j-1];
                a[j-1]=a[j];
                a[j]=temp;
                flag=1;
            }
        }
        if(flag==0)
            return;
    }
}

int main() {
    int a[10]={12,63,58,95,41,35,65,0,38,44};
    BubbleSort(a,10);
    for(int i =0;i<10;i++)
    {
      printf("%3d",a[i]);
    }
    printf("\n");
    int b[10]={12,63,58,95,41,35,65,0,38,44};
    quickSort(b,0,9);
    for(int i =0;i<10;i++)
    {
      printf("%3d",b[i]);
    }
    printf("\n");
    int c[10]={12,63,58,95,41,35,65,0,38,44};
    InsertSort(c,10);
    for(int i =0;i<10;i++)
    {
      printf("%3d",c[i]);
    }
    return 0;
}

day12

读取10个整型数据12 63 58 95 41 35 65  0 38 44，然后通过选择排序，堆排序，分别对该组数据进行排序，输出2次有序结果，每个数的输出占3个空格

#include <stdio.h>
#include <stdlib.h>
using namespace std;
///day11 读取10个整型数据12 63 58 95 41 35 65  0 38 44，然后通过选择排序，堆排序，
///分别对该组数据进行排序，输出2次有序结果，每个数的输出占3个空格

void SelectSort(int a[],int n)
{
    int i,j;
    for(i=0;i<n-1;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(a[j]<a[i])
                {
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
                }
        }
    }
}

void AdjustHeap(int a[],int k,int len)
{
    int temp=a[k];
    for(int i=2*k;i<len;i*=2)
    {
        if(i<len-1&&a[i]<a[i+1])
        {
            i++;
        }
        if(temp>=a[i])
            break;

        else{
            a[k]=a[i];
            k=i;
        }
    }
    a[k]=temp;
}

void BuildHeap(int a[],int len)
{
    for(int i=(len-1)/2;i>=0;i--)
    {
        AdjustHeap(a,i,len);
    }
}

void HeapSort(int a[],int len)
{
    BuildHeap(a,len);
    for(int i=len-1;i>0;i--)
    {
        int temp = a[i];
        a[i]=a[0];
        a[0]=temp;
        AdjustHeap(a,0,i);
    }
}

int main() {
    int a[10]={12,63,58,95,41,35,65,0,38,44};
    SelectSort(a,10);
    for(int i =0;i<10;i++)
    {
      printf("%3d",a[i]);
    }
    printf("\n");
    int b[10]={12,63,58,95,41,35,65,0,38,44};
    HeapSort(b,10);
    for(int i =0;i<10;i++)
    {
      printf("%3d",b[i]);
    }

    return 0;
}

高级day1

读取10个整型数据12 63 58 95 41 35 65  0 38 44，然后通过归并排序，对该组数据进行排序，输出有序结果，每个数的输出占3个空格

#include <stdio.h>
#include <stdlib.h>
using namespace std;
///day11 读取10个整型数据12 63 58 95 41 35 65  0 38 44，然后通过选择排序，堆排序，
///分别对该组数据进行排序，输出2次有序结果，每个数的输出占3个空格

void SelectSort(int a[],int n)
{
    int i,j;
    for(i=0;i<n-1;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(a[j]<a[i])
                {
                int temp=a[i];
                a[i]=a[j];
                a[j]=temp;
                }
        }
    }
}

void AdjustHeap(int a[],int k,int len)
{
    int temp=a[k];
    for(int i=2*k;i<len;i*=2)
    {
        if(i<len-1&&a[i]<a[i+1])
        {
            i++;
        }
        if(temp>=a[i])
            break;

        else{
            a[k]=a[i];
            k=i;
        }
    }
    a[k]=temp;
}

void BuildHeap(int a[],int len)
{
    for(int i=(len-1)/2;i>=0;i--)
    {
        AdjustHeap(a,i,len);
    }
}

void HeapSort(int a[],int len)
{
    BuildHeap(a,len);
    for(int i=len-1;i>0;i--)
    {
        int temp = a[i];
        a[i]=a[0];
        a[0]=temp;
        AdjustHeap(a,0,i);
    }
}
int *b=(int *)malloc(sizeof(int*));

void MergeAB(int a[],int low,int mid,int high)
{
    for(int k=low;k<=high;k++)
    {
        b[k]=a[k];
    }
    int i =low;int j=mid+1;int k=low;
    for(;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(int a[],int low,int high)
{
    if(low<high)
    {
        int mid=(low+high)/2;
        MergeSort(a,low,mid);
        MergeSort(a,mid+1,high);
        MergeAB(a,low,mid,high);
    }
}

int main() {

    int a[10]={12,63,58,95,41,35,65,0,38,44};
    MergeSort(a,0,9);
    for(int i =0;i<10;i++)
    {
      printf("%3d",a[i]);
    }

    return 0;
}

高级day2

图的顶点和边如下，直接初始化好，无需读取标准输入，完成有向图的邻接表初始化，完成深度优先遍历，广度优先遍历

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'}};

#include <stdio.h>
#include <stdlib.h>
#include <cstring>
using namespace std;
#define Maxsize 20
/*图的顶点和边如下，直接初始化好，无输入，完成有向图的邻接表初始化，完成深度优先遍历，广度优先遍历
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'}};
输出内容如下（注意每个字母占两个字符位置%2d）：
A B C E D F G
A B C E F D G
*/
typedef struct arcNode{//边邻接表结构体

    int ivex;//边指向的节点的位置
    struct arcNode* next;//节点的下一条边

}arcNode;
typedef struct VNode//顶点邻接表结构体
{
    char data;//节点存的信息
    arcNode* first;//节点指向的第一条边
}VNode,AdjList[Maxsize];
typedef struct Graph//图的结构体
{
    AdjList LGraph;//图的邻接表
    int vexnum,arcnum;//顶点数，边数
}Graph;
static int getposition(Graph g,char ch)
{
    for(int i=0;i<g.vexnum;i++)
    {
        if(g.LGraph[i].data==ch)
            return i;
    }
    return -1;
}
Graph* create()
{
    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 lvex=(sizeof(vexs)/sizeof(vexs[0]));///获取长度
    int ledge=(sizeof(edges)/sizeof(edges[0]));///获取行数,求数组列数： sizeof(a[0])/sizeof(int)
    int p1,p2;
    arcNode * node1;
    Graph *G;
    if((G=(Graph*)malloc(sizeof(Graph)))==NULL)
        return NULL;
    memset(G,0,sizeof(Graph));///将申请的内存单元的值都置为0
    G->arcnum=ledge;
    G->vexnum=lvex;
    for(int i=0;i<G->vexnum;i++)///初始化顶点邻接表
    {
        G->LGraph[i].data=vexs[i];
        G->LGraph[i].first=NULL;
    }
    for(int i =0;i<G->arcnum;i++)
    {
        c1=edges[i][0];
        c2=edges[i][1];
        p1=getposition(*G,c1);
        p2=getposition(*G,c2);

    node1=(arcNode*)calloc(1,sizeof(arcNode));
    node1->ivex=p2;
    if(G->LGraph[p1].first==NULL)
    {
        G->LGraph[p1].first=node1;
    }
    else
    {
        arcNode* node3= G->LGraph[p1].first;
       while(node3->next)
        {node3=node3->next;}
       node3->next=node1;

        }
    }
    return G;
}
void printGraph(Graph G)
{
    int i;
    arcNode* node;
    for(i=0;i<G.vexnum;i++)
    {
        printf("%d(%c)   ",i,G.LGraph[i].data);
        node=G.LGraph[i].first;
        while(node!=NULL)
        {
            printf("%d(%c)",node->ivex,G.LGraph[node->ivex].data);
            node=node->next;
        }
    printf("\n");
    }

}

static void DFS(Graph G,int i,int* visited)
{
    arcNode* node;
    visited[i]=1;
    printf("%2c",G.LGraph[i].data);
    node=G.LGraph[i].first;
    while(node!=NULL)
    {
        if(visited[node->ivex]==0)
    {
        DFS(G,node->ivex,visited);
    }//注意加括弧的位置
    node=node->next;
    }

}
void DFSTraverse(Graph G)
{
    int i;
    int visited[Maxsize];
    for(i=0;i<G.vexnum;i++)
    {
        visited[i]=0;
    }
    for(i=0;i<G.vexnum;i++)
    {
        if(visited[i]==0)
        {
            DFS(G,i,visited);
        }
    }
    printf("\n");
}

void BFS(Graph G)///图的广度优先遍历
{

    int head=0,rear=0;
    int sequeue[Maxsize];///辅助队列是数组
    int visit[Maxsize];
    int i,j,k;
    arcNode * node;
    //每个顶点未被访问

    for(i = 0;i<G.vexnum;i++)
    {
        visit[i]=0;
    }

    for(i=0;i<G.vexnum;i++)
    {
        if(visit[i]==0)
        {
            visit[i]=1;
            printf("%2c",G.LGraph[i].data);
            sequeue[rear++]=i;
        }

        while(head!=rear)
        {
            k=sequeue[head++];
            node=G.LGraph[k].first;
            while(node!=NULL)
            {
                j=node->ivex;
                if(visit[j]==0)
                {
                    visit[j]=1;
                    printf("%2c",G.LGraph[j].data);
                    sequeue[rear++]=j;
                }
                node=node->next;
            }

        }
    }
    printf("\n");
}

int main() {
    Graph *G;///定义成结构体malloc完后会释放掉
    G=create();
    ///printGraph(*G);
    DFSTraverse(*G);
    BFS(*G);
    return 0;
}