當前位置：首頁 » 編程語言 » 數據結構的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語言實現相關的閱讀推薦