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語言代碼實現
然後 編譯 調試 運行。