数据结构c语言版线性表

1. 数据结构c语言版 使用线性表的顺序储存结构定义(静态)实现线性表的初

直接上源码吧。
/*线性表功能的实现*/
#include<stdio.h>
//定义常量 存储空间的初始化分配
#define MAXSIZE 20
#define TRUE 1
#define ERROR -1
#define FALSE 0
#define OK 1
//用typedef定义类型
typedef int Status;
typedef int ElemType;
//定义一个结构体类型
typedef struct{
ElemType data[MAXSIZE];
int length;
} sqlist;
//初始化函数
Status initList(SqList *L){
L->length = 0;
return OK;
}
//返回线性表的长度
Status getListLength(SqList L){
return L.length;
}
//线性表为空返回true,否则返回false
Status listEmpty(SqList L){
if(L.length == 0){
return TRUE;
}
return FALSE;
}
//线性表清空,长度为0
Status clearList(SqList *L){
L->length = 0;
return OK;
}
//获取指定的元素的值,返回下标为i - 1的元素,赋值给e
Status getElem(SqList L, int i, ElemType *e){
//判断元素位置是否合法[i]
if(i > L.length || i < 1){
printf("查找的位置不正确 \n");
return ERROR;
}
//判断线性表是否为空
if(listEmpty(L)){
return ERROR;
}
*e = L.data[i - 1];
return OK;
}
//在线性表中查找指定的e相等的元素,如果查找成功,返回该元素的下标,否则返回ERROR
Status locateElem(SqList L, ElemType e){
int i;
for(i = 0; i < L.length - 1; i++){
if(L.data[i] == e){
return i;
}
}
printf("没有查找到元素 %d 指定的下标\n",e);
return ERROR;
}
//自动创建 MAXSIZE 个元素,并赋值为0
Status createList(SqList *L){
int i;
for(i = 0; i < 10; i++){
L->data[i] = 0;
}
L->length = 10;
return OK;
}
//在线性表中第i个位置前插入新元素e
Status listInsert(SqList *L, int i, ElemType e){
//判断长度是否可以允许插入新的数据
if(L->length >= MAXSIZE){
printf("空间已满,不能再插入数据\n");
return FALSE;
}
//判断插入位置的合法性
if(i < 1 || i > L->length) {
printf("插入位置不正确\n");
return FALSE;
}
int j;
for(j = L->length - 1; j >= i; j--){
L->data[j] = L->data[j - 1];
}
L->data[i - 1] = e;
L->length++;
return TRUE;
}
//删除线性表中第i个元素,成功后表长减1,用e返回其值
Status deleteList(SqList *L, int i, ElemType *e){
//判断线性表是否为空
if(listEmpty(*L)){
return ERROR;
}
//判断删除的位置是否合法
if(i < 1 || i > L->length) {
printf("删除位置不合法\n");
return ERROR;
}
*e = L->data[i - 1];
for(i; i < L->length; i++){
L->data[i - 1] = L->data[i];
}
L->length--;
return TRUE;
}
//遍历线性表
Status listTraverse(SqList L){
int i;
for(i = 0; i < L.length; i++){
printf("%d ",L.data[i]);
}
printf("\n");
return OK;
}
//主程序
int main(void){
SqList L;
ElemType e;
initList(&L);
int option = 1;
int input_number;
int res;
ElemType input_value;
printf("\n1.遍历线性表 \n2.创建线性表 \n3.清空线性表 \n4.线性表插入 \n5.查找表中元素 \n6.判断元素是否在表中 \n7.删除某个元素 \n8.线性表长度\n9.线性表是否为空\n0.退出 \n请选择你的操作：\n");
while(option){
scanf("%d",&option);
switch(option){
case 0:
return OK;
break;
case 1:
listTraverse(L);
break;
case 2:
createList(&L);
listTraverse(L);
break;
case 3:
clearList(&L);
listTraverse(L);
break;
case 4:
printf("请输入插入的位置:");
scanf("%d",&input_number);
printf("\n");
printf("请输入插入的值:");
scanf("%d",&input_value);
printf("\n");
listInsert(&L, input_number, input_value);
listTraverse(L);
break;
case 5:
printf("请输入要查找的位置:");
scanf("%d",&input_number);
printf("\n");
getElem(L, input_number, &input_value);
printf("第%d个元素的值为:%d\n",input_number,input_value);
break;
case 6:
printf("请输入要查找的元素:");
scanf("%d",&input_value);
printf("\n");
res = locateElem(L, input_value);
if(res != ERROR){
printf("值为%d在表中的第%d个位置\n",input_value,input_number);
}
break;
case 7:
printf("要删除第几个元素？");
scanf("%d",&input_number);
printf("\n");
deleteList(&L, input_number, &input_value);
listTraverse(L);
break;
case 8:
res = getListLength(L);
printf("线性表的长度是:%d",res);
break;
case 9:
res = listEmpty(L);
if(res){
printf("线性表的是空的");
}else{
printf("线性表的是不是空的");
}
break;
}
}
return OK;
}

线性表的特征是:
1. 元素之间是有序的,如果元素存在多个,则第一个元素无前驱,最后一个无后继,其它元素都有且只有一个前驱和后继.
2. 元素个数是有限的. 当n=0是,称为空表
线性表实现方式有两种,分别是顺序存储结构和链式存储结构,它们之间各有优缺点 . 根据需求的不同进行选择不同的存储结构.
线性表存储结构的优缺点
优点:
1. 无须为表中元素之前的逻辑关系而增加额外的存储空间
2. 可以快速的存取表中的任一位置的元素
缺点:
1. 插入和删除操作需要移动大量元素
2. 当线性表长度变化较大时,难以确定存储空间的容量.
3. 造成存储空间的”碎片”.

2. 【100分】数据结构——使用C语言（线性表）

//c++的头文件,我是用c++编写的，有一些该成了C但是有些输入输出没有改
//希望楼主不要建议哦，费了很久的时间写的啊！
#include<iostream>//c++的头文件
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<math.h>
#define error 0
#define OVERFLOW 1
#define OK 1
using namespace std;//c++的一个指令
typedef struct
{
int *elem; //存储空间基址
int length; //当前长度
int listsize;//当前分配的存储容量
// (以sizeof(ElemType)为单位)
//int *next;
}sqlist;

void initList(sqlist &La)
{//构造一个空线性表L
La.elem=(int *) malloc(100 *sizeof(int));//分配空间
if (!La.elem) exit(-2);//未分配则 跳出；
La.length=0;
La.listsize= 100 ;
}

int Listinsert_sq(sqlist &L,int i,int e) // listinsert_sq;插入一个元素
{int *newbase;int *p,*q;
if (i<1 || i>L.length+1) return error;
if (L.length>=L.listsize)//空间不足追加
{newbase=(int*) realloc(L.elem,(L.listsize+10) *sizeof(int));
if (!newbase)
exit(-2);
L.elem=newbase; L.listsize+=10 ;
return 0;
}
q=&(L.elem[i-1]);//指针指向确定插入的位子
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1)=*p;//指针后移
*q=e; //实现元素的插入
++L.length;
return 0;
}
int ListDelete_sq(sqlist &L,int i)//删除i位子的元素
{int *p,*q;
if((i<1)||(i>L.length)) return 0;
p=&(L.elem[i-1]);
//e=*p;
cout<<"被删除的值是："<<*p<<endl;
for(q=&(L.elem[L.length-1]);p<q;p++)
*p =*(p+1);//指针前移，覆盖前面的存储的数据
--L.length;
return 1;
}
int Getelem(sqlist &L)//输入表的数据
{ int n;
cout<<"输入数列的个数："<<endl;
cin>>n;
printf("按大小顺序输入n个数：");//cout<<"按大小顺序输入n个数：";
if(n<0||n>L.listsize ) return 0;
for(int i=0;i<n;i++)//循环输入元素
{ cin>>L.elem [i];
L.length ++;//表长度
}
cout<<"这数列的长度："<<L.length <<endl;
return 1;
}
int Poplist(sqlist &L)//输出函数
{
for(int j=0;j<L.length ;j++)
cout<<L.elem[j]<<" ";
printf("\n");//cout<<endl;
return 0;
}
void ListMerge(sqlist La,sqlist Lb, sqlist &Lc)//合并函数，
{ int *pa,*pb,*pa_list ,*pb_list,*pc;
pa=La.elem;pb=Lb.elem;//用pa和pb指向表头
Lc.length=La.length+Lb.length;
Lc.listsize=Lc.length;
Lc.elem=(int *)malloc(Lc.listsize*sizeof(int ));//合理分配Lc的空间
if(!Lc.elem) exit(-2);
pa_list=&(La.elem[La.length-1]);pb_list=&(Lb.elem[Lb.length-1]);//用pa-list和pb_list指向表未
pc=Lc.elem;
while(pa<=pa_list&&pb<=pb_list)//合并算法
{ if(*pa>=*pb){ *pc++=*pb++;*pc++=*pa++;}

//if(*pa=*pb){ *pc++=*pa++;*pc++=*pb++; }

else {*pc++=*pa++;*pc++=*pb++;}
}
while(pa<=pa_list) *pc++=*pa++;//插入剩余的元素；
while(pb<=pb_list) *pc++=*pb++;
}
int main()
{ sqlist La,Lb,Lc;int i,e;
initList(La);
Getelem(La);
initList(Lb);
Getelem(Lb);
ListMerge(La,Lb,Lc);
Poplist(Lc);
printf("input munber 要删除的位子i \n:");
scanf("%d",&i);// cin>>i;
ListDelete_sq(La,i);
Poplist(La);//我这里是用表La做例子。也可用Lb。。。
printf("输出要插入的位子和元素：\n");
scanf("%d%d",&i,&e);//cin>>i>>e;
Listinsert_sq(Lb,i,e);
Poplist(Lb);//我这里是用表Lb做例子。也可用La。。。
return 0;
}
终于全搞定了，还有些不足，希望对楼主有用！

3. 数据结构 线性表 用c语言

#define MAXSIZE 100 //表中元素的最大个数

typedef int ElemType；//元素类型

typedef struct list{

ElemType elem[MAXSIZE];//静态线性表

int length; //表的实际长度

}SqList;//顺序表的类型名

4. 数据结构中，怎么用C语言构造线性表！

#define
OK
1
#define
ERROR
-1
#define
MAX_SIZE
100
typedef
int
Status
;
typedef
int
ElemType
;
typedef
struct
sqlist
{
ElemType
Elem_array[MAX_SIZE]
;
int
length
;
}
SqList
;
以上为线性表建立的相关定义
Status
Init_SqList(
SqList
*L
)
{
L->elem_array=(
ElemType
*
)malloc(MAX_SIZE*sizeof(
ElemType
)
)
;
if
(
!L
->
elem_array
)
return
ERROR
;
else
{
L->length=
0
;
return
OK
;
}
}
以上为线性表初始化函数
有以上两部分可构造一个线性表

5. 数据结构c语言版，第二章线性表

说实话，我本学期也开数据结构，只不过教我们的是一个年过60的老爷爷。水平就不说了，你想要答案，我没有，我这有思路，前5个要求我可以解决。我说一下思路：
如果想按书上的那种方式来编写代码,你需要一定的指针知识，不然说了你也看不懂。看下面：
这一步是定义，别说这你也看不懂：
typedef struct LNode /*定义结点*/
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
下面这步是初始化链表，这步中，你要注意几个问题，第一个是LinkList *L，你可以看成双指针。指针不好可以复习下。：
InitList(LinkList *L) /*初始化*/
{(*L)=(LinkList)malloc(sizeof(LNode));
if(!(*L)) return 0;
(*L)->next=NULL;
}
这一步：是建立和插入操作，你看得懂这步，那么删除就不难了
CreatList(LinkList *L,int n) /*建立*/
{ int i,e;
for(i=1;i<=n;i++)
{
scanf("%d",&e);
InsertList(L,i,e);
}
}
InsertList(LinkList *L,int i,ElemType e) /*把e插入第i个位置*/
{LinkList p,s;
int j=0;
p=*L;
while(p!=NULL && j<i-1){p=p->next;j++;}
if(p==NULL || j>i-1) return 0;
s=(LinkList)malloc(sizeof(LNode));
s->next=p->next;
p->next=s;
s->data=e;
return 1;
}
这一步是删除，看看是不是和书上的很像？
DeleteList(LinkList *L,int i,ElemType e){
LinkList q,p,s;
int j=0;
p=*L;
while(p->next&&j<i-1){
p=p->next;
j++;
}
if(!p||j>i-1){
return 0;
}
q=p->next;
p->next=q->next;
e=q->data;
free(q);
return e;
}
授之以渔，下面的我就不多说了。不懂得说，

6. 数据结构(c语言版)数据类型线性表的实现

常用的线性表的插入，删除，创建，按位置查找，按值查找，排序。其他操作都是基于以上基本操作实现的，你所谓的12个操作:排序有很多方法，插入类，选择类，交换类，归并类，基数排序法等，这些都是线性表的操作。
一般本科阶段教学大纲中掌握上面的内容即可。

7. 数据结构（C语言版）线性表的操作

//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int *elem;
int length;
int listsize;
}sqlist;
void initlist_sq(sqlist *L){ /*注意这里*/
L->elem=(int *)malloc(5*sizeof(sqlist)); /*注意这里*/
if(!L->elem) /*注意这里*/
exit(0);
L->length=0; /*注意这里*/
L->listsize=5; /*注意这里*/
}
int main()
{
int i;
sqlist p;
initlist_sq(&p); /*注意这里*/
for(i=0;i<5;i++)
{
printf("%d ",i);
scanf("%d",&p.elem[i]);
p.listsize++;
}
printf("%d\n",p.listsize);
for(i=0;i<5;i++)
{
printf("%d\n",p.elem[i]);
p.listsize--;
}
printf("%d",p.listsize);

}
//---------------------------------------------------------------------------

8. c语言数据结构线性表求解

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

#defineMAXSIZE100/*线性表的最大长度*/
typedefintElemType;
//描述线性表
typedefstruct{
ElemTypedata[MAXSIZE];
intlength;/*当前表的长度*/
}SeqList;

//初始化线性表
SeqList*init_SeqList(){
SeqList*L=(SeqList*)malloc(sizeof(SeqList));
L->length=0;
returnL;
}

//插入
voidInsertList(SeqList*L,inti,ElemTypee){
intk;
if(L->length==0||i==L->length){
L->data[L->length]=e;
++L->length;
return;
}
if(i<1||i>L->length){
printf("Thepositionismistake! ");
printf("插入数据%d失败。 ",e);
return;
}
for(k=L->length;k>=i;k--)
L->data[k]=L->data[k-1];/*结点移动*/
L->data[i-1]=e;
L->length++;
}

//删除元素
intsqListDelete(SeqList*L,inti){//???????
intk;
if(i<1||i>=L->length){/*检查删除位置的合法性*/
printf("Thepositionismistake!");
return0;
}
for(k=i-1;k<L->length;k++)
L->data[k]=L->data[k+1];/*向前移动*/
L->length--;
returni;
}

//
intSqlistLcate(SeqList*L,ElemTypex){//??????
inti;
for(i=0;i<L->length;i++){
if(L->data[i]==x)
returni+1;/*返回的是存储位置*/
}
return-1;
}

voidShow(SeqList*list){
for(inti=0;i<list->length;++i)
printf("%d",list->data[i]);
printf(" ");
}

//主函数
intmain(){
intx,loc;
inti;
SeqList*list=init_SeqList();
//添加10个数字给线性表list
printf("pleaseinput10numbers:");
for(i=0;i<10;i++){
scanf("%d",&x);
InsertList(list,i,x);
}
Show(list);
printf("在第2个位置插入一个元素999后 ");
InsertList(list,2,999);
Show(list);
printf("删除元素%d后。 ",list->data[5-1]);
sqListDelete(list,5);
Show(list);
//查找
loc=SqlistLcate(list,4);
if(loc>=0)printf("第4个元素是:%d ",list->data[loc]);
elseprintf("没有找到第4个元素。 ");
return0;
}