数据结构c语言
❶ 数据结构和c语言有什么区别
数据结构是数据及数据之间的关系，C语言只是一门编程语言，可以用C语言来写程序，实现数据按照某种特定的关系来组织和管理数据（也就是实现数据结构），所以数据结构的课程会有不同的语言版本，其实就是用不同的语言来实现数据结构了。呵呵，不知道你明白没有呢~~
❷ 数据结构（C语言）
呵呵，碰巧到你网络空间看了下，看到了你想知道的这个问题，蒽蒽，下午就给你答案哈~~~
恩，可以了：
#include <stdio.h>
#include <stdlib.h>
typedef struct term
{
double coef;//系数
int expn; //指数
struct term *next;
}term,*polynomial;
//注:下面的head_p是头指针，而非头结点。其存放的是多项式的第一项
int depart_polyn(polynomial &head_p,polynomial &Odd_items,polynomial &Even_items)//奇数项，偶数项
{
int i=1,j=1;
polynomial odd,even,p;
Odd_items=Even_items=NULL;
p=head_p;
while(1)
{
if(p->expn%2)
{
if(i)
{
i=0;//使得奇数项头指针只赋值一次
Odd_items=p;
odd=Odd_items;
}
else
{
odd->next=p;
odd=odd->next;
}
p=p->next;
odd->next=Odd_items;
}
else
{
if(j)
{
j=0;//作用同上
Even_items=p;
even=Even_items;
}
else
{
even->next=p;
even=even->next;
}
p=p->next;
even->next=Even_items;
}
if(p==head_p)
break;
}
return 1;
}
void print_polyn(polynomial head)//这函数只是针对main函数内给出的多项式例子编的，处理的系数均为正数。
{
polynomial p=head;
if( !head)
{
puts("该表为空:");
return;
}
while(1)
{
if(p->next!=head)
printf("%gm^%d + ",p->coef,p->expn);
else
printf("%gm^%d\n",p->coef,p->expn);
p=p->next;
if(p==head)
break;
}
putchar('\n');
}
int main()
{
int i;
polynomial head_p,head,Odd_items,Even_items,newbase;
head_p=(polynomial)malloc(sizeof(term));
head_p->coef=2.71;
head_p->expn=0;
head=head_p;
//随意创建了一个稀疏多项式，以验证
for(i=1;i<11;i++)
{
newbase=(polynomial)malloc(sizeof(term));
newbase->coef=2.71*i;
newbase->expn=i*13;
head->next=newbase;
head=head->next;
}
head->next=head_p;//构成循环链表
puts("原稀疏多项式:");
print_polyn(head_p);
if(depart_polyn(head_p,Odd_items,Even_items) )
{
puts("分解后的奇数项稀疏多项式:");
print_polyn(Odd_items);
puts("分解后的偶数项稀疏多项式:");
print_polyn(Even_items);
}
return 0;
}
哪里不懂可追问：
❸ 数据结构c语言版
#include "stdio.h"
typedef char datatype;
typedef struct node{
datatype data;
struct node *next;
} stack;
stack * creat(void)
{
char ch;
stack * head;
stack *p;
head=NULL;/*初始化为空*/
ch=getchar( );
while (ch!='\n'){
p=(stack*)malloc(sizeof(stack));/*分配空间*/
p->data=ch;/*数据域赋值*/
p->next=head;/*指定后继指针*/
head=p;/*head指针指定到新插入的结点上*/
ch=getchar( );
}
return (head);
}
void MakeNull(stack *s)/*使栈s为空*/
{
stack *p=s;
while(s!=NULL){
s=s->next;
free(p);/*释放空间*/
p=s;
}
}
datatype Top(stack *s)
{
if(Empty(s))/*s为空栈，直接跳出，提示出错信息*/
printf("The stack is empty.");
else
return s->data;
}
void Pop(stack *s)
{
stack *p;
if(Empty(s)) /*s为空栈，直接跳出，提示出错信息*/
printf("The stack is empty.");
else{
p=s;
s=s->next;
free(p);/*释放栈顶空间*/
}
}
void Push(stack *s,datatype x)
{
stack *p;
p=(stack*)malloc(sizeof(stack));
p->data=x;
p->next=s;
s=p;
}
int Empty(stack *s)
{
return(s==NULL);
}
void main()
{
stack* m_stack=creat();
char m_top;
if(!Empty(m_stack))
{
m_top=Top(m_stack);
Pop(m_stack);
}
else
Push(m_stack,'a');
MakeNull(m_stack);
}
❹ 数据结构C语言版
//二叉树的先序遍历序列:ABCEDFHGIJ
//二叉树的中序遍历序列:ECBHFDJIGA
//二叉树的后序遍历序列:ECHFJIGDBA
#include"stdio.h"
#include"stdlib.h"
structtree
{
chardata;
structtree*left;
structtree*right;
};
typedefstructtreetreenode;
typedeftreenode*btree;
btreecreatebtree(char*data,intpos,intmaxPos)//递归创建法
{
btreenewnode;
if(data[pos]==0||pos>maxPos)
{
returnNULL;
}
else
{
newnode=(btree)malloc(sizeof(treenode));
newnode->data=data[pos];
newnode->left=createbtree(data,2*pos,maxPos);
newnode->right=createbtree(data,2*pos+1,maxPos);
returnnewnode;
}
}
voidinorder(btreeptr)
{
if(ptr!=NULL)
{
inorder(ptr->left);
printf("%C",ptr->data);
inorder(ptr->right);
}
}
voidpreorder(btreeptr)
{
if(ptr!=NULL)
{
printf("%C",ptr->data);
preorder(ptr->left);
preorder(ptr->right);
}
}
voidpostorder(btreeptr)
{
if(ptr!=NULL)
{
postorder(ptr->left);
postorder(ptr->right);
printf("%C",ptr->data);
}
}
intmain()
{
btreeroot=NULL;
inti;
chardata[64]={0,'A','B',0,'C','D',0,0,
'E',0,'F','G',0,0,0,0,
0,0,0,0,'H',0,'I',0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,'J',0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
root=createbtree(data,1,63);
printf("二叉树的顺序存储内容: ");
for(i=1;i<64;i++)
{
if(data[i]==0)
{
printf("^");
}
else
{
printf("%C",data[i]);
}
if(i%8==7)printf(" ");
}
printf(" 二叉树的先序遍历序列:");
preorder(root);
printf(" 二叉树的中序遍历序列:");
inorder(root);
printf(" 二叉树的后序遍历序列:");
postorder(root);
printf(" ");
return0;
}
❺ 数据结构C语言编程
#include"stdio.h"
#include<stdlib.h>
#include"time.h"
intmain(intargv,char*argc[]){
doublex[10]={0.0,};
inti;
srand((unsigned)time(NULL));
while(rand()%10000!=0){//
for(i=0;i<9;x[i++]=x[i+1]);
x[9]=rand()/32767.0*100000;//模拟采集数据
}
for(i=0;i<10;printf("%10.3f ",x[i++]));//输出最后10个数
return0;
}
运行样例：
❻ 数据结构（c语言）
1．数据结构是一门研究非数值计算的程序设计问题中计算机的 A 以及它们之间的 _ B 和运算等的学科。
① A. 数据元素 B. 计算方法 C. 逻辑存储 D. 数据映象
② A. 结构 B. 关系 C. 运算 D. 算法
2．数据结构被形式地定义为(K,R),其中K是 B 的有限集，R是K上的 A 有限集。
① A. 算法 B. 数据元素 C. 数据操作 D. 逻辑结构
② A. 操作 B. 映象 C. 存储 D. 关系
3．在数据结构中，从逻辑上可以把数据结构分成____C____。
A. 动态结构和静态结构 B. 紧凑结构和非紧凑结构
C. 线性结构和非线性结构 D. 内部结构和外部结构
4．算法分析的目的是 C ，算法分析的两个主要方面是 A 。
① A. 找出数据结构的合理性 B. 研究算法中的输入和输出的关系
C. 分析算法的效率以求改进 D. 分析算法的易懂性和文档性
② A. 空间复杂度和时间复杂度 B. 正确性和简单性
C. 可读性和文档性 D. 数据复杂性和程序复杂性
5．计算机算法指的是 C ，它必须具备输入、输出和 C 等5个特性。
① A. 计算方法 B. 排序方法
C. 解决问题的有限运算序列 D. 调度方法
② A. 可执行性、可移植性和可扩充性
B. 可行性、确定性和有穷性
C. 确定性、有穷性和稳定性
D. 易读性、稳定性和安全性
三、填空题
1．下面程序段的时间复杂度是___O(n*m)____。
For (i=0;i<n;i++)
For (j=0;j<m;j++)
A[i][j]=0;
2．下面程序段的时间复杂度是___O(n^(1/2))____。
i=s=0
While(s<n)
{
i++; /* i=i+1 */
s+=i; /* s=s+i */
}
3．下面程序段的时间复杂度是___O(n^2)____。
s=0;
for (i=0;i<n;i++)
for (j=0;j<n;j++)
s+=B[i][j];
sum=s;
4．下面程序段的时间复杂度是__O（log3 N）（注：对N取3的对数）_____。
i=1;
While (i<=n)
i=i*3;
❼ 数据结构c语言
把scanf("%d ",&q->name);改成scanf("%s",q->name);。
把scanf("%d ",&q->score);改成scanf("%d",&q->score);。
函数studlist *CreateStudent()应该有一个返回值。若不需要返回值，请改成voidCreateStudent()。
if(p->Next->score<q->score)中p->Next->score并未赋值，怎么能与q->score比较？这里就会跳出运行。
char name[3];中3太小只能放下一个汉字或两个字符。
适当的地方应该有释放所申请的内存的语句。
❽ 数据结构C语言
++;
printf("第%d个数据：",i);
printf("%d\n",p->data);
p=head->next; //改成p=p->next
不是给你回答过一次吗？
http://..com/question/13189159.html
这个是你问的吧，还把问题关了
上次我明明调式过了能回答的
❾ 数据结构（c语言版）
测试数据1:
创建二叉树,输入先序扩展序列:ABD##E##C#F##
先序遍历输出节点:ABDECF
中序遍历输出节点:DBEACF
后序遍历输出节点:DEBFCA
二叉树示意图:
A
/
BC
//
DE#F
///
######
测试数据2:
创建二叉树,输入先序扩展序列:ABC##DE#G##F###
先序遍历输出节点:ABCDEGF
中序遍历输出节点:CBEGDFA
后序遍历输出节点:CGEFDBA
二叉树示意图:
A
/
B#
/
CD
//
##EF
//
#G##
/
##
#include<stdio.h>
#include<stdlib.h>
typedefstructNode//二叉树的结构体
{
chardata;//字符
structNode*lchild;//左分支
structNode*rchild;//右分支
}Bitree;
//创建二叉树:用"先序遍历"(递归法)
voidCreateBiTree(Bitree**bt)
{
charch;
scanf("%c",&ch);//输入字符
if(ch=='#')//'#'是空节点NULL
*bt=NULL;
else
{
*bt=(Bitree*)malloc(sizeof(Bitree));
(*bt)->data=ch;
CreateBiTree(&((*bt)->lchild));
CreateBiTree(&((*bt)->rchild));
}
}
//用"先序遍历"输出节点(递归法)
voidpreOrder(Bitree*ptr)
{
if(ptr!=NULL)
{
printf("%c",ptr->data);
preOrder(ptr->lchild);
preOrder(ptr->rchild);
}
}
//用"中序遍历"输出节点(递归法)
voidinOrder(Bitree*ptr)
{
if(ptr!=NULL)
{
inOrder(ptr->lchild);
printf("%c",ptr->data);
inOrder(ptr->rchild);
}
}
//用"后序遍历"输出节点(递归法)
voidpostOrder(Bitree*ptr)
{
if(ptr!=NULL)
{
postOrder(ptr->lchild);
postOrder(ptr->rchild);
printf("%c",ptr->data);
}
}
intmain()
{
Bitree*root;
printf("创建二叉树,输入先序扩展序列:");
CreateBiTree(&root);
printf("先序遍历输出节点:");
preOrder(root);
printf(" 中序遍历输出节点:");
inOrder(root);
printf(" 后序遍历输出节点:");
postOrder(root);
printf(" ");
return0;
}