數據結構使用c語言
① 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鏈表結點上的數據:
218222632
將鏈表A和鏈表B仍然按照遞增關系合並成一個新的鏈表C:列印合並後鏈表結點上的數據:
12182022263032
② 數據結構的問題，如何用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語言來實現，請舉例說明，盡可能詳細
數據的結構無非就是表：線性表、鏈表，棧，隊列，串，數組，樹、二叉樹，圖，這幾種。
常用的使用指針，或數組建立數據結構，然後對其進行插入、刪除、查找、排序等操作。
以下是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語言
只有第二題
#include<stdio.h>#include<stdlib.h>
#define MAX 256
//typedef int List[MAX];
typedef int ElemType;
typedef int Status;
#define OVERFLOW -1
#define OK 1
#define LIST_INIT_SIZE 80
#define LISTINCREMENT 10
typedef struct {
ElemType *elem;
int length;
int listsize;
} SqList;
typedef SqList List;
Status InitList_Sq( SqList* L )
{
(*L).elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType));
if (!(*L).elem) exit (OVERFLOW);
(*L).length = 0;
(*L).listsize = LIST_INIT_SIZE;
return OK;
}
void main()
{
int ListLength(List Lx);
void GetElem(List Lx,int i,ElemType *xi);
Status InitList_Sq( SqList* L );
void ListInsert(List *Lc,int k,ElemType e);
void MergeList(List La,List Lb);
void printElem(List Lx);
List La,Lb;
int i;
InitList_Sq(&La ); InitList_Sq(&Lb );
printf("pls input length of La ,Lb\n");
scanf("%d,%d",&La.length,&Lb.length);
printf("intiating La....\n");
for(i=1;i<=La.length;i++)
scanf("%d",&La.elem[i]);
printf("intiating Lb....\n");
for(i=1;i<=Lb.length;i++)
scanf("%d",&Lb.elem[i]);
printf("values of La are:\n");
printElem(La);
printf("values of Lb are:\n");
printElem(Lb);
printf("starting union...\n");
MergeList(La,Lb);
}
void MergeList(List La,List Lb)
{
List Lc;
int i,j,k;
ElemType ai,bj;
int La_len=0,Lb_len=0;
i=j=1;k=0;
InitList_Sq(&Lc );
La_len=ListLength(La);Lb_len=ListLength(Lb);
while((i<=La_len)&&(j<=Lb_len))
{
GetElem(La,i,&ai); GetElem(Lb,j,&bj);
if(ai<=bj) {ListInsert(&Lc,++k,ai);++i;}
else {ListInsert(&Lc,++k,bj);++j;}
}
while(i<=La_len)
{
GetElem(La,i++,&ai);ListInsert(&Lc,++k,ai);
}
while(j<=Lb_len)
{
GetElem(Lb,j++,&bj);ListInsert(&Lc,++k,bj);
}
Lc.length=k;
printf("values of Lc after union:\n");
printElem(Lc);
}
void printElem(List Lx)
{
int i;
for(i=1;i<=Lx.length;i++)
{
printf("%5d",Lx.elem[i]);
if(0==i%5)
printf("\n");
}
printf("\n");
}
void GetElem(List Lx,int i,ElemType *xi)
{
if(i>0 && i<=Lx.length) *xi=Lx.elem[i];
// printf("current value get: %d\n",Lx[i]);
// printf("current value get: %d\n",xi[i]);
}
int ListLength(List Lx)
{
return Lx.length;//
}
void ListInsert(List *Lc,int k,ElemType e){
(*Lc).elem[k]=e; //printf("insert success to e=%d\n",e);
}
⑤ 數據結構（使用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語言編程
#include "stdlib.h"
#include "iostream.h"
#define ERROR 0
#define OK 1
typedef int elemtype;
typedef struct lnode{
elemtype data;
struct lnode* next;
}lnode,*linklist;
void init_linklist(linklist &p)//鏈表參數採用引用參數，因初始化鏈表是從沒有鏈表到有鏈表，並且要保留這個空鏈表以便後面使用，所以必須採用引用參數。當然採用指針參數也是可以的。
{
p=(linklist)malloc(sizeof(lnode));
p->next=NULL;
}
void crt_linklist(linklist &p,int len)//鏈表參數採用引用參數，與初始化同理
{
init_linklist(p);
lnode* t;
t=p;
lnode* s;
for(int i=1;i<=len;i++)
{
s=(linklist)malloc(sizeof(lnode));
s->data=i*10;
s->next=NULL;
t->next=s;
t=s;
}
}
void output_linklist(linklist p)//鏈表參數採用賦值參數，因為輸出不改變鏈表結構
{
lnode* q=p->next;
int i=1;//初值設為1，因為是從第一個元素開始輸出的
while(q)
{
cout<<q->data<<","<<i<<" ";
q=q->next;
i++;
}
}
int main()
{
linklist p;
int i=30;//最好用int，這里是定義長度的，不是定義一個數據元素；或者typedef int Length; Length i=30;更好，呵呵
crt_linklist(p,i);
output_linklist(p);
return 0;
}
⑦ 用C語言寫的數據結構的定義
typedef
struct
//typedef是表示定義類型。
(比如type
int
a；
那麼就可以這樣使用定義整型變數，a
number；當然你這里所定義的就可以這樣使用了
node
another；就表示another也是一個結構體)
{
elementype
data;
//
node當中的數據data；(這里的elementype表示你可
以有很多數據，比如int
a；char
address[10]等等)
struct
node
*next;
//
定義了一個node當中指向下一個結點的next指針(比如當前結點是p，那麼p->next就是指向下一個結點)
}node;
//
定義了一個名叫node的結構
⑧ 數據結構（使用C語言）隊列
對順序循環隊列，常規的設計方法是使用隊尾指針和隊頭指針，隊尾指針用於指出當前胡隊尾位置下標，隊頭指針用於指示當前隊頭位置下標。現要求：
（1）設計一個使用隊頭指針和計數器胡順序循環循環隊列抽象數據類型，其中包括：初始化，入隊列，出隊列，取隊頭元素肯判斷隊列是否非空；
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"conio.h"
#defineMAX80
typedefstruct
{
intdata[MAX];
intfront,rear;
intnum;
}SeQue;
SeQue*Init_SeQue()
{
SeQue*s;
s=newSeQue;
s->front=s->rear=MAX-1;
s->num=0;
returns;
}
intEmpty_SeQue(SeQue*s)
{
if(s->num==0)
return1;
else
return0;
}
intIn_SeQue(SeQue*s,intx)
{
if(s->num==MAX)
return0;
else
{
s->rear=(s->rear+1)%MAX;
s->data[s->rear]=x;
s->num++;
return1;
}
}
intOut_SeQue(SeQue*s,int*x)
{
if(Empty_SeQue(s))
return0;
else
{
s->front=(s->front+1)%MAX;
*x=s->data[s->front];
s->num--;
return1;
}
}
voidPrint_SeQue(SeQue*s)
{
inti,n;
i=(s->front+1)%MAX;
n=s->num;
while(n>0)
{printf("%d",s->data[i]);
i=(i+1)%MAX;
n--;
}
}
voidmain()
{
SeQue*s;
intk,flag,x;
s=Init_SeQue();
do{
printf("\");
printf("\t\t\t循環順序隊列");
printf("\t\t\t***********************");
printf("\t\t\t**1-入隊**");
printf("\t\t\t**2-出隊**");
printf("\t\t\t**3-判隊空**");
printf("\t\t\t**4-隊列顯示**");
printf("\t\t\t**0-返回**");
printf("\t\t\t***********************");
printf("\t\t\t請輸入菜單項(0-4):");
scanf("%d",&k);
switch(k)
{
case1:
printf("請輸入入隊元素:");
scanf("%d",&x);
flag=In_SeQue(s,x);
if(flag==0)
printf("隊滿不能入隊!按任意鍵返回..");
else
printf("元素已入隊!按任意鍵返回..");
getch();
system("cls");
break;
case2:
flag=Out_SeQue(s,&x);
if(flag==0)
printf("隊列空出隊失敗!按任意鍵返回..");
else
printf("隊列頭元素已出隊~!按任意鍵返回..");
getch();
system("cls");
break;
case3:
flag=Empty_SeQue(s);
if(flag==1)
printf("該隊列為空!按任意鍵返回..");
else
printf("該隊列不為空!按任意鍵返回..");
getch();
system("cls");
break;
case4:
printf("該隊列元素為:");
Print_SeQue(s);
printf("按任意鍵返回..");
getch();
system("cls");
break;
}
}while(k!=0);
}
⑨ 數據結構 用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++也可以通過這個辦法，來實現數據結構，
還有很簡單，就是STL 框架，這個是系統自動定義的函數。用起來容易