線性表c語言

㈠ 誰能給一個簡單的線性表操作c語言完整程序

1、線性表有兩種：

typedefstruct{

ElemType*elem;

intlength;

intlistsize;

}SqList;//順序表

voidInitList_Sq(SqList&l){

l.elem=newElemType[LIST_INIT_SIZE];

l.length=0;

l.listsize=LIST_INIT_SIZE;

}//初始化順序表

然後SqListLa;

InitList_Sq(La);

就可以

typedefstructLnode{

intdata;

structLnode*next;

}Lnode,*LinkList;//線性鏈表

//單鏈表可以有效的利用主存的碎片,它的數據域不是連續的

2、常式：

#include"stdio.h"
#include<malloc.h>
typedefcharElemType;
typedefstructLNode
{ElemTypedata;
structLNode*next;
}LinkList;
voidCreatListF(LinkList*&L,ElemTypea[],intn)//頭插法建表
{
LinkList*s;inti;
L=(LinkList*)malloc(sizeof(LinkList));
L->next=NULL;
for(i=0;i<n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
voidCreateListR(LinkList*&L,ElemTypea[],intn)//尾插法建表
{
LinkList*s,*r;inti;
L=(LinkList*)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
voidInitList(LinkList*&L)//初始化線性表
{
L=(LinkList*)malloc(sizeof(LinkList));
L->next=NULL;
}
voidDestroyList(LinkList*&L)//銷毀線性表
{
LinkList*p=L,*q=p->next;
while(q!=NULL)
{
free(p);
p=q;
q=p->next;
}
free(p);
}
intListEmpty(LinkList*L)//判斷線性表是否為空
{
return(L->next==NULL);
}
intListLength(LinkList*L)//求線性表的長度
{
LinkList*p=L;intn=0;
while(p->next!=NULL)
{
n++;p=p->next;
}
return(n);
}
voidDispList(LinkList*L)//輸出線性表
{
LinkList*p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
}
intGetElem(LinkList*L,inti,ElemType&e)//求線性表中某個數據元素值
{
intj=0;
LinkList*p=L;
while(j<i&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return0;
else
{
e=p->data;return1;
}
}
intLocateElem(LinkList*L,ElemTypee)//按元素值查找
{
LinkList*p=L->next;
inti=1;
while(p!=NULL&&p->data!=e)
{
p=p->next;i++;
}
if(p==NULL)return(0);
elsereturn(i);
}
intListInsert(LinkList*&L,inti,ElemTypee)//插入數據元素
{
intj=0;
LinkList*p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)return0;
else
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=e;s->next=p->next;p->next=s;
return1;
}
}
intListDelete(LinkList*&L,inti,ElemType&e)//刪除數據元素
{
intj=0;
LinkList*p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return0;
else
{
q=p->next;
if(q==NULL)return0;
e=q->data;
p->next=q->next;
free(q);
return1;
}
}
intmain()
{
ElemTypee,a[5]={'a','b','c','d','e'};
LinkList*h;
InitList(h);//初始化順序表h
CreateListR(h,&a[0],5);//依次採用尾插入法插入a，b，c，d，e元素
printf("單鏈表為：");
DispList(h);printf("
");//輸出順序表h
printf("該單鏈表的長度為：");
printf("%d",ListLength(h));printf("
");//輸出順序表h的長度
if(ListEmpty(h))printf("該單鏈表為空。
");
elseprintf("該單鏈表不為空。
");//判斷順序表h是否為空
GetElem(h,3,e);printf("該單鏈表的第3個元素為：");
printf("%c",e);printf("
");//輸出順序表h的第3個元素
printf("該單鏈表中a的位置為：");
printf("%d",LocateElem(h,'a'));printf("
");//輸出元素'a'的位置
ListInsert(h,4,'f');//在第4個元素位置插入'f'素
printf("在第4個元素位置上插入'f'後單鏈表為：");
DispList(h);printf("
");//輸出順序表h
ListDelete(h,3,e);//刪除L的第3個元素
printf("刪除第3個元素後單鏈表為：");
DispList(h);printf("
");//輸出順序表h
DestroyList(h);//釋放順序表h
return0;
}

㈡ C語言線性表

#include<stdio.h>
#include<stdlib.h>
typedef struct aaa{
int a;
struct aaa *next;}*uuu;
struct aaa * ccc(uuu l);
void ddd(uuu l);
int main()
{
int m;
uuu l;
l=NULL;
do{
printf("1_____插入一個元素:\n2_____輸出全部元素:\n0_____退出.\n");
scanf("%d",&m);
switch(m)
{case 1:l=ccc(l);break;
case 2:ddd(l);break;
case 0:break;
default:printf("輸入錯誤，請重新輸入:\n");}
}while(m!=0);
return 0;
}
struct aaa * ccc(uuu l)
{
struct aaa *p;
printf("輸入要插入的數:\n");
p=(uuu)malloc(sizeof(struct aaa));
scanf("%d",&p->a);
p->next=l;
return p;
}
void ddd(uuu l)
{
struct aaa *p;
p=l;
while(p!=NULL)
{
printf("%d\t",p->a);
p=p->next;
}
}

㈢ 線性表的基本操作c語言實現

代碼如下：

頭文件：

2_1.h

#ifndef _2_1_H

#define _2_1_H

typedef void SeqList;

typedef void SeqListNode;

//創建線性表

SeqList * SeqList_Create(int capacity);

//銷毀線性表

void SeqList_DesTroy(SeqList * list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

源文件：

// 順序線性表.cpp : 定義控制台應用程序的入口點。

//

#include "stdafx.h"

#include <malloc.h>

#include <stdlib.h>

#include "2_1.h"

typedef unsigned int TSeqListNode;

typedef struct {

int len; //長度

int capacity;//總長度

TSeqListNode * node;//每個節點的指針

} TSeqList;

int main()

{

SeqList* list = SeqList_Create(5);//創建線性表

int i = 6;//賦值6個變數，已超過線性表最大值 5

int j = 1;

int k = 2;

int x = 3;

int y = 4;

int z = 5;

int index = 0;

SeqList_Insert(list, &i, 7); //將這6個變數插入線性表中

SeqList_Insert(list, &j, 0);

SeqList_Insert(list, &k, 0);

SeqList_Insert(list, &x, 0);

SeqList_Insert(list, &y, 0);

SeqList_Insert(list, &z, 0);

//遍歷

for(index=0; index<SeqList_Length(list); index++)

{

int* p = (int*)SeqList_Get(list, index);

printf("%d ", *p);

}

printf(" ");

//刪除操作

while( SeqList_Length(list) > 0 )

{

int* p = (int*)SeqList_Delete(list, 0);

printf("刪除了： %d ", *p);

}

SeqList_Clear(list);

SeqList_DesTroy(list);

system("pause");

return 0;

}

//創建線性表

SeqList * SeqList_Create(int capacity)

{

TSeqList* ret = NULL ;

if(capacity >= 0)

{

ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity); //為線性表分配空間，包含結 //構體和節點的總大小

}

if(NULL != ret)

{

ret->len = 0;

ret->capacity = capacity;

ret->node = (TSeqListNode*)(ret + 1);//將節點指向上述分配到的空間的後部分

}

return ret;

}

//銷毀

void SeqList_DesTroy(SeqList * list)

{

free(list);

}

//清空

void SeqList_Clear(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

if(NULL != ret)

{

ret->len = 0;

}

}

//獲得線性表的長度

int SeqList_Length(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int len = -1;

if(NULL != ret)

{

len = ret->len;

}

return len;

}

//線性表的總長度

int SeqList_Capacity(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int capacity = -1;

if(NULL != ret)

{

ret->capacity = capacity;

}

return capacity;

}

//插入

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)

{

TSeqList * sList = (TSeqList*)list;

int i,ret = -1;

if((sList != NULL) &&(pos >= 0) && sList->capacity >= sList->len+1)

{

if(pos >= sList->len)

{

pos = sList->len;

}

for(i = sList->len; i > pos; i--)

{

sList->node[i] = sList->node[i-1];

}

sList->node[i] = (TSeqListNode)node;

++sList->len;

ret = 1;

}

return ret;

}

//獲得指定位置的節點

SeqListNode* SeqList_Get(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

TSeqListNode* node = NULL;

if(NULL != sList && pos>=0 && pos < sList->len)

{

node = (TSeqListNode*)sList->node[pos];

}

return node;

}

//刪除

SeqListNode* SeqList_Delete(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

SeqListNode * node = SeqList_Get( list, pos);

int i;

if(sList != NULL && pos >= 0 && pos< sList->len)

{

for( i=pos+1; i<sList->len; i++)

{

sList->node[i-1] = sList->node[i];

}

sList->len--;

}

return node;

}

演示：

資料拓展：

線性表是最基本、最簡單、也是最常用的一種數據結構。

線性表中數據元素之間的關系是一對一的關系，即除了第一個和最後一個數據元素之外，其它數據元素都是首尾相接的（注意，這句話只適用大部分線性表，而不是全部。比如，循環鏈表邏輯層次上也是一種線性表（存儲層次上屬於鏈式存儲），但是把最後一個數據元素的尾指針指向了首位結點）。

我們說「線性」和「非線性」，只在邏輯層次上討論，而不考慮存儲層次，所以雙向鏈表和循環鏈表依舊是線性表。

在數據結構邏輯層次上細分，線性表可分為一般線性表和受限線性表。一般線性表也就是我們通常所說的「線性表」，可以自由的刪除或添加結點。受限線性表主要包括棧和隊列，受限表示對結點的操作受限制。

線性表的邏輯結構簡單，便於實現和操作。因此，線性表這種數據結構在實際應用中是廣泛採用的一種數據結構。

㈣ C語言文字線性表

#include <stdio.h>
#include<Windows.h>
int *pi;
int m=15;
struct node{
int data;
struct node *next;
};
void Get_data(void)
{
while(m>0)
{
scanf("%d",pi);getchar();
if(*pi<0)return;
pi++;
}
}
void Print_slist(struct node *h)
{
struct node *p;
p=h->next;
if(p=='\0')
{
printf("Linklist is null!\n");
}
else
{
// printf("heead");
while(p!='\0')
{
printf("%d\t",p->data);
p=p->next;
}
printf("end\n");
}
}
void Delete_node(struct node *h,int x)
{
struct node *p,*q;
q=h;p=h->next;
if(p!='\0')
{
while((p!='\0')&&(p->data!=x))
{
q=p;p=p->next;
}
if(p->data==x)
{
q->next=p->next;free(p);
}
}
}
void Insert_node(struct node *h,int x,int y)
{
struct node *s,*p,*q;
s=(struct node *)malloc(sizeof(struct node));
s->data=y;
q=h;
p=h->next;
while((p!='\0') && (p->data!=x))
{
q=p;p=p->next;
}
q->next=s;s->next=p;
}
void main()
{
int x;
struct node *phead,*s,*r;
phead=(struct node*)malloc(sizeof(struct node));
r=phead;
scanf("%d",&x);
while(x>=0 && m>0)
{
s=(struct node*)malloc(sizeof(struct node));
s->data=x;
r->next=s;
scanf("%d",&x);
m--;
}
r->next='\0';
Print_slist(s);
}

㈤ C語言中怎麼定義個線性表

1、定義結構體類型，這里需要利用指針和結構體，其中m和n分別表示矩陣的行和列。

㈥ C語言創建一個線性表，然後輸出線性表

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

typedef struct _NodeList
{
int m_data;
_NodeList* m_next;
}NodeList;

NodeList * createList()
{
NodeList *head,*temp,*tail;
head=tail=NULL;
for (int i = 0; i < 10; i++)
{
temp=(NodeList *)malloc(sizeof(NodeList));
scanf("%d",&temp->m_data);
temp->m_next = NULL;
if(head==NULL)
{
head = tail = temp;
}
else
{
tail->m_next = temp;
tail = temp;
}
}
return head;
}

void printList(NodeList *list)
{
NodeList * tmp = list;
printf("The list is :\n");
while (tmp->m_next != NULL)
{
printf("%d--",tmp->m_data);
tmp = tmp->m_next;
}
printf("%d\n",tmp->m_data);
}

int main()
{
printf("Please input 10 numbers:\n");

/* create list */
NodeList * list = createList();

/* print list */
printList(list);

return 0;
}

㈦ c語言中的線性表是指什麼啊

線性就是數據是一維的意思而已。線性表一般分靜態和動態兩種，靜態的就是數組，動態的就是單鏈表而已。

㈧ 怎樣創建線性表（C語言）

線性表是個抽象的概念，沒辦法直接創建抽象類型，需要具體的類型（比如數組，鏈表）。
比如創建數組：int array[100];
創建一個GList鏈表: GList * list = NULL; (空的）

㈨ 線性表的操作（C語言）

//---------------------------------------------------------------------------

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

#define STY "%d"/*元素類型格式符*/
typedef int eltp;/*元素類型*/

typedef struct node{
eltp data;
struct node *next;
} node;

void init(void)
{
static int fg=1;
if (fg) {
srand(time(NULL));
fg=0;
}
}
node *insert(node *h,eltp d)
{
node *s=(node *)malloc(sizeof(node));
if (!h) {
s->data=d;
s->next=NULL;
h=s;
}
else {
h->next=insert(h->next,d);
}
return h;
}
node *create(int n)
{
node *h=NULL;
int i;
for (i = 0; i<n; i++) {
h=insert(h,rand()%100);
}
if (h) {
printf("線性表生成已完成!\n");
}
else {
fprintf(stderr,"線性表生成未成功\n");
exit(-1);
}
return h;
}
node *del(node *h,eltp d)
{
node *p;
if (h&&h->data==d) {
p=h;
h=h->next;
free(p);
}
else if (h) h->next=del(h->next,d);

return h;
}
int search(node *h,eltp d)
{
int i=1;
while (h&&h->data!=d)
{
h=h->next;
i++;
}
if (!h) i=-1;
return i;
}

int count(node *h)
{
int i=0;
for (i = 0; h; i++) {
h=h->next;
}
return i;
}

void prt(node *h)
{
while (h)
{
printf(STY"\t",h->data);
h=h->next;
}
putchar('\n');
}
void Free(node **h)
{
if (*h) {
Free(&(*h)->next);
free(*h);
*h=NULL;
}
}
int menu(void)
{
int i;
puts("******************");
puts("1.生成線性表");
puts("2.輸出表元素");
puts("3.刪除表元素");
puts("4.查找表元素");
puts("5.統計表元素");
puts("6.插入表元素");
puts("7.刪除線性表");
puts("0.退出本程序");
puts("******************");
printf("請選擇:");
scanf("%d",&i);
return i;
}
void find(node *h)
{
eltp a;
//node *t=NULL;
int index;
printf("請輸入要查找的數字:");
scanf(STY,&a);
index=search(h,a);
if (index!=-1) {
printf(STY"是表中的第%d個元素\n",a,index);
}
else printf(STY"不是表中的元素\n",a);
}
node *insert_node(node *h,int index,eltp a)
{
node *hd=h,*in=(node *)malloc(sizeof(node));
int i;
in->data=a;
if (index>1) {
for (i=1; h->next&&i<index-1; i++) {
h=h->next;
}
in->next=h->next;
h->next=in;
}
else {
in->next=hd;
hd=in;
}
return hd;
}
node *remove_node(node *h)
{
eltp a;
printf("請輸入要刪除的元素:");
scanf(STY,&a);
h=del(h,a);
puts("已完成");
return h;
}
node *ins(node *h)
{
eltp a;
int i;
printf("請輸入要插入的元素:");
scanf(STY,&a);
printf("請輸入要插入的位置:");
scanf("%d",&i);
return insert_node(h,i,a);
}
int main(void)
{
node *head=NULL;
int ch;
init();
do
{
ch=menu();
switch (ch) {

default:printf("輸入有誤，重新輸入\n");break;
case 0:break;
case 1:if(head) Free(&head);
head=create(10);
break;
case 2:prt(head);break;
case 3:head=remove_node(head);break;
case 4:find(head);break;
case 5:printf("表中共有%d個元素\n",count(head));break;
case 6:head=ins(head);break;
case 7:Free(&head);break;

}
}while (ch);
Free(&head);
return 0;
}
//---------------------------------------------------------------------------

㈩ C語言創建一個線性表，然後輸出線性表，如何編寫程序

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

#defineOVERFLOW -2
#define OK 1
#define ERROR 0
#defineLIST_INIT_SIZE 100
#defineLISTINCREMENT 10

typedef intElemType;
typedef intStatus;
//定義順序存儲結構
typedef struct
{
ElemType *elem;
int length;
int listsize;
}SqList;
//初始化順序表
StatusInitList_Sq(SqList &L)
{
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem ) exit(ERROR);
L.length =0;
L.listsize =LIST_INIT_SIZE;
return OK;
}
//自定義創建順序表
voidCreate_SqList(SqList &L)
{
int c,i=0;
int *newBase;
printf("請輸入順序表元素：\n");
while((scanf("%d",&c))!=EOF)
{
if(i>=L.listsize) //自定義順序表大小超過初始化大小
{
newBase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
//為初始順序表以LISTINCREMENT大小重新增加存儲空間
if(!newBase)exit(OVERFLOW);
L.elem=newBase;
L.listsize+=LISTINCREMENT;
}
L.elem[i++]=c;
}
L.length=i;
printf("輸入的順序表元素：\n");
for(i=0;i<L.length;i++)
printf("%d ",L.elem[i]);
printf("\n");
}
//在指定位置插入元素
StatusListInsert(SqList &L,int i,ElemType e)
{
ElemType *p,*q,*newbase;
if(i<1||i>L.length+1)
{
printf("插入位置錯誤\n");
return(ERROR);
}
if(L.length>=L.listsize)
{
newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW);
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
if(i==L.length) L.elem[i+1]=e;
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;
*q=e;
++L.length;
return OK;
}
//在指定位置刪除元素
StatusListDelete_Sq(SqList &L,int i,ElemType *e)
{
ElemType *p,*q;
if(i<1||i>L.length+1)
return ERROR;
p=&(L.elem[i-1]);
*e=*p;
q=L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1)=*p;
--L.length ;
return OK;
}

void main()
{
SqList L;
int m,n;
int location,element;
if(!InitList_Sq(L))
{
printf("初始化順序表失敗！\n");
exit(ERROR);
}
Create_SqList(L);
for(m=0;m<3;m++)
{
printf("輸入插入位置：");
scanf("%d",&location);
while(location>L.length+1||location<1)
{
printf("輸入位置錯誤，請重新輸入！\n");
scanf("%d",&location);
}
printf("插入元素：");
scanf("%d",&element);
if(!ListInsert(L,location,element))
{
printf("順序表插入失敗！\n");
exit(ERROR);
}
printf("插入順序表為：\n");
for(int i=0;i<=L.length -1;i++)
{
printf("%d ",L.elem[i]);
}
printf("\n新順序表一共有%d個元素。\n",L.length);
}
for(n=0;n<3;n++)
{
printf("輸入刪除位置：");
scanf("%d",&location);
while(location>L.length||location<1)
{
printf("輸入位置錯誤，請重新輸入！\n");
scanf("%d",&location);
}
if(!ListDelete_Sq(L,location,&element))
{
printf("刪除錯誤！\n");
exit(ERROR);
}
printf("被刪除的元素為：%d \n",element);

printf("被刪除後的順序表為：\n");
for(int j=0;j<=L.length-1;j++)
{
printf("%d ",L.elem[j]);
}
printf("\n新順序表一共有%d個元素。\n",L.length);
}
}
這個是我最近編寫的 順序表也是線性表的
這里還有鏈表的程序 用的話再傳給你