数据结构56-60

于 2022-10-08 16:51:54 发布
阅读量314 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Euphoria_stars/article/details/127210411
版权

56

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

struct student{
    int number; /*编号*/
    int score; /*成绩*/  
} ;
int main(){
    int  a[n]={s};
    int i,j,t;
    for(i=1;i<5;i++){
        for(j=0;j<n;j++){
            if（a[j]<a[j+1]){
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
            }
        }
    }
    n--
}
for (j=0;j<5;j++)
    printf("%d",a[j]);
return 0;
}

57

这个有问题 平台就是报错

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int K[100];
int Found = 0;
int index = 0;
int MINVALUE[100]={100};
typedef struct Link {
	int data;
	struct Link* next;
}L, * LL;
typedef struct Tree {
	int data;
	struct Tree* left;
	struct Tree* right;
	struct Tree* parent;
	int sum;
	int num;
	LL Lhead;
}T, * TL;
LL NewLHead() {
	LL LHead = new L;
	LHead->next = NULL;
	return LHead;
}
int ADD(LL Lhead, int data) {
	LL node = new L;
	node->data = data;
	if (Lhead) {
		node->next = Lhead->next;
		Lhead->next = node;
	}
	return 0;
}
TL NewTree(TL Tr,int arr[]) {
	int data=arr[index];
	index++;
	if (!data)
		return NULL;
	Tr = new T;
	Tr->data = data;
	Tr->sum = Tr->data;
	Tr->num = 1;
	Tr->Lhead = NewLHead();
	ADD(Tr->Lhead, Tr->data);
	Tr->left = NewTree(Tr->left,arr);
	if (Tr->left)
		Tr->left->parent = Tr;
	Tr->right = NewTree(Tr->right,arr);
	if (Tr->right)
		Tr->right->parent = Tr;
	return Tr;
}
void AxeOrder(TL Tr) {
	if (Tr) {
		AxeOrder(Tr->right);
		AxeOrder(Tr->left);
		TL parent = Tr->parent;
		while (Tr->sum < K[index]) {
			if (parent) {
				Tr->sum += Tr->parent->data;
				ADD(Tr->Lhead, Tr->parent->data);
				Tr->num++;
			}
			else
				break;
			parent = parent->parent;
		}
		if (Tr->sum == K[index] && MINVALUE[index] > Tr->num)
			MINVALUE[index] = Tr->num;
	}
}
void AnotherAxeOrder(TL Tr) {
	if (Tr) {
		AnotherAxeOrder(Tr->right);
		if (Found)
			return;
		AnotherAxeOrder(Tr->left);
		if (Found)
			return;
		if (Tr->sum == K[index] && MINVALUE[index] == Tr->num)
		{
			while (Tr->Lhead && Tr->Lhead->next) {
				printf("%d ", Tr->Lhead->next->data);
				Tr->Lhead = Tr->Lhead->next;
			}
			printf("\n");
			Found = true;
		}
	}
}
void PreOrder(TL t) {
	if (t) {
		printf("%d ", t->data);
		PreOrder(t->left);
		PreOrder(t->right);
	}
}
int main(void) {
	int num;
	scanf("%d", &num);
	char ch = getchar();
	TL* t = new TL[num];
	for (int i = 0; i < num; i++)
	{
		
		Found = 0;
		index = 0;
		int arr[1500];
		int len = 0;
		char ch;
		int num_ = 0;
		while (true) {
			ch = getchar();
			if (ch == ' ' || ch == '\n') {
				arr[len++] = num_;
				num_ = 0;
			}
			else {
				num_ = num_ * 10 + (ch - '0');
			}
			if (ch == '\n')
				break;
		}
		K[i] = arr[len - 1];
		MINVALUE[i] = 10000;
		t[i] = NewTree(NULL, arr);
	}
	for (int i = 0; i < num; i++) {
		Found = 0;
		index = i;
		AxeOrder(t[i]);
		AnotherAxeOrder(t[i]);
	}
	return 0;
}

 58

这个是C++   C写的答案报错

 

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#define MAX_INT 1000
#define MAX_Double (numeric_limits<double>::max)()
 
using namespace std;
 
//Huffman树结点结构体
typedef struct TreeNode{
	double weight;//因为频率有可能为小数，所以用double
	char Ch;//用于存放该节点字符
	char *code;//用于存放该字符的 Huffman编码
	int parent,lchild,rchild;//存放每个结点的 父节点 以及 子结点
}TreeNode;
 
//Huffman树结构体
typedef struct HFTree{
	TreeNode* data;//用堆实现该Huffman树
	int length;//该树总结点的个数
}HFTree;
 
//初始化哈夫曼树
HFTree* initTree(double* weight,char* ch,int n){
	HFTree* T = (HFTree*)malloc(sizeof(HFTree));
	//根据性质，n个结点生成的Huffman树会有2*n-1个结点
	T->data = (TreeNode*)malloc(sizeof(TreeNode)*(2*n-1));
	T->length = n;
	
	//初始化每个结点
	for(int i = 0; i < n; ++i){
		T->data[i].Ch = ch[i];
		T->data[i].weight = weight[i];
		T->data[i].parent = 0;
		T->data[i].lchild = -1;
		T->data[i].rchild = -1;
		
		//初始化每个结点的code数组
		T->data[i].code = (char*)malloc(sizeof(char)*MAX_INT);
		memset(T->data[i].code,'\0',MAX_INT);	
	}
	return T;
}
 
//选择两个权值最小的结点
int* selectMin(HFTree* T){
	//定义两个哨兵变量，他们的值为double所表示的最大值
	//(numeric_limits<double>::max)();
	double min = MAX_Double;
	double secondMin = MAX_Double;
	//两个最小结点的下标
	int minIndex;
	int secondIndex;
	//先选择第一小的结点
	for(int i=0;i<T->length;++i){
		//只要没有父节点就可以选择
		if(T->data[i].parent == 0){
			if(T->data[i].weight < min){
				min = T->data[i].weight;
				minIndex = i;
			}
		}
	}
	//其次选择第二小的结点
	for(int i =0;i<T->length;++i){
		//没有父节点且不等于第一小的才选择
		if(T->data[i].parent == 0 && i != minIndex){
			if(T->data[i].weight < secondMin){
				secondMin = T->data[i].weight;
				secondIndex = i;
			}
		}
	}
	//因为返回两个值，所以可以使用指针
	int* res = (int*)malloc(sizeof(int)*2);
	res[0] = minIndex;
	res[1] = secondIndex;
	return res;
}
 
//Huffman编码器
void Hfmcode(HFTree* T,int n){
	//分别给n个字符编码
	for(int k=0;k<n;k++){
	//从0号位的叶子节点开始回溯
	    int i = 0,j = 0;
	    int ch = k;
	    //记录单个字符的编码
	    char str[MAX_INT];
	    memset(str,'\0',MAX_INT);
		int parent = T->data[k].parent;
			for(i = n-1;parent != 0;i--){
			//如果该左孩子与 回溯起点index相符
				if(T->data[parent].lchild == ch){
					str[j++] = '0';
					ch = parent;
					//向上回溯
					parent = T->data[ch].parent;
				}else{
					//同上 右孩子.....
					str[j++] = '1';
					ch = parent;
					parent = T->data[ch].parent;
				}
			}
		int f = 0;
		//因为是回溯编码，所以需要反转
		for(int s = j-1;s>=0;s--){
			T->data[k].code[f] = str[s];
			f++;
		}
	}
}
 
//创建Huffman树
void createHFTree(HFTree* T,int nn){
	int* res;
	int min;
	int secondMin;
	int n = T->length * 2 - 1;
	for(int i = T->length; i < n;++i){
		T->data[i].parent = 0;
		res = selectMin(T);
		min = res[0];
		secondMin = res[1];
		//给父节点赋值
		T->data[i].weight = T->data[min].weight + T->data[secondMin].weight;
		T->data[i].lchild = min;
		T->data[i].rchild = secondMin;
		//给儿子们赋值
		T->data[min].parent = i;
		T->data[secondMin].parent = i;
		T->length++;
	}
	
	//为每个字符编码
	Hfmcode(T,nn);
}
 
//递归遍历Huffman树 T->length-1为根结点
void preOrder(HFTree* T,int index){
	if(index != -1){
		if(T->data[index].lchild == -1 || T->data[index].rchild == -1)
			cout << T->data[index].Ch <<":"<<T->data[index].code<<endl;
		preOrder(T,T->data[index].lchild);
		preOrder(T,T->data[index].rchild);
		
	}
}
 
//Huffman译码
char* Decode(char* str,int length,HFTree* T){
	int index = length - 1,ct = 0,j = 0;
	char ch;
	ch = str[0];
	char* res = (char*)malloc(sizeof(char)*MAX_INT);
	while(true){
		//当密文字符为0时向左走
		if(ch == '0'){
			index = T->data[index].lchild;
			//为1时向右走
		}else if(ch == '1'){
			index = T->data[index].rchild;
		}
		//直到遍历到叶子节点
		if(T->data[index].lchild == -1 || T->data[index].rchild == -1){
			//此时的字符值即为这一段密文的密码字符
			res[ct] = T->data[index].Ch;
			ct++;
			//回到根结点
			index = length-1;
		}
		//记录当前遍历密文的位置
		j++;
		ch = str[j];
		//当走完时直接及解码完成 退出循环
		if(j == (int)strlen(str))
			break;
	}
	return res;
}
 
 
int main(){
	//输入n个字符
	int n;
	scanf("%d",&n);
	getchar();
	
	//初始化n个 char和double类型的数组 用于存放 字符和对应的频率
	char* chNums = (char*)malloc(sizeof(char)*n);
	double* nuNums = (double*)malloc(sizeof(double)*n);
	
	//输入 字符以及相应的频率
	for(int i=0;i<n;++i){
		scanf("%c%lf",&chNums[i],&nuNums[i]);
		getchar();
	}
	
	//输入 需要译码的字符串
	char str[MAX_INT];
	scanf("%s",str);
	getchar();
	//创建一棵Huffman树
	HFTree* T = initTree(nuNums,chNums,n);
	createHFTree(T,n);
	//遍历每个字符及其编码
	preOrder(T,T->length-1);
	//遍历解码后的密文
	cout<<"original:"<<Decode(str,T->length,T)<<endl;
	
	return 0;
}

59

 

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int arr1[18];
int arr2[18];
int main() {
    int n, num, i, temp;
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        scanf("%d", &num);
        arr2[i] = num;
        temp = num % 17;
        while (arr1[temp] != 0) {
            temp = (temp + 5) % 18;
        }
        arr1[temp] = num;
    }
    for (i = 0; i < n; i++) {
        for (int j = 0; j < 18; j++) {
            if (arr1[j] != 0 && arr1[j] == arr2[i]) {
                printf("%d pos: %d\n", arr1[j], j);
            }
        }
    }
    system("pause");
    return 0;
}

60

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

int arr[18], brr[18], pos[18], arr1[18], arr2[18], d, n, temp, m, k, count;
int main() {
	for (int i = 0; i < 18; i++)arr[i] = brr[i] = pos[i] = -1;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
		temp = arr[i] % 17;
		d = 1;
		while (brr[temp] != -1) {
			temp = (arr[i] % 17 + d * d) % 18;
			arr2[i] = d;
			d++;
		}
		brr[temp] = arr[i];
		pos[i] = temp;
	}
	scanf("%d", &m);
	for (int i = 0; i < m; i++)
		scanf("%d", &arr1[i]);
	for (int i = 0; i < n; i++) {
		printf("%d ", pos[i]);
	}
	printf("\n");
	for (int i = 0; i < m; i++) {
		d = count = 0;
		for (int j = arr1[i] % 17; j < 18; j = (arr1[i] % 17 + d * d) % 18) {
			d++;
			count++;
			if (arr1[i] == brr[j]) {
				for (k = 0; k < n; k++) {
					if (brr[j] == arr[k]) {
                        if(i==m-1)
                            printf("%d pos:%d,try %d", arr1[i], pos[k], arr2[k] + 1);
                        else
						    printf("%d pos:%d,try %d\n", arr1[i], pos[k], arr2[k] + 1);
						break;
					}
				}
				break;
			}
			else if (brr[j] == -1 || count == 18) {
                if(i==m-1)
				    printf("%d not found,try %d", arr1[i], count);
                else
                    printf("%d not found,try %d\n", arr1[i], count);
				break;
			}
			if (j == 18)j = 0;
		}
	}
	return 0;
}

 

Euphoria_stars
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值