王道C语言督学营oj练习附个人学习感受（持续更新ing）

初级阶段

个人感受分享：
初级阶段比较基础，但像龙哥说的那样，即使是科班出身，也需要听课。龙哥讲课把C语言以及之后考研用到的数据结构、计算机组成原理都有融合，也带着一步一步进行进行调试，在代码运行和问题解决方面有很大的收获。
这里建议大家上完课立马去写作业进行巩固，否则会对知识有所遗忘，有条件的朋友可以多刷几次课程加深记忆与理解。
关于oj，有时候确实很烦人。但现在BAT企业以及考研复试都是使用oj系统，所以也是刚好的帮助大家适应。我也曾多次被oj折磨的痛不欲生，但在这个过程中也是有提升自己的耐心，当你听到通过声音或者是看到那个绿色的accept的时候，那个感觉也是非常爽的。
希望我们共勉，创造属于我们自己的奇迹。

day1

#include
int main(){
	printf("hello wangdao");
	return 0;
}

day 2

#include
int main(){
  int a,b;
  scanf("%d%d",&a,&b);
  printf("%d",a+b);
	return 0;
}

day 3

#include
int main(){
	int i;
  scantf("%d",&i);
  char c = i;
  printf("%c",i);
  return 0;
}

day 4

#include

int main(){
	int year;
	scanf("%d",&year);
	if(year % 4 ==0 && year % 400 ==0){
		printf("yes");
	}else{
		printf("no");
	}
	return 0;
} 

day 5

#include

int main(){
  int i;
  char j;
  float k;
  int ret;
  ret = scanf("%d %c%f",&i, &j,&k);
  printf("%0.2f\n",i+j+k);
  return 0;
}

day 6

#include

int main(){
	int a,b,c,tmp;
	scanf("%d",&a);
		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;
}

day 7作业1

我是利用循环完成的，也可以运用嵌套的方式

#include

int main(){
  int n;
  int total = 1;
  scanf("%d",&n);
 	for(int i = 1; i <= n; i++){
 		total = total * i;
 }
  printf("%d",total);
	return 0;
}

day 7 作业2

#include 

int main(){
	int num = 0;
	for(int a =1;a<40;a++){
		for(int b = 1;b<40;b++){
			for(int c = 1;c<40;c++){
				for(int d = 1;d<40;d++){
					if(a * 10 +b * 5 + c *2 + d ==100 && a+b+c+d ==40){
								num ++;
						}
					}
				}
			}
		}
	printf("%d",num);
}

day 8

#include
#include
 
 int main(){
 	int a[100];
 	int n,num = 0;
 	scanf("%d\n",&n);
 	for(int i =0;i <n;i++){
	 	scanf("%d",&a[i]);
	 	if(a[i] == 2){
		 	num++;
		 }
	 }
	 printf("%d",num);
 }

day 9

day 10

#include
#include

void change(int *i){
	*i /= 2;
}

int main(){
	int i;
	scanf("%d",&i);
	change(&i);
	printf("%d",i);
	 return 0;
} 

day 11

#include
#include

int main(){
	int i;//申请多大的空间
	scanf("%d",&i);
	char *p;
	p=(char*)malloc(i);//malloc申请空间的单位是字节
	scanf("%c",&p);
	gets(p);
	puts(p);
	return 0;
}

day 12

#include

int f(int n){
	if(1 == n){
		return 1;
	}
	return n*f(n-1);
}

int step(int n){
	if(1 == n){
		return 1;
	}if(2 == n){
		return 2;
	}
	return step(n-1)+step(n -2);
}

int main(){
	int n;
	int ret;
	scanf("%d",&n);
	ret = f(n);
	printf("%d\n",ret);
	scanf("%d\n",&n);
	ret=step(n);
	printf("%d\n",ret);
	return 0;
}

中级阶段

个人感受：
中级阶段主要是与数据结构相结合，认真去学基础理论，跟着龙哥打一遍代码（一定要打一遍），我是跟着龙哥打一遍代码之后将代码作为样本，之后在纸上写代码练习（如果不是考研初试的话建议是上机练习，因为我的编译器都是有提醒，不在纸上练习各种报错格式我记不住，很多时候编代码全靠编译器提醒，对于初试就有一点点不友好）。感觉进入到数据结构部分的习题大多都是参照模板按照oj要求改格式即可，多推多画然后细心一点即可。
一定一定要记得改成C++！！！！还有就是看清楚格式！！！！

day 1

#include

struct student{
	int num;
	char name[20];
	char sex;
};

int main(){
	struct student  s;
	scanf("%d%s %c\n",&s.num,&s.name,&s.sex);
	printf("%d%s %c\n",s.num,s.name,s.sex);
	return 0;
}

day 2

··#include<stdio.h>
#include
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;
}

day 3

#include
#include

#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;//数组下标从零开始，插入第一个位置，访问的下标为0
	L.length++;
	return true;//走到这里代表插入成功

}

//删除元素
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;
}

//打印顺序表元素
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_1;//查看返回值，布尔型是True或者False
    bool ret_2;//查看返回值，布尔型是True或者False
	ElemType del;//用来存储要删除的元素
 	int add_p;
  	int del_p;
  	scanf("%d",&add_p);
	//首先手动在顺序表中赋值
	L.data[0]=1;
	L.data[1]=2;
	L.data[2]=3;
	L.length = 3;//总计三个元素
	ret_1 = ListInsert(L, 2, add_p);//读取的元素固定放在第二个位置
	if(ret_1){

		PrintList(L);
	}else{
		printf("false\n");
	}

	ret_2 = ListDelete(L,del_p,del);//删除第一个位置的元素，并把元素值输出
	if(ret_2){
		printf("删除元素为%d\n",del);
		PrintList(L);
	}else{
		printf("false\n");
	}
	return 0;
}

day 4

#include
#include

typedef int ElempType;
typedef struct LNode{
	ElempType 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 7 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 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;//尾结点的next指针赋值为NULL
		return L;
}

//打印链表中每个结点的值
void PrintList(LinkList L){
	L=L->next;
	while(L != NULL){
		printf("%d",L->data);//打印当前结点数
     	printf(" ");
		L=L->next;//指向下一个结点
	}
	printf("\n");
}

int main(){
	LinkList L;//链表头，是结构体指针类型
	LinkList search;//用来存储拿到的某一个结点
	CreatList1(L);//输入数据可以为3 4 5 6 7 9999，输入9999时候，代表循环结束  头插法新建列表
	PrintList(L);//链表打印
	CreatList2(L);//尾插法
	PrintList(L);//链表打印
}

day 5

#include 
#include 

typedef int ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode *next;//指向下一个结点 
}LNode,*LinkList;

//尾插法新建链表
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 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;//尾结点的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 ListFrontInsert(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)//NULL是为了代表一张空的藏宝图
	{
		printf("%3d",L->data);//打印当前结点数据
		L=L->next;//指向下一个结点
	}
	printf("\n");
}
 
//2.3 线性表的链式表示
int main()
{
	LinkList L;//链表头，是结构体指针类型
	LinkList search;
	CreatList2(L);//输入数据可以为3 4 5 6 7 9999
	PrintList(L);//链表打印
	search=GetElem(L,2);
	if(search!=NULL)
	{
		printf("%d\n",search->data);
	}
	ListFrontInsert(L,2,99);//新结点插入第i个位置
	PrintList(L);
	ListDelete(L,4);//删除第4个结点
	PrintList(L);

}

day 6

#include
#include

#define Maxsize 5
typedef int ElemType;
//静态定义栈
typedef struct{
	ElemType data[Maxsize];//数组
	int top;
}SqStack;

//初始化栈
void InitStack(SqStack &S){
	S.top = -1;//代表栈为空
}

//判断栈为空
bool StackEmpty(SqStack S){
	if(-1 ==S.top){
	return true;
	}else{
		return false;
	}
}


//入栈
bool Push(SqStack &S,ElemType x){
	if(S.top == Maxsize - 1){//栈满
		return false;
	}
	S.data[++S.top] = x;
	return true;//入栈成功
}

//获取栈顶元素
bool GetTop(SqStack S,ElemType &x){
	if(StackEmpty(S))
		return false;
	x= S.data[S.top];
	return true;
}

//弹出栈顶元素
bool Pop(SqStack &S,ElemType &x){
	if(StackEmpty(S)){//栈为空
		return false;
	}
	x = S.data[S.top--];//等价于S.data[S.top];再做S.top--;
	return true;
}

typedef int ElemType;
//静态定义
typedef struct {
	ElemType data[5];//数组，存储Maxsize-1个元素
	int front,rear;//队列头，队列尾
}SqQueue;

//初始化
void InitQueue(SqQueue &Q){
	Q.front = Q.rear = 0;
}

//判空
bool isEmpty(SqQueue Q){
	if(Q.front ==Q.rear){//不需要为零
	return true;
	}
	return false;
}

//入队
bool EnQueue(SqQueue &Q,ElemType x){
	if((Q.rear +1)% 5 == Q.front){
		return false;//队列满了
	}
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear+1)%5;//向后移动一格
	return true;
}

//出队引用
bool DeQueue(SqQueue &Q,ElemType &x){
	if(Q.front == Q.rear){//队列为空
		return false;
	}
	x = Q.data[Q.front];
	Q.front = (Q.front +1) %5;//向后移动一位
	return true;
}


int main(){
	int a1,a2,a3;//需要插入的三个元素
	SqStack S;//初始化S
	bool flag;
	ElemType m;//存储拿出来的栈顶元素
	InitStack(S);
	int i,num;
	for(i=0;i< 3;i++){
		scanf("%d",&num);
		Push(S,num);
	}
	for(i =0;i < 3;i++){
		Pop(S,m);
		printf("%2d",m);
	}
	printf("\n");
	SqQueue Q;
	InitQueue(Q);
	for(i=0;i<5;i++){
		scanf("%d",&num);
		flag=EnQueue(Q,num);
		if(false == flag){
		printf("false\n");
		}
	}
	ElemType element;
	for(i = 0;i < 4;i++){
		DeQueue(Q,element);
		printf("%2d",element);
	}
	printf("\n");
	return 0;
}

day 7

#include
#include

typedef char BiElemType;
typedef struct BiTNode{
	BiElemType 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 int ElemType;
//静态定义栈
typedef struct{
	ElemType data[Maxsize];//数组
	int top;
}SqStack;

//初始化栈
void InitStack(SqStack &S){
	S.top = -1;//代表栈为空
}

//判断栈为空
bool StackEmpty(SqStack S){
	if(-1 ==S.top){
	return true;
	}else{
		return false;
	}
}

//入栈
bool Push(SqStack &S,ElemType x){
	if(S.top == Maxsize -1){//栈满
		return false;
	}
	S.data[++S.top] = x;
	return true;//入栈成功
}

//获取栈顶元素
bool GetTop(SqStack S,ElemType &x){
	if(StackEmpty(S))
		return false;
	x= S.data[S.top];
	return true;
}

//弹出栈顶元素
bool Pop(SqStack &S,ElemType &x){
	if(StackEmpty(S)){//栈为空
		return false;
	}
	x = S.data[S.top--];//等价于S.data[S.top];再做S.top--;
	return true;
}

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

int main(){
	BiTree pnew;
	char c;
	BiTree tree = NULL;//树根
	ptag_t phead = NULL,ptail=NULL,listpnew,pcur;//phead就是队列头，ptail就是队列尾
	//abcdefghij
	while(scanf("%c",&c)!=EOF){
		if(c == '\n'){
			break;
		}
		pnew=(BiTree)calloc(1,sizeof(BiTNode));//calloc申请空间并对空间进行初始化，赋值为0
		pnew->data=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);
}
	

day 8

#include
#include

typedef char BiElemType;
typedef struct BiTNode{
	BiElemType 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{
	ElemType data[Maxsize];//数组
	int top;
}SqStack;

//初始化栈
void InitStack(SqStack &S){
	S.top = -1;//代表栈为空
}

//判断栈为空
bool StackEmpty(SqStack S){
	if(-1 ==S.top){
	return true;
	}else{
		return false;
	}
}

//入栈
bool Push(SqStack &S,ElemType x){
	if(S.top == Maxsize -1){//栈满
		return false;
	}
	S.data[++S.top] = x;
	return true;//入栈成功
}

//获取栈顶元素
bool GetTop(SqStack S,ElemType &x){
	if(StackEmpty(S))
		return false;
	x= S.data[S.top];
	return true;
}

//弹出栈顶元素
bool Pop(SqStack &S,ElemType &x){
	if(StackEmpty(S)){//栈为空
		return false;
	}
	x = S.data[S.top--];//等价于S.data[S.top];再做S.top--;
	return true;
}


//队列相关数据
typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
}LinkNode;

typedef struct{
	LinkNode *front,*rear;
}LinkQueue;

//初始化链表队列
void InitQueue(LinkQueue &Q){
	Q.front = Q.rear =(LinkNode*)malloc(sizeof(LinkNode));
	Q.front->next=NULL;//头结点的next指针为NULL
}

//入队 尾部插入法
void EnQueue(LinkQueue &Q,ElemType x){
	LinkNode *s=(LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	Q.rear->next=s;//rear始终指向尾部
	Q.rear = s;
}

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

//出队  头部删除法
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;
}

//前序遍历  递归实现  深度优先遍历
//abdhiejcfg
void preOrder(BiTree p){
	if(p!=NULL){
		putchar(p->data);//等价于visit函数
		preOrder(p->lchild);
		preOrder(p->rchild);
	}
}

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

//后序遍历 hidjebfgca
void PostOrder(BiTree p){
	if(p!=NULL){
		PostOrder(p->lchild);
		PostOrder(p->rchild);
		putchar(p->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);
	}
}

int main(){
	BiTree pnew;
	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->data=c;//数据放进去  abcdefghij
		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);
}
	
```day 9
![在这里插入图片描述](https://img-blog.csdnimg.cn/6339a42115294d38b278f4f39ef8d265.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA6aG-5bCP5amJ,size_20,color_FFFFFF,t_70,g_se,x_16)

```c
#include
#include

typedef int KeyType;
typedef struct BSTNode{
	KeyType key;
	struct BSTNode *lchild,*rchild;
}BSTNode,*BiTree;

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 Creat_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){//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]);
	}
	Creat_BST(T,str,10);
	int pos=0;
	InOrder(T,str,pos);//中序遍历把有序的结果存入str数组中
	SSTable L;
	L.elem= str;//让顺序表指针指向数组
	L.TableLen = 10;
	pos=Binary_Search(L,21);
	printf("\n%d",pos);
	return 0;
}

day 10

#include
#include
#include
int main(){
	int next[9]={0,1,1,2,2,3,1,1,2};
	for(int i= 0;i<9;i++){
	printf("%2d",next[i]);
	}
}

day 11

#include
#include
#include

typedef int ElemType;
typedef struct{
	ElemType *elem;//存储元素的起始地址
	int TableLen;//元素个数
}SSTable;

void ST_Init(SSTable &ST,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]=rand()%100;//生成的是
	}
}

void swap(ElemType  &a,ElemType &b){
	ElemType tmp;
	tmp=a;
	a=b;b=tmp;
}

//冒泡排序
void BubbleSort(ElemType A[],int n){
	int i,j;
	bool flag;
	for(i=0;i< n-1;i++){//i是控制有多少个有序
		flag = false;
		for(j =n-1;j>0;j--){//内层控制比较，交换
			if(A[j-1]>A[j]){
				swap(A[j-1],A[j]);
				flag=true;
			}
		}
		if(false == flag)
		return ;
	}
}

//快速排序（非王道书上的版本）
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++;
		}
	}
	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 ST_print(SSTable ST){
	for(int i =0;i<ST.TableLen;i++){
		printf("%3d",ST.elem[i]);
	}
	printf("\n");
}

void ST_print1(SSTable ST){
	for(int i =1;i<ST.TableLen;i++){
		printf("%3d",ST.elem[i]);
	}
	printf("\n");
}
void InsertSort(ElemType A[],int n){
	int i,j;
	//24 66 94  2 15 74 28 51 22 18  2
	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];
	for(int i=0;i<10;i++){
		scanf("%3d",&A[i]);
	}
	ST_Init(ST,10);//初始化
	memcpy(ST.elem,A,sizeof(A));//内存copy接口，当你copy整型或者浮点型的时候，要用memcpy
	BubbleSort(ST.elem,10);
	ST_print(ST);
	QuickSort(ST.elem,0,9);
	ST_print(ST);
	InsertSort(ST.elem,9);
	ST_print(ST);
}

day 12

#include
#include
#include
#include

typedef int ElemType;
typedef struct{
	ElemType * elem;//整型指针
	int TableLen;
}SSTable;

void ST_Init(SSTable &ST,int len){
	ST.TableLen=len+1;//实际申请11个元素的空间
	ST.elem=(ElemType *)malloc(sizeof(ElemType)*ST.TableLen);
	int i;
	srand(time(NULL));
	for(i=0;i<ST.TableLen;i++){
		ST.elem[i]=rand()%100;//随机了11个数，但是第一个元素是没有用到的
	}
}

void ST_print(SSTable ST){
	for(int i =0;i<ST.TableLen;i++){
		printf("%3d",ST.elem[i]);
	}
	printf("\n");
}

void InsertSort(ElemType A[],int n){
	int i,j;
	//24 66 94  2 15 74 28 51 22 18  2
	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];
		}
	}
}

//折半查找  插入排序  考的很少
void MidInserSort(ElemType A[],int n){
	int i,j,low,high,mid;
	for(i=2;i<=n;i++){
		A[0]=A[i];
		low=1;high=i-1;//low有序序列的开始，high有序序列的最后
		while(low<=high){//先通过二分查找找到待插入位置
			mid=(low+high)/2;
			if(A[mid]>A[0])
				high=mid-1;
			else
				low=mid+1;
	}
		for(j=i-1;j>=high+1;--j)
			A[j+1]=A[j];
		A[high+1]=A[0];
	}
}

//希尔排序
//多伦插入排序，考大题的概率约等于零，因为编写起来复杂，同时效率并不如快排、堆排
//小题主要考步长的变化是如何的
void ShellSor(ElemType A[],int n){
	int dk,i,j;
	// 73 29 74 51 29 90 37 48 72 54 83
	for(dk=n/2;dk>=1;dk=dk/2){//步长变化
		for(i=dk+1;i<=n;++i){//以dk为步长进行插入排序
			if(A[i]<A[i-dk]){
				A[0]=A[i];
				for(j=i-dk;j>0&&A[0]<A[j];j=j-dk)
					A[j+dk]=A[j];
				A[j+dk]=A[0];
			}
		}
	}
}

//选择排序
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 AdjustDown(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 HeapSort(ElemType A[],int len){
	int i;
	//建立大根堆
	for(i=len/2;i>=0;i--){
		AdjustDown (A,i,len);
	}
	swap(A[0],A[len]);//交换顶部和数组最后一个元素
	for(i=len-1;i>0;i--){
		AdjustDown(A,0,i);//剩下元素调整为大根堆
		swap(A[0],A[i]);
	}
}

int main(){
	SSTable ST;
	ElemType A[10];
	for(int i=0;i<10;i++){
		scanf("%3d",&A[i]);
	}
	ST_Init(ST,10);//实际申请了11个元素空间
	memcpy(ST.elem+1,A,sizeof(A));
	SelectSort(ST.elem,10);//零号元素不参与排序
	ST_print(ST);
	HeapSort(ST.elem,9);//王道书零号元素不参与排序，这个代码是零号元素参与排序的
	ST_print(ST);
}

高级阶段