A. 数据结构二叉树的程序，用c语言怎么实现
您好，想哪链手要实现一个二叉树，需要用到结构体来存储每个节点的信息，并使用指针来存储每个节点的左右子节点的地址。具体的实现方法唤物可以参考下面的代码示例：
#include <stdio.h>
#include <stdlib.h>
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
};
struct TreeNode* createNode(int val) {
struct TreeNode* node = (struct TreeNode*) malloc(sizeof(struct TreeNode));
node->val = val;
node->left = NULL;
node->right = NULL;
return node;
}
void insertNode(struct TreeNode* root, int val) {
if (root == NULL) {
return;
}
if (val < root->李嫌val) {
if (root->left == NULL) {
root->left = createNode(val);
} else {
insertNode(root->left, val);
}
} else {
if (root->right == NULL) {
root->right = createNode(val);
} else {
insertNode(root->right, val);
}
}
}
void printTree(struct TreeNode* root) {
if (root == NULL) {
return;
}
printf("%d ", root->val);
printTree(root->left);
printTree(root->right);
}
int main() {
struct TreeNode* root = createNode(5);
insertNode(root, 3);
insertNode(root, 2);
insertNode(root, 4);
insertNode(root, 7);
insertNode(root, 6);
insertNode(root, 8);
printTree(root);
return 0;
}
在这段代码中，我们定义了一个结构体 TreeNode 来表示二叉树的每个节点，结构体中包含了一个节点的数值 val，以及指向左子节点和右子节点的指针 left 和 right。
B. 数据结构如何通过C语言来实现，请举例说明，尽可能详细
数据的结构无非就是表：线性表、链表，栈，队列，串，数组，树、二叉树，图，这几种。
常用的使用指针，或数组建立数据结构，然后对其进行插入、删除、查找、排序等操作。
以下是C语言实现的循环队列：
#include<stdio.h>
#include<stdlib.h>
#define MAX_QSIZE 5
struct SqQueue
{ QElemType *base; // 初始化的动态分配存储空间
int front; // 头指针，若队列不空，指向队列头元素
int rear; // 尾指针，若队列不空，指向队列尾元素的下一个位置
};
// bo3-4.cpp 循环队列(存储结构由c3-3.h定义)的基本操作(9个)
void InitQueue(SqQueue &Q)
{ // 构造一个空队列Q。在教科书第64页
Q.base=(QElemType*)malloc(MAX_QSIZE*sizeof(QElemType));
if(!Q.base) // 存储分配失败
exit(OVERFLOW);
Q.front=Q.rear=0;
}
void DestroyQueue(SqQueue &Q)
{ // 销毁队列Q，Q不再存在
if(Q.base) // 队列Q存在
free(Q.base); // 释放Q.base所指的存储空间
Q.base=NULL; // Q.base不指向任何存储单元
Q.front=Q.rear=0;
}
void ClearQueue(SqQueue &Q)
{ // 将队列Q清为空队列
Q.front=Q.rear=0;
}
int QueueEmpty(SqQueue Q)
{ // 若队列Q为空队列，则返回TRUE；否则返回FALSE
if(Q.front==Q.rear) // 队列空的标志
return TRUE;
else
return FALSE;
}
int GetHead(SqQueue Q,QElemType &e)
{ // 若队列Q不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
if(Q.front==Q.rear) // 队列空
return ERROR;
e=Q.base[Q.front]; // 将队头元素的值赋给e
return OK;
}
int EnQueue(SqQueue &Q,QElemType e)
{ // 插入元素e为队列Q的新的队尾元素。在教科书第65页
if((Q.rear+1)%MAX_QSIZE==Q.front) // 队列满
return ERROR;
Q.base[Q.rear]=e; // 将e插在队尾
Q.rear=(Q.rear+1)%MAX_QSIZE; // 队尾指针+1后对MAX_QSIZE取余
return OK;
}
int QueueLength(SqQueue Q)
{ // 返回队列Q的元素个数，即队列的长度。在教科书第64页
return(Q.rear-Q.front+MAX_QSIZE)%MAX_QSIZE;
}
int DeQueue(SqQueue &Q,QElemType &e) // 在教科书第65页
{ // 若队列Q不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
if(Q.front==Q.rear) // 队列空
return ERROR;
e=Q.base[Q.front]; // 将队头元素的值赋给e
Q.front=(Q.front+1)%MAX_QSIZE; // 移动队头指针
return OK;
}
void QueueTraverse(SqQueue Q,void(*visit)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数visit()
int i=Q.front; // i最初指向队头元素
while(i!=Q.rear) // i指向队列Q中的元素
{ visit(Q.base[i]); // 对i所指元素调用函数visit()
i=(i+1)%MAX_QSIZE; // i指向下一个元素
}
printf("\n");
}
void main()
{
int j;
int i=0,m;
int d;
SqQueue Q;
InitQueue(Q); // 初始化队列Q，失败则退出
printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
printf("请输入整型队列元素(不超过%d个)，-1为提前结束符：",MAX_QSIZE-1);
do
{ scanf("%d",&d); // 由键盘输入整型队列元素
if(d==-1) // 输入的是提前结束符
break; // 退出输入数据循环
i++; // 计数器+1
EnQueue(Q,d); // 入队输入的元素
}while(i<MAX_QSIZE-1); // 队列元素的个数不超过允许的范围
printf("队列长度为%d，",QueueLength(Q));
printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
printf("连续%d次由队头删除元素，队尾插入元素：\n",MAX_QSIZE);
for(m=1;m<=MAX_QSIZE;m++)
{ DeQueue(Q,d); // 删除队头元素，其值赋给d
printf("删除的元素是%d，请输入待插入的元素：",d);
scanf("%d",&d); // 输入要入队的元素给d
EnQueue(Q,d); // 将d入队
}
m=QueueLength(Q); // m为队列Q的长度
printf("现在队列中的元素为");
QueueTraverse(Q,print); // 从队头到队尾依次对队列Q的每个元素调用函数print()
printf("共向队尾插入了%d个元素。",i+MAX_QSIZE);
if(m-2>0)
printf("现在由队头删除%d个元素，",m-2);
while(QueueLength(Q)>2)
{ DeQueue(Q,d); // 删除队头元素，其值赋给d
printf("删除的元素值为%d，",d);
}
j=GetHead(Q,d); // 将队头元素赋给d
if(j) // 队列Q不空
printf("现在队头元素为%d\n",d);
ClearQueue(Q); // 清空队列Q
printf("清空队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
DestroyQueue(Q); // 销毁队列Q
}
C. 不会啊，数据结构的C语言实现怎么弄
# include<stdio.h>
# include<stdlib.h>
typedef int datatype;
typedef struct node{
datatype data;
struct node *next;
}LinkList;
LinkList *head,*p,*s;
int i,j,x,count,length,choices;
LinkList (*CreatList)()//创建单链表
{
int t;
LinkList *r;
head=(LinkList*)malloc(sizeof(LinkList));
r=head;
scanf("%d",&t);
while(t!=-1){
s=(LinkList*)malloc(sizeof(LinkList));
s->data=t;
r->next=s;
r=s;
scanf("%d",&t);
}
r->next=NULL;
return head;
}
LinkList DispList(LinkList *head)//输出单链表
{
for(p=head->next;p;p=p->next)
printf("%5d",p->data);
printf("\n");
}
int ListLength(LinkList *head)//计算单链表长度并输出
{
length=0;
p=head->next;
while(p!=NULL){
p=p->next;
length++;
}
printf("%5d\n",length);
}
LinkList GetElem(LinkList *head,int i)//查找某一元素并输出
{
D. C语言编写 数据结构
#include<stdio.h>
#include<stdlib.h>
typedefstructintnumber
{
intn;
structintnumber*next;
}INTNUM;
INTNUM*creat(intnum)/*建立链表*/
{
INTNUM*p1,*p2,*head;
inti;
p1=(INTNUM*)malloc(sizeof(INTNUM));
head=p1;
p2=p1;
for(i=0;i<num-1;i++)
{
p1=(INTNUM*)malloc(sizeof(INTNUM));
p2->next=p1;
p2=p1;
}
p1->next=NULL;
returnhead;
}
voidinput(INTNUM*head)/*输入链表数据*/
{
INTNUM*p;
p=head;
while(p->next!=NULL)
{
scanf("%d",&(p->n));
p=p->next;
}
scanf("%d",&(p->n));
}
voidoutput(INTNUM*head)/*输出链表数据*/
{
INTNUM*p;
p=head;
while(p->next!=NULL)
{
printf("%d/t",p->n);
p=p->next;
}
printf("%d/n",p->n);
}
voidmain(void)
{
INTNUM*pa,*pb,*pc,*heada,*headb,*headc;/*pc是指向新链表的指针*/
intcounta,countb;/*counta,countb是建立链表的结点数*/
printf("请输入建立A链表的结点数:");
scanf("%d",&counta);
pa=creat(counta);
heada=pa;
printf("请按递增输入A链表结点上的数据:");
input(heada);
printf("打印A链表结点上的数据:/n");
output(heada);
printf("请输入建立B链表的结点数:");
scanf("%d"胡兆桐,&countb);
pb=creat(countb);
headb=pb;
printf("请按递增输入B链表结点上的数据:");
input(headb);
printf("打印B链表结点上的数据:/n");
output(headb);
printf("将链表A和链表B仍然按照递增关系合并成一个新的链表C:");
headc=heada;
pc=pa;
pa=pa->next;
while(pa&&pb)
{
if(pa->n<=pb->n)
{
pc->next=pa;
pc=pc->next;
pa=pa->next;
}
else
{
pc->next=pb;
pc=pc->next;
pb=pb->next;
}
}
pc->next=pa?pa:pb;
printf("打印合并后链表结点上的数据:/n");
output(headc);
}
结果如下:
请输入建立A链表的结点数:3
请按递增输入A链表结点上的数据:12030
打印A链表结点上的数据:
12030
请输入建立B链表的结点数:5
请按递增输入B链表结点上的数据:218222632
打印B链表结点上的数据:
21822裤坦2632
将链表A和链表B仍然按照递增关系合并成一个新的链表C:打印合并后链表结点上的数据:
121820猜尺22263032
E. 数据结构 用c语言实现
#include<stdio.h>
#include<梁猛string.h>
#include<stdlib.h>
typedef struct list
{
char ch;
struct list *next;
}List;
List *create_list(List *data);
List *insert_list(List *head, List *data);
void print_list(List *head);
void get_list_length(List *head);
void insert_third_withf(List *head);
void delete_first_value(List *head);
void delete_within_A_Z(List *head);
int main()
{
List *head = NULL;
List tmp;
memset(&tmp, 0x00, sizeof(tmp));
head = create_list(&tmp);
tmp.ch = 'a';
insert_list(head, &tmp);
tmp.ch = 'b';
insert_list(head, &tmp);
tmp.ch = 'A';
insert_list(head, &tmp);
tmp.ch = 'c'橡慎;
insert_list(head, &tmp);
tmp.ch = 'D';
insert_list(head, &tmp);
tmp.ch = 'd';
insert_list(head, &tmp);
tmp.ch = 'F';
insert_list(head, &tmp);
tmp.ch = 'e';
insert_list(head, &tmp);
tmp.ch = 'h';
insert_list(head, &tmp);
printf("显示\n");
print_list(head);
get_list_length(head);
printf("第三个位置插入f\n");
insert_third_withf(head);
print_list(head);
printf("删除第一梁渣敬个元素\n");
delete_first_value(head);
print_list(head);
printf("删除A-Z\n");
delete_within_A_Z(head);
print_list(head);
return 0;
}
List *create_list(List *data)
{
List *newnode = NULL;
newnode = (List*)malloc(sizeof(List));
if(NULL == newnode)
{
printf("malloc failed !\n");
return NULL;
}
*newnode = *data;
newnode->next = NULL;
return newnode;
}
List *insert_list(List *head, List *data)
{
List *newnode = NULL;
if(NULL == head)
{
printf("list null !\n");
return NULL;
}
newnode = create_list(data);
while(head->next != NULL)
{
head = head->next;
}
head->next = newnode;
newnode->next = NULL;
return newnode;
}
void print_list(List *head)
{
List *tmp = NULL;
if(NULL == head)
{
printf("print head null !\n");
return;
}
tmp = head;
tmp = tmp->next;
while(tmp != NULL)
{
printf("ch = %c\n", tmp->ch);
tmp = tmp->next;
}
}
void get_list_length(List *head)
{
List *tmp = NULL;
int length = 0;
if(NULL == head)
{
printf("get_len_list head null !\n");
return ;
}
tmp = head;
while(tmp != NULL)
{
length = length + 1;
tmp = tmp->next;
}
printf("the list length(包括头结点) = %d\n", length);
}
void insert_third_withf(List *head)
{
List *tmp = NULL;
List *value = NULL;
List val;
int i = 1;
if(NULL == head || NULL == head->next)
{
printf("insert_third_...head null !\n");
return;
}
memset(&val, 0x00, sizeof(val));
head = head->next;
tmp = head;
while(tmp != NULL)
{
i = i + 1;
if(3 == i)
{
val.ch = 'f';
value = create_list(&val);
value->next = tmp->next;
tmp->next = value;
break;
}
tmp = tmp->next;
}
if(i < 3)
{
printf("the list is too short !\n");
}
}
void delete_first_value(List *head)
{
List *tmp = NULL;
if(NULL == head || NULL == head->next || NULL == head->next->next)
{
printf("delete_fir_val head null !\n");
return;
}
tmp = head->next;
head->next = head->next->next;
free(tmp);
}
void delete_within_A_Z(List *head)
{
List *tmp = NULL;
if(NULL == head || head->next == NULL)
{
printf("head null[dele_A_Z] !\n");
return;
}
tmp = head;
tmp->next = head->next;
while(tmp->next != NULL)
{
if(tmp->next->ch >64 && tmp->next->ch < 91)
{
if(NULL != tmp->next->next)
{
free(tmp->next);
tmp->next = tmp->next->next;
}
else
{
tmp->next = NULL;
break;
}
}
tmp = tmp->next;
}
}
//楼主只能帮你到这了
F. 如何用C语言定义一个数学模型（数据结构）
1、c语言（数据结构）中，在函数定义的头部分&怎么使用？
如果使团携用的是纯C语言，在函数定义的头部，不使用&来定义形参，当需将对形参的改变带回来时用指针即*。大多数据结构教材沿用严蔚敏版教材的习惯，用类C语言，描述数据结构，借助C++中的引用即&来定义形参，这时起到作用类似于兄陆指针，但函数的写法更简洁。
2、你只要记住一点，如果需要将参数改变带回来就要用引用或指针来实现。
3＊和&写的顺序是不同的，
int * &c = a;//这里c是一个引用，它是指针a的引用
int & *d;//这里d是一个指针，它指向引用，但引用不是实体，所以羡或顷这是错误的
G. 数据结构的问题，如何用c语言实现
#include <stdio.h>
#include <stdlib.h>
struct node
{
int coef,exp;
struct node *next;
} *La,*Lb,*Lc;
void add()
{
node *p,*q;
int i;
p=Lc=(node *)malloc(sizeof(node));
La=La->next;Lb=Lb->next;
while(La&&Lb)
{
if(La->exp==Lb->exp)
{
if(La->coef+Lb->coef!=0)
{
q=(node *)malloc(sizeof(node));
p->next=q;p=q;
p->coef=La->coef+Lb->coef;
p->exp=La->exp;
}
La=La->next;Lb=Lb->next;
}
else if(La->exp<Lb->exp)
{
q=(node *)malloc(sizeof(node));
p->next=q;p=q;
p->coef=La->coef;
p->exp=La->exp;
La=La->next;
}
else
{
q=(node *)malloc(sizeof(node));
p->next=q;p=q;
p->coef=Lb->coef;
p->exp=Lb->exp;
Lb=Lb->next;
}
}
while(La)
{
q=(node *)malloc(sizeof(node));
p->next=q;p=q;
p->coef=La->coef;
p->exp=La->exp;
La=La->next;
}
while(Lb)
{
q=(node *)malloc(sizeof(node));
p->next=q;p=q;
p->coef=Lb->coef;
p->exp=Lb->exp;
Lb=Lb->next;
}
p->next=NULL;
}
int main ()
{
node *p,*q,*pa;
int i,j,n,m,e,c;
scanf("%d",&n);
p=La=(node *)malloc(sizeof(node));
for(i=1;i<=n;i++)
{
q=(node *)malloc(sizeof(node));
scanf("%d%d",&c,&e);
q->coef=c;
q->exp=e;
p->next=q;
p=q;
}
p->next=NULL;
scanf("%d",&m);
p=Lb=(node *)malloc(sizeof(node));
for(i=1;i<=m;i++)
{
q=(node *)malloc(sizeof(node));
scanf("%d%d",&c,&e);
q->coef=c;
q->exp=e;
p->next=q;
p=q;
}
p->next=NULL;
add();
pa=Lc->next;
while(pa)
{
printf("%d %d\n",pa->coef,pa->exp);
pa=pa->next;
}
}
/*
以前自己实现的代码，功能是两个一元多项式相加。
输入格式：
输入数据有多组，对于每组测试数据，第一行一个整数n，表示第一个多项式La的项数；接下来n行，每行表示多项式的一项，包含两个元素，表示系数和指数；接下来一个整数m，表示第二个多项式Lb的项数；接下来m行，每行表示多项式的一项，包含两个元素，表示系数和指数；
输出格式：
La与Lb相加之后的多项式。
按指数从小到大输出，每行一项，用空格把系数和指数分开。
*/
H. C语言实现常用数据结构（一）
实现了链表，栈、哈希表等
哈希表由数组加链表实现。通过计算key的哈希值，将哈希值转旁岩成int类型并与数组长度进行与运算得到数组下标，数组每个元素都是一个链表，默认为NULL。
通过InitHashTable函数得到初始化的哈希表。已实现功能有：添加键值、删除键值、根据键获取值，清理所有键值对差棚、回收哈希表，可以根据例子遍历键值。
Key可以扩展为任何类型，运庆御但需要实现相应类型HashCode的算法，此处只支持字符串类型。
C语言实现常用数据结构二
项目地址
md5.h
md5.c
m_hashtable.h
m_hashtable.c
测试使用
I. 用c语言怎么实现数据结构算法
c语言主要通过自己定义函数来实现数据结构，比如实现堆栈，实现了先输入后输出，用函数来实现各个接口；
但是C++也可以通过这个办法，来实现数据结构，
还有很简单，就是STL 框架，这个是系统自动定义的函数。用起来容易
J. c语言如何写数据结构
首先你得会C语言的搭亮碰基本语法，至少要学会指针 自定义知谈类型等等
然后 根据数据结构算法需求
一般数据结构书上 都会有伪代码一类的
根据键喊操作流程 用对应C语言代码实现
然后 编译 调试 运行。