当前位置：首页 » 编程语言 » 数据结构的c语言实现

数据结构的c语言实现

发布时间: 2021-03-04 10:40:25

1. 数据结构，用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进制。

2. 数据结构题目，用c语言实现。


/*------数据类型预定义------*/
typedefintStatus;//函数结果状态类型

/*------函数结果状态代码------*/
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineOVERFLOW-2

/*------队列数据类型定义------*/
typedefintQElemType;//队列中元素的数据类型

/*------数据类型预定义------*/
typedefintStatus;//函数结果状态类型

/*------队列动态存储分配初始常量预定义------*/
#defineQUEUE_INIT_SIZE100//队列存储空间的初始分配量
#defineQUEUEINCREMENT10//队列存储空间的分配增量
#defineMAXQUEUESIZE100//循环队列最大长度

/*------全局变量定义------*/
intFLAG;//出、入队列操作标志

/*------队列存储结构类型定义------*/
typedefstruct
{
	QElemType*base;//队列初始化动态分配存储空间
	intfront;//对头指针向量，若队列不空，指向队列头元素
	intrear;//队尾指针向量，若队列不空，指向队列尾元素的下一个位置
}SqQueue;//顺序队列结构类型

StatusInitQueue(SqQueue&Q)
{//构造一个空队列Q
	Q.base=(QElemType*)malloc(QUEUE_INIT_SIZE*sizeof(QElemType));
	if(!Q.base)
		return(OVERFLOW);
	Q.front=Q.rear=0;
	FLAG=0;
	returnOK;
}//InitQueue

StatusStatusQueue(SqQueue&Q)
{//返回队列当前状态
if(Q.front==Q.rear&&FLAG==0)//队列为空
returnFLASH;
if(Q.front==Q.rear&&FLAG==1)//队列为满
returnTURE;
}//StatusQueue

StatusEnQueue(SqQueue&Q,QElemTypee)
{//元素e入队列
	if(StatusQueue(Q))//队列为满
		returnERROR;
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%MAXQUEUESIZE;
	FLAG=1;
returnOK;
}//EnQueue

StatusDeQueue(SqQueue&Q,QElemType&e)
{//元素e出队列
	if(!StatusQueue(Q))
		returnERROR;
	e=Q.base[Q.front++];
	FLAG=0;
	returnOK;
}//DeQueue

3. 数据结构的问题，如何用c语言实现

以前写的多项式运算

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

typedefstruct_PolyNode{
	intindex;
	intcofficient;
}NodeType;

typedefstruct_polynomial{
	NodeTypedata;
struct_polynomial*next;
}Polynomial;

voidappend(Polynomial*head,NodeTypedata){
	Polynomial*p=(Polynomial*)malloc(sizeof(Polynomial));
	p->data=data;
	p->next=head->next;
	head->next=p;
}

voidinput(Polynomial*head){
	NodeTypedata;
	do{
		scanf("%d%d",&data.cofficient,&data.index);
		append(head,data);
	}while(data.cofficient!=0&&data.index!=-1);
}

/**
*合并同类项并去除系数为的项
*/
voidmerge(Polynomial*head){
	Polynomial*p;
	for(p=head->next;p->next;p=p->next)
		if(p->data.index==p->next->data.index){
			p->data.cofficient+=p->next->data.cofficient;
			p->next->data.cofficient=0;
		}
	for(p=head;p->next;)
		if(p->next->data.cofficient==0){
			Polynomial*q;
			q=p->next;
			p->next=q->next;
			free(q);
		}
		else
			p=p->next;
}

/**
*按指数从高到低排序
*/
voidsort(Polynomial*head){
	Polynomial*p,*q;
	for(p=head->next;p->next;p=p->next){
		NodeTypet=p->data;
		for(q=p->next;q;q=q->next){
			if(t.index<q->data.index){
				p->data=q->data;
				q->data=t;
				t=p->data;
			}
		}
	}
}

Polynomial*add(Polynomial*a,Polynomial*b){
	Polynomial*p,*ret=(Polynomial*)malloc(sizeof(Polynomial));
	ret->next=NULL;
	for(p=a->next;p;p=p->next)
		append(ret,p->data);
	for(p=b->next;p;p=p->next)
		append(ret,p->data);
	sort(ret);
	merge(ret);
	returnret;
}

Polynomial*multiply(Polynomial*a,Polynomial*b){
	Polynomial*p,*q,*ret=(Polynomial*)malloc(sizeof(Polynomial));
	ret->next=NULL;
	for(p=a->next;p;p=p->next)
		for(q=b->next;q;q=q->next){
			NodeTypedata={p->data.index+q->data.index,p->data.cofficient*q->data.cofficient};
			append(ret,data);
		}
	sort(ret);
	merge(ret);
	returnret;
}

voiddisplay(Polynomial*head){
	Polynomial*p;
	for(p=head->next;p;p=p->next){
		if(p->data.cofficient<0)
			printf("-");
		elseif(p!=head->next)
			printf("+");
		if(!(abs(p->data.cofficient)==1&&p->data.index>0))
			printf("%d",abs(p->data.cofficient));
		if(p->data.index>0){
			printf("X");
			if(p->data.index>1)
				printf("^%d",p->data.index);
		}
	}
	printf("
");
}

intmain(){
	Polynomial*a=(Polynomial*)malloc(sizeof(Polynomial)),
			*b=(Polynomial*)malloc(sizeof(Polynomial));
	input(a);
	input(b);
	display(a);
	display(b);
	display(add(a,b));
	display(multiply(a,b));
	return0;
}

4. 数据结构c语言题目实现

#include <stdio.h>
#define SIZE 1024
int main(void){
int myQQGroupNumber=936250734;
char text[SIZE];
char encry[SIZE];
gets(text);
int p=0,m,n,pe=0;
while(text[p]!=''){
for(m=p,n=0;text[m]==text[p];p++,n++);
if(n>1)
encry[pe++]='0'+n;
encry[pe++]=text[m];
}
encry[pe++]='';
puts(encry);
return 0;
}

5. 数据结构用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;
}
}
//楼主只能帮你到这了

6. 数据结构的c语言实现

typedef struct LNode{
int data;
struct *next;
}LNode,*LinkList;
里面定义有问题，复struct *next;-改成 ----struct LNode *next;

CreateList_L

p->next=(int)malloc(sizeof(LNode));类型为什制么要强转，还匹配吗？p->next=(LinkList)malloc(sizeof(LNode));
这段代码问题太多了，建议把链表这好好看看

7. 数据结构C语言——实现各种排序算法

刚做完的
#include <iostream>
using namespace std;

void BiInsertsort(int r[], int n) //插入排序（折半）
{
for(int i=2;i<=n;i++)
{
if (r[i]<r[i-1])
{
r[0] = r[i]; //设置哨兵
int low=1,high=i-1; //折半查找
while (low<=high)
{
int mid=(low+high)/2;
if (r[0]<r[mid]) high=mid-1;
else low = mid+1;
}
int j;
for (j=i-1;j>high;j--) r[j+1] = r[j]; //后移
r[j+1] = r[0];
}
}
for(int k=1;k<=n;k++) cout<<r[k]<<" ";
cout<<"\n";
}

void ShellSort ( int r[], int n) //希尔排序
{
for(int d=n/2;d>=1;d=d/2) //以d为增量进行直接插入排序
{
for (int i=d+1;i<=n;i++)
{
r[0] = r[i]; //暂存被插入记录
int j;
for( j=i-d; j>0 && r[0]<r[j]; j=j-d) r[j+d] = r[j]; //记录后移d个位置
r[j+d] = r[0];

}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}

void BubbleSort(int r[], int n) //起泡排序
{
int temp,exchange,bound;
exchange=n; //第一趟起泡排序的范围是r[0]到r[n-1]
while (exchange) //仅当上一趟排序有记录交换才进行本趟排序
{
bound=exchange;
exchange=0;
for (int j=1; j<bound; j++) //一趟起泡排序
if (r[j]>r[j+1])
{
temp=r[j];
r[j]=r[j+1];
r[j+1]=temp;
exchange=j; //记录每一次发生记录交换的位置
}
}
for(int i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}

int Partition(int r[], int first, int end) //快速排序一次划分
{
int i=first; //初始化
int j=end;
r[0]=r[first];
while (i<j)
{
while (i<j && r[0]<= r[j]) j--; //右侧扫描
r[i]=r[j];
while (i<j && r[i]<= r[0]) i++; //左侧扫描
r[j]=r[i];
}
r[i]=r[0];
return i; //i为轴值记录的最终位置
}
void QuickSort(int r[], int first, int end) //快速排序
{
if (first<end)
{ //递归结束
int pivot=Partition(r, first, end); //一次划分
QuickSort(r, first, pivot-1);//递归地对左侧子序列进行快速排序
QuickSort(r, pivot+1, end); //递归地对右侧子序列进行快速排序
}
}

void SelectSort(int r[ ], int n) //简单选择排序
{
int i,j,index,temp;
for (i=1; i<n; i++) //对n个记录进行n-1趟简单选择排序
{
index=i;
for (j=i+1; j<=n; j++) //在无序区中选取最小记录
if (r[j]<r[index]) index=j;
if (index!=i)
{
temp=r[i];
r[i]=r[index];
r[index]=temp;
}
}
for(i=1;i<=n;i++) cout<<r[i]<<" ";
cout<<"\n";
}

void main()
{
const int numv=12;
int a[3][numv]={{0,6,13,19,23,37,39,41,45,48,58,86},{0,86,58,48,45,41,39,37,23,19,13,6},{0,23,13,48,86,19,6,41,58,37,45,39}};
int z1[numv],z2[numv];
int m,n;
cout<<"请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]" <<endl;
cin>>m;
while(m>0&&m<4)
{
cout<<"请选择排序算法：⑴直接插入排序 ⑵希尔排序 ⑶冒泡排序 ⑷快速排序 \n ⑸简单选择排序"<<endl;
cin>>n;
switch(n)
{
case 1:
cout << "直接插入排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n直接插入排序结果为：" << "\n";
BiInsertsort(a[m-1],numv-1);
break;
case 2:
cout << "\n希尔排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n希尔排序结果为：" << "\n";
ShellSort(a[m-1], numv-1);
break;
case 3:
cout << "\n冒泡排序前：" << "\n";
for(int k=1;k<numv;k++) cout<<a[m-1][k]<<" ";
cout << "\n冒泡排序结果为：" << "\n";
BubbleSort(a[m-1], numv-1);
break;
case 4:
cout << "\n快速排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n快速排序结果为：" << "\n";
QuickSort(a[m-1],0,numv-1);
for(int i=1;i<numv;i++)
cout<<a[m-1][i]<<" ";
cout<<"\n";
break;
case 5:
cout << "\n简单选择排序前：" << "\n";
for(int j=1;j<numv;j++) cout<<a[m-1][j]<<" ";
cout << "\n简单选择排序结果为：" << "\n";
SelectSort(a[m-1],numv-1);
break;

default:
cout<<"输入错误！"<<endl;
}
m=0;
cout<<"请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]" <<endl;
cin>>m;
}
if(m==4) cout<<"(*^__^*) 再见！"<<endl;
else cout<<"输入错误！"<<endl;
}

8. 数据结构如何通过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
}

9. 数据结构之C语言实现

是的，你理清每个数据结构的原理即可

阅读全文

数据结构的c语言实现

与数据结构的c语言实现相关的阅读推荐