(c++)王道oj小练习2

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

description：使用C++的引用，注意提交时把代码选为C++；在主函数定义字符指针 char *p,然后在子函数内malloc申请空间，通过fgets读取字符串，然后在主函数中进行输出；要求子函数使用C++的引用，注意在C++中从标准输入读取字符串，需要使用fgets(p,100,stdin)
input: 输入一个字符串，例如 I love C language
output: 如果输入的是I love C language，那么输出也是I love C language
sample input：I love C language    sample output：I love C language
sample input：how are you       sample output：how are you

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

void PrintNum(char *&p) {
	p = (char*)malloc(200);//动态申请
	fgets(p, 100, stdin);
}
int main()
{
	char* p;
	PrintNum(p);
	puts(p);
	return 0;
}

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

description：第一次输入插入的元素值，第二次输入删除的位置
input: 假如插入的元素为6，那么输出为
1 6 2 3
output: 假如删除的位置为1，那么输出为
6 2 3
sample input1：6
         1
sample output1： 1 6 2 3
           6 2 3
sample input2：9
         3
sample output2： 1 9 2 3
           1 9 3
sample input3：9
         3
sample output3：1 9 2 3
           false

#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;

//打印顺序表
void PrintList(SqList &L) {
	for (int i = 0; i < L.length; i++) {
		printf("%3d", L.data[i]);
	}
	printf("\n");
}
//插入操作
bool PrintInsert(SqList& L, int i, ElemType e)
{
	if (i<1 || i>L.length) {
		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;
}
//删除操作
bool PrintDelete(SqList& L, int i)
{
	if (i<1 || i>L.length) {
		return false;
	}
	if (L.length == 0) {
		return false;
	}
	for (int j = i; j < L.length; j++)
	{
		L.data[j - 1] = L.data[j];
	}
	//int a = L.data[i - 1];
	L.length--;
	return true;
}

int main()
{
	int e;//定义元素
	int i=2;//定义元素的位置
	SqList L;
	bool result;
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.length = 3;
	scanf("%d", &e);//读取一个元素
	result=PrintInsert(L,i,e);
	if(result){
		PrintList(L);
		scanf("%d", &i);//读取一个删除的位置
		result=PrintDelete(L,i);
		if (result) {
			PrintList(L);
		}
		else
		{
			printf("%s", "false");
		}
	}
	return 0;
}

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

description：第一次输入插入的元素值，第二次输入删除的位置
input:3 4 5 6 7 9999，第二行也是3 4 5 6 7 9999，数据需要输入两次
output:如果输入是3 4 5 6 7 9999，那么输出是7 6 5 4 3，数之间空格隔开，尾插法的输出是3 4 5 6 7
sample input1：3 4 5 6 7 9999
          3 4 5 6 7 9999
sample output1： 7 6 5 4 3
           3 4 5 6 7
sample input2：1 3 5 7 9 9999
         1 3 5 7 9 9999
sample output2：9 7 5 3 1
           1 3 5 7 9

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int	ELemType;//宏定义
typedef struct LNode {
	ELemType data;
	struct  LNode* next;//指向下一个结点(结构体指针)
}LNode, * LinkList;

 void PrintfList(LinkList L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%d", L->data);//打印当前结点数据
		L = L->next;//指向下一个结点
		if (L != NULL)
		{
			printf(" ");
		}
	}
	printf("\n");

}
//头插法
LinkList CreateList1(LinkList& L) {
	LNode* s; //新的结构体指针变量
	int x;
	L = (LinkList)malloc(sizeof(LNode));//头结点
	L->next = NULL;//L->里面没有放东西
	scanf("%d", &x);
	//3 4 5 6 7 9999
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));//申请内存
		s->data = x;//把读到的值给新空间中data成员
		s->next = L->next;//把新节点指向第一个元素的结点
		L->next = s;//让L指向新节点，让s作为第一个元素
		scanf("%d", &x);
	}
	return L;
}
LinkList CreateList2(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));//带头结点的链表
	LNode* s, * r = L;//LinkList  s,r=L;
	scanf("%d", &x);
	while (x != 9999)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;//r指向表为结点
		scanf("%d", &x);
	}
	r->next = NULL;
	return  L;
}
int main() {
	LinkList L;//链表头，是结构体指针类型
	CreateList1(L);
	PrintfList(L);
	CreateList2(L);
	PrintfList(L);
}

1.4输入3 4 5 6 7 9999一串整数，9999代表结束，通过尾插法新建链表，查找第二个位置的值并输出，在2个位置插入99，输出为 3 99 4 5 6 7，删除第4个位置的值，打印输出为 3 99 4 5 6 7。

description：输入3 4 5 6 7 9999一串整数，9999代表结束，通过尾插法新建链表，查找第二个位置的值并输出，在2个位置插入99，输出为 3 99 4 5 6 7，删除第4个位置的值，打印输出为 3 99 4 5 6 7。
input:输入是3 4 5 6 7 9999
output:输出是
4
3 99 4 5 6 7
3 99 4 6 7
sample input1：3 4 5 6 7 9999
sample output1：4
             3 99 4 5 6 7
             3 99 4 6 7

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

typedef int	ELemType;//宏定义
typedef struct LNode {
	ELemType data;
	struct  LNode* next;//指向下一个结点(结构体指针)
}LNode, * LinkList;
//打印数组
void PrintList(LinkList L)
{
	L = L->next;
	while (L != NULL)
	{
		printf("%3d", L->data);//打印当前结点数据
		L = L->next;//指向下一个结点
	}
	printf("\n");
}
//通过尾插法创建链表
LinkList CreatList(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));//带头结点的链表
	LNode* s;
	LNode* r = L;//LinkList  s,r=L;r代表表尾结点，指向链表尾部
	scanf("%d", &x);
	while (x != 9999)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;//r指向表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;
	return  L;
}
//查找第二个位置的元素
LinkList GetElement(LinkList L, ELemType i) {
	LinkList p = L->next;
	if (i == 0) {
		return L;
	}
	if (i < 1) {
		return NULL;
	}
	int j = 1;
	while (p && j < i) {
		p = p->next;
		j++;
	}
	return p;
}
//在第二个位置插入99
bool LinkInsert(LinkList& L,int i, ELemType e) {
	LinkList p =GetElement(L,i - 1);//拿到前一个位置的地址值
	if (p == NULL) {
		return false;
	}
	LinkList q = (LinkList)malloc(sizeof(LNode));
	q->data=e;
	q->next = p->next;
	p->next = q;
	return true;
}
//删除第四个位置的元素
bool LinkDelete(LinkList& L, int i) {
	LinkList p=GetElement(L, i - 1);
	if (p == NULL) {
		return false;
	}
	LinkList q = p->next;
	p->next = q->next;
	free(q);
	return true;
}
int main()
{
	LinkList L;
	ELemType e;
	CreatList(L);//3 4 5 6 7 9999
	LinkList p=GetElement(L, 2);
	printf("%d\n", p->data);
	LinkInsert(L, 2, 99);
	PrintList(L);
	LinkDelete(L, 4);
	PrintList(L);
}

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

description：新建一个栈，读取标准输入3个整数3 4 5，入栈3 4 5，依次出栈，打印 5 4 3，新建循环队列（Maxsize为5），读取标准输入3 4 5 6 7，入队7时，队满，打印false，然后依次出队，输出 3 4 5 6
input:读取标准输入，内容依次是3 4 5，换行后，接着是3 4 5 6 7
output:如果输入是3 4 5，换行，接着是3 4 5 6 7，那么输出是
5 4 3
false
3 4 5 6

注意每个数字占用两个字符的位置，5之前是有一个空格的，第三行的3之前也是有一个空格的
sample input：3 4 5
         3 4 5 6 7
sample output： 5 4 3
           false
            3 4 5 6

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
//新建一个栈，读取标准输入3个整数3 4 5，入栈3 4 5，依次出栈，打印 5 4 3，
//新建循环队列（Maxsize为5），读取标准输入3 4 5 6 7，入队7时，队满，打印false，
//然后依次出队，输出 3 4 5 6
#define MaxSize 5
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];
	int top;
}Sqstack;

typedef struct {
	ElemType data[MaxSize];
	int rear;
	int front;
}Squeue;

void  InitStack(Sqstack& s) {
	s.top = -1;
}
void  InitQueue(Squeue& q) {
	q.rear = q.front = 0;
}
//入栈
bool Push(Sqstack& s,ElemType e)
{
	if (s.top == MaxSize - 1) {
		return false;
	}
	s.data[++s.top] = e;
	return true;
}
//入队
bool EnQueue(Squeue& q, ElemType &e)
{
	if ((q.rear + 1) % MaxSize == q.front) {//队列满了
		return false;
	}
	 q.data[q.rear]=e;
	q.rear = (q.rear + 1) % MaxSize;//改变队尾
	return true;
}
//出队
bool DeQueue(Squeue& q, ElemType& e) {
	if (q.rear == q.front) {
		return false;
	}
	e = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;//改变队尾
	return true;
}

//出栈
bool Pop(Sqstack& s,ElemType &m) {
      //获取栈顶元素
		m = s.data[s.top];
		s.top--;
	    return true;
}

int main() {
	Sqstack s;
	ElemType m;
	bool flag;
	ElemType element;//存储出队的元素
   //初始化
	InitStack(s);
	//判断栈空
	//入栈
	int x;
	for(int i=0;i<3;i++){
		scanf("%d", &x);
	    Push(s, x);
	}
	//出栈
	for (int i = 0; i < 3; i++) {
		Pop(s, m);
		printf("%2d", m);
	}
	printf("\n");
	Squeue q;
	//初始化队列
	InitQueue(q);
	//入队
	int y;
	for (int i = 0; i < 5; i++) {
		scanf("%d", &y);
		flag =EnQueue(q, y);
		if (!flag) {
			printf("false\n");
		}
	}
	//出队
	for (int i = 0; i < 4; i++) {
		DeQueue(q, element);
		printf("%2d", element);
	}
	return 0;
}

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

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
//层次建树
//树节点数据结构
typedef char BiElemType;
typedef struct BiTNode {
	BiElemType data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;
//2(层数-1)满二叉树、完全二叉树

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

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

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

		if (NULL == pcur->p->lchild) {
			pcur->p->lchild = pnew;
		}
		else if (NULL == pcur->p->rchild) {
			pcur->p->rchild = pnew;
			pcur = pcur->pnext;
		}
	}
	//前序输出
	PreOrder(tree);
	return 0;
}

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

description：读取字符串abcdefghij，然后层次建树建立一颗二叉树，然后中序遍历输出 hdibjeafcg，后序遍历输出 hidjebfgca，层序遍历输出abcdefghij，注意不要输出汉字
input:abcdefghij
output:中序遍历输出hdibjeafcg，后序遍历输出 hidjebfgca，层序遍历输出abcdefghij，每个一行
sample input：abcdefghij
sample output：hdibjeafcg
            hidjebfgca
            abcdefghij

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
//层次建树
//树节点数据结构
typedef char BiElemType;
typedef struct BiTNode {
	BiElemType data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;
//2(层数-1)满二叉树、完全二叉树
typedef BiTree ElemType;
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)
{
	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 Inorder(BiTree tree) {
	if (tree!= NULL) {
		Inorder(tree->lchild);
		putchar(tree->data);
		Inorder(tree->rchild);
	}
}

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

void LevelOrder(BiTree tree) {
	LinkQueue Q;
	InitQueue(Q);
	BiTree p;
	EnQueue(Q, tree);//树根入队
	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() {
	char data;
	BiTree pnew = NULL;
	BiTree tree = NULL;//树根
	ptag_t phead = NULL, ptail = NULL, listpnew = NULL, pcur = NULL;//phead就是队头，ptail就是队列尾
	while (scanf("%c", &data) != EOF)
	{
		if (data =='\n') {
			break;
		}
	
	pnew = (BiTree)calloc(1, sizeof(BiTNode));
	pnew->data = data;
	listpnew = (ptag_t)calloc(1, sizeof(tag_t));
	listpnew->p = pnew;
	if (tree == NULL) {
		tree=pnew;
		phead = listpnew;
		ptail = listpnew;
		pcur = listpnew;
		continue;
	}
	//尾插法建树
	else {
		ptail->pnext = listpnew;
		ptail = listpnew;
	}
	if(pcur->p->lchild == NULL) {
		pcur->p->lchild = pnew;
	}
	else if(pcur->p->rchild == NULL) {
		pcur->p->rchild = pnew;
		pcur = pcur->pnext;
	}
	}
	//abcdefghij
	//中序遍历输出
	Inorder(tree);
	printf("\n");
	//后续遍历输出
	Postorder(tree);
	printf("\n");
	//层次(层序)遍历输出（广度优先遍历）
	LevelOrder(tree);//需要使用辅助队列
	return 0;
}

1.8读取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

description：读取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
input:标准输入读取10个元素 87 7 60 80 59 34 86 99 21 3
output:中序遍历输出有序，每个元素占3个字母位置
3 7 21 34 59 60 80 86 87 99
接着输出2即可（就是元素21的下标），注意2直接在行首输出即可。
sample input：87 7 60 80 59 34 86 99 21 3
sample output： 3 7 21 34 59 60 80 86 87 99
        2

//读取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

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


#define   MaxSize 10
typedef int ElemType;
typedef int KeyType;
typedef struct BSTNode {
	KeyType key;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BiTree;

//比较规则
int compare(const void* _a, const void* _b)
{
	int* a = (int*)_a;    //强制类型转换
	int* b = (int*)_b;
	return *a - *b;   //升序，从小到大
	//return *b-*a;    降序，从大到小
}
//二叉建树
int BST_Insert(BiTree& T, KeyType k) {
	if (T == NULL) {
		//为新节点申请空间
		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) {
	if (T != NULL) {
		Inorder(T->lchild);
		printf("%3d", T->key);
		Inorder(T->rchild);
	}
}
//二分查找
int ER_Search(ElemType data[MaxSize], ElemType x) {
	int mid;
	int low = 0;
	int high = MaxSize - 1;
	while (low < high) {
		mid = (low + high) / 2;
		if (x > data[mid]) {
			low = mid + 1;
		}
		else if (x < data[mid]) {
			high = mid - 1;
		}
		else {
			return mid;
		}
	}
	return -1;
}
int main() {
	KeyType str[MaxSize];//定义原来一开始乱序的数组
	ElemType data[MaxSize];//定义一个存入一个长度为10并且有序的数组中
	//建树
	BiTree T = NULL;
	BiTree  parent = NULL;
	BiTree  search = NULL;
	int element;//标准读取10个元素
	//87  7 60 80 59 34 86 99 21  3
	for (int i = 0; i < 10; i++) {
		scanf("%d", &element);
		str[i] = element;
	}
		/*for (int i = 0; i < 10; i++) {
			printf("%3d", str[i]);
		}*/
		Creat_BST(T, str, 10);//插入树的10个结点
		//中序遍历输出
		Inorder(T);
		printf("\n");//换行
		qsort(str,10,sizeof(ElemType), compare);//排序//分别代表：初地址;元素的个数;每个元素的空间大小;比较规则
		//将排好序的数存入新的数组
		for (int i = 0; i < 10; i++) {
			data[i] = str[i];
		}
		int pos;
		pos = ER_Search(data, 21);//查找21元素
		printf("%d", pos);
	}

1.9输入一个字符串abaabcdac，直接手动打印它的next数组值（也就是自己人工算，直接写死到一个数组里，for循环输出数组即可），每个输出的数值占两个空格（%2d），因此不能给大家输出是啥。

description：读取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
input:abaabcdac
output:不能给，手动打印出来即可
sample input：abaabcdac
sample output：保密，直接手动输出出来就会ac

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
//abaabcdac
int main()
{
	int data[9] = {0,1,1,2,2,3,1,1,2};
	char *p;
	p =(char *)malloc(200);
	fgets(p, 100, stdin);
	for (int i = 0; i < 9; i++) {
		printf("%2d", data[i]);
	}
	return 0;
}