① 数据结构如何通过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语言中数据结构的实现
将B集合的元素插入到A集合中，如果B中的元素和A中的相同，那么就删除A中的，最后A中剩下得元素就是你要的结果！主要用到链表的插入删除！
③ 数据结构的问题，如何用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相加之后的多项式。
按指数从小到大输出，每行一项，用空格把系数和指数分开。
*/
④ 用c语言socket编程服务器和客户端能相互传文件，请问怎样在服务器端设置帐号和密码，在下载时能显示进度条
1、可以在client端登入时write（发送）帐号和密码给server端，当server端接受到内容时判断是否是你预设的帐号密码，是则允许下载，否则关闭其socket。
2、是要客户端看到进度条？ 这样就要要求在下载文件时server端要先发这个文件的大小给client端，client端就可以通过这个大小和接受到的字节数比较后打印进度条（printf("#");）.
文件大小可用int stat(const char *restrict path, struct stat *restrict buf);函数获取。
⑤ 怎么用C语言结合数据结构的知识来实现数据库的功能，代码怎么设计和编写
用数据结构组织起来就是简单的数据库了，无非就是插入删除修改之类的功能
你说的那些数据库语句，可以用简单的字符串匹配来做
如： strcmp 匹配"Create table"这个字符串 对接下来字符进行提取，直到"(" 以后的关键字符也是用类似方法判断","等实现
提取了需要的关键字符之后就可以进行对应的传参，调用相应操作
⑥ 数据结构（使用C语言）
->叫做SmartPoint,是针对指针而使用的一种操作符,在L->size中,L是某一指针,L->size就是调用指针L指向的对象的size属性.
int
ListInsert(SeqList
*L,int
i,DataType
x)中第一个SeqList
*L指的是需要一个指向SeqList的指针,int是需要一个整数,DataType
x是指需要一个DataType类型的量,这个ListInsert方法的参数列表(也就是括号中的内容)指的是在列表L中的i位置插入一个类型为DataType的元素
⑦ C语言 socket编程 TFTP服务器与客户端的实现
TFTP是一个传输文件的简单协议，其于UDP协议而实现
socket是...我只能理解成是网络编程里面包含ip地址端口号的一个数据结构 具体我说不清楚
基础肯定是要先了解udp ,先要掌握用udp接收和发送数据,
然后基于udp的数据发送接收再根据tftp协议的要求来写程序
这个里面有tftp的介绍
http://www.longen.org/S-Z/details-z/TFTPProtocol.htm
⑧ 数据结构（c语言版）里面的那些程序是用什么工具实现的。。
数据结构（c语言版）里面的那些程序可以用VC 6.0来实现。其它C语言的编译器也可以。
ASP.net 要用来做网络编程的，要一些网络知识和一点编程的基础。
ASP的前景不如PHP和JSP,ASP不要花太多的时间去学了。
⑨ 数据结构 用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;
}
}
//楼主只能帮你到这了
⑩ 数据结构，用C语言实现。。。
这个是堆栈。不管是C还是其他的语言里都应该有的，因为这在数据结构里是一种很常见的东西。如果你要用C语言实现的话，实现的手法大概也就只能从数组或者链表来实现了。数据结构书上很多。也很简单。
int a[20];int t=0;int p;
while(N)
{
p=N%8;
a[t]=p;
t++;
N=N/8;
}
for(;t>=0;t--)
{
priintf("%d";a[t]);
}
就是正着输进去，反着数出来，类似于8进制。