c语言数据结构顺序表实验

① 数据结构实验（c语言）： 顺序表实验

//线性表函数操作
#include <stdio.h>
#include <string.h>

#define MaxSize 30
#define Error 0
#define True 1

typedef char ElemType;

typedef struct
{
ElemType elem[MaxSize];

int length;
}SqList; /*顺序表类型定义*/

void InitList(SqList * &L) /*初始化顺序表L*/
{
L = (SqList *)malloc(sizeof(SqList));
L -> length = 0;
}

void DestroyList( SqList *L ) /*释放顺序表L*/
{
free(L);
}

int ListEmpty( SqList *L ) /*判断顺序表L是否为空表*/
{
return( L -> length == 0);
}

int ListLength( SqList *L ) /*返回顺序表L的元素个数*/
{
return( L -> length);
}

void DispList( SqList *L ) /*输出顺序表L*/
{
int i;
if( ListEmpty(L))
return;
for( i = 0; i < L -> length; i++ )
printf("%c", L -> elem[i]);
printf("\n");
}

int GetElem( SqList *L, int i, ElemType &e) /*获取顺序表中的第i个元素*/
{
if( i < 1 || i > L -> elem[i])
return Error;
e = L -> elem[i - 1];
return True;
}

int LocateElem( SqList *L, ElemType e) /*在顺序表中查找元素e*/
{
int i = 0;
while( i < L -> length && L -> elem[i] != e)
i++;
if(i >= L -> length)
return Error;
else
return i+1;
}

int ListInsert( SqList * &L, int i, ElemType e) /*在顺序表L中第i个位置插入元素e*/
{
int j;
if( i < 1 || i > L -> length + 1)
return 0;
i--; /*将顺序表位序转化为elem下标*/
for( j = L -> length; j > i; j--) /*将elem[i]及后面元素后移一个位置*/
L -> elem[j] = L -> elem[j - 1];
L -> elem[i] = e;
L -> length++; /*顺序表长度增1*/
return True;
}

int ListDelete( SqList * &L, int i, ElemType &e) /*顺序表L中删除第i个元素*/
{
int j;
if( i < 1 || i > L -> length)
return Error;
i--; /*将顺序表位序转化为elem下标*/
e = L -> elem[i];
for(j = i; j < L -> length - i; j++)
L -> elem[j] = L -> elem[j + 1];
L -> length--; /*顺序表长度减1*/
return True;
}

void main()
{
SqList *L;
ElemType e;
printf("(1)初始化顺序表L\n");
InitList(L);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(L, 1, 'a');
ListInsert(L, 2, 'b');
ListInsert(L, 3, 'c');
ListInsert(L, 4, 'd');
ListInsert(L, 5, 'e');
printf("(3)输出顺序表L:");
DispList(L);
printf("(4)顺序表L长度 = %d\n", ListLength(L));
printf("(5)顺序表L为%s\n", (ListEmpty(L) ?"空" :"非空"));
GetElem(L, 3, e);
printf("(6)顺序表L的第3个元素 = %c\n", e);
printf("(7)元素a的位置 = %d\n", LocateElem(L,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(L, 4, 'f');
printf("(9)输出新的顺序表L:");
DispList(L);
printf("(10)删除L的第3个元素\n");
ListDelete(L, 3, e);
printf("(11)输出新的顺序表L:");
DispList(L);
printf("(12)释放顺序表L\n");
DestroyList(L);

}

② 关于《数据结构C语言版》的顺序表的算法实现的实验代码请教高手！！

sjshkjhkc45154916

③ 求数据结构顺序表c语言实现.....

无函数版本，只需你写算法就OK，算是比较基础的··*顺序表的基本操作*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 10
#define LISTINCREMENT 3
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR -1
#define OVERFLOW -2
typedef int Status;
typedef int ElemType;
typedef struct {
int *elem;
int length;
int listsize;
}SqList;Status Initlist_Sq(SqList &L) /*初始化顺序表*/
{

}int Destroylist(SqList &L) /*销毁顺序表*/
{

}int Clearlist_Sq(SqList &L) /*清空顺序表*/
{

}
Status Listempty_Sq(SqList L) /*测试顺序表是否为空*/
{

}Status ListInsert_Sq(SqList &L, int i,ElemType e) /*在第i个位置上插入一个元素*/
{ }int LocateElem_Sq(SqList L,ElemType e) /*返回元素e在顺序表中的位置*/
{

}Status ListDelete_Sq(SqList &L, int i, int &e) /*删除第i个位置上的元素*/
{ }void Print_Sq(SqList L) /*输出顺序表*/
{ int i;
if (Listempty_Sq(L))
printf("\nSequential List's length is %d. It's empty!",L.length);
else
printf("\nSequential List's length is %d. These element are : ",L.length);
for(i=0;i<L.length;i++)
printf(" %d",L.elem[i]);
}
void menu()
{ printf("\n");
printf("\n* * * * * * * * * * * * * * * * * * * * * * * * * *\n");
printf(" 1 ------- Print the Sequential List(输出顺序表).\n");
printf(" 2 ------- Insert a data in the Sequential List(在第i个位置上插入一个元素).\n");
printf(" 3 ------- Delete a data in the Sequential List(删除第i个位置上的元素).\n");
printf(" 4 ------- Get a element's locationt in the SqList(返回元素e在顺序表中的位置).\n");
printf(" 5 ------- Clear the Sequential List(清空顺序表).\n");
printf(" 6 ------- Exit.\n");
printf("* * * * * * * * * * * * * * * * * * * * * * * * * *\n");
printf("\n");
}void menuselect(SqList L)
{ int k,i,done=1;
ElemType e;
while (done)
{ menu();
printf("Please choose: ");
scanf("%d",&k);
getchar();
switch(k)
{ case 1: Print_Sq(L); break;
case 2:{
printf("\nInput the location and data you want to Insert: ");
scanf("%d,%d",&i,&e);
if (ListInsert_Sq(L,i,e)==ERROR) printf("Insert location is not correct!\n");
break;
} case 3:{ printf("\nInput the location you want to delete data: ");
scanf("%d",&i);
if (ListDelete_Sq(L,i,e)==ERROR)
printf("Delete location is not exit!\n");
else
printf("\nDelete data is %d.",e);
break; }
case 4:{ printf("\nInput the data you want to find: ");
scanf("%d",&e);
if (LocateElem_Sq(L,e)!=FALSE)
printf("\nData %d location in the Sequential List is %d.", e,LocateElem_Sq(L,e));
else printf("\nData %d is not in the Sequential List.\n", e);
break; }
case 5: Clearlist_Sq(L);; break;
case 6: done=0;
}
}
}
void main()
{ ElemType e;
SqList La;
int n,i;
Initlist_Sq(La);
printf("Input a number of the element in the Sequential List (n<=%d):",LIST_INIT_SIZE);
scanf("%d",&n);
printf("Enter these elements:");
for(i=1;i<=n;i++)
{scanf("%d",&e);<br> ListInsert_Sq(La,i,e);}
menuselect(La);
getch();
}

④ 数据结构 用C语言实现顺序表的建立及遍历

#include<stdio.h>
#include<malloc.h>

typedefstructnlist
{
int*np;
intlen;//已使用地址个数
intmaxlen;//最大地址个数
}NLT;

NLT*createlist();//创建顺序表
intaddtolist(NLT*nlist);//向顺序表插入元素
voidpList(NLT*nlist);//遍历顺序表
intmain()
{
inti;
NLT*nlist=createlist();
if(nlist)
{
for(i=0;i<nlist->maxlen;i++)
addtolist(nlist);
pList(nlist);
}
return0;
}
voidpList(NLT*nlist)//遍历打印,空格分割，最后一个数后面没有空格
{
inti;
for(i=0;i<nlist->len-1;i++)
printf("%d",nlist->np[i]);
printf("%d",nlist->np[nlist->len-1]);
}
NLT*createlist()
{
NLT*nlist=NULL;
nlist=(NLT*)malloc(sizeof(NLT));
scanf("%d",&nlist->maxlen);
nlist->np=(int*)malloc(sizeof(int)*nlist->maxlen);
if(!nlist||!nlist->np)
{
printf("内存申请失败！ ");
returnNULL;
}
nlist->len=0;
returnnlist;
}
intaddtolist(NLT*nlist)
{
if(nlist->len<nlist->maxlen)//如果存储空间未满，保存元素,保存成功返回1失败返回0
{
scanf("%d",&nlist->np[nlist->len]);
nlist->len++;
return1;
}
else//这里可以写当存储满的之后，空间扩容，本题用不到所以我不写了
return0;
}

⑤ C语言数据结构实验

#include<stdio.h>
#include<stdlib.h>
typedef struct
{
int arr[100];
int last;

}SeqList;
void InitList(SeqList *L);
void IsEmpty(SeqList L);
int GetLength(SeqList L);
void DeletNum(SeqList * L,int num);
void GetEmpty(SeqList * L);
void PaiXu(SeqList * L);
int main()
{
int length,addr,num;
SeqList L,*p;
p=&L;

printf("创建表\n");
InitList(&L);//初始化
IsEmpty(L);//判断是否为空
printf("input the length\n");
scanf("%d",&length);
L.last=length-1;//数组最后下个数的下标
printf("输入表中的值\n");//输入表中的值
for(int i=0;i<=L.last;i++)
scanf("%d",&L.arr[i]);
length=GetLength(L);
printf("输入想输出的数在表中的位置(从1开始数)\n");//输出某个位序上的数据元素
scanf("%d",&addr);
if(addr>length)
printf("该位置不存在，超过了范围\n");
else
printf("第%d数为%d\n",addr,L.arr[addr-1]);

printf("输入想得到前驱后继的结点的值\n");//输出某元素的前驱后继
scanf("%d",&num);
for(i=0;i<=L.last;i++)
{
if(L.arr[i]==num)
{
printf("找到该结点，结点的位置为第%d数\n",i+1);
if((i+1)==length)
printf("该结点无后继\n");
else
printf("结点后继为%d\n",L.arr[i+1]);

if((i-1)<0)
printf("该结点无前驱\n");
else
printf("结点前驱为%d\n",L.arr[i-1]);

break;
}
}
if(i==length)
printf("表中无此数\n");
//将奇偶排序
PaiXu(&L);

printf("输入想要删除的数\n");
scanf("%d",&num);
DeletNum(p,num);//删除该数
GetLength(L);//删除后的表长

GetEmpty(&L);//置空
IsEmpty(L);//判断是否为空

return 0;
}

void InitList(SeqList * L)
{
L->last=-1;
}
void IsEmpty(SeqList L)
{
if(L.last>=0)
printf("该表不为空\n");
else
printf("该表为空\n");
}
int GetLength(SeqList L)
{
printf("该表的长度为%d\n",L.last+1);
return L.last+1;
}
void DeletNum(SeqList * L,int num)
{
int i,k;
for(i=0;i<=L->last;i++)
{
if(L->arr[i]==num)
{
k=i;
break;
}
}
if(i==L->last+1)
printf("表中无此数\n");
for(i=k;i<L->last;i++)//删除该数后，后面的数向前移
L->arr[i]=L->arr[i+1];
L->last--;//表长减一
for(i=0;i<=L->last;i++)
printf("%d ",L->arr[i]);

}

void GetEmpty(SeqList * L)
{

L->last=-1;
}

void PaiXu(SeqList * L)
{
int i,j,t;
i=0;
j=L->last;

while(i<j)
{
while(L->arr[i]%2!=0)
i++;
while(L->arr[j]%2==0)
j--;
if(i<j)
{
t=L->arr[i];
L->arr[i]=L->arr[j];
L->arr[j]=t;
}

}
printf("奇偶排序后\n");
for(i=0;i<=L->last;i++)
printf("%d ",L->arr[i]);
}

⑥ 数据结构 c语言版 ——顺序表的查找、插入与删除

#include<stdio.h>
#include<stdlib.h>
#define N 10 //顺序表的最大容量
int length=0; //顺序表的当前元素个数

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100//线性表存储的空间初始化分配量
#define LISTINCREAMENT 10 //线性表存储空间的分配增量

typedef struct LNode//线性单链表存储结构
{
int data;
struct LNode *next;
}LNode,*LinkList;

int CreatList_L(LinkList&L)//创建一个线性链表
{
L=(LinkList)malloc(sizeof(LNode));//分配一个空间给链表，作为头结点

if(!L) exit(OVERFLOW);
L->next=NULL;
return OK;
}
int DestroyList_L(LinkList &L)//销毁链表
{
if(L) free(L);
return OK;
}
int ListInsert_L(LinkList&L,int i,int e)//再练表的第i个元素前插入一个元素e
{
LinkList p=L;//p指针定位于i-1
LNode *s;
int j=0;
while(p&&j<i-1) {p=p->next;j++;}//定位
if(!p||j>i-1) return ERROR;//如果i<1或大于链表元素个数+1
s=(LNode*)malloc(sizeof(LNode));
if(!s) exit(OVERFLOW);
s->data=e; //完成插入操作
s->next=p->next;
p->next=s;
return OK;
}

int ListDelet_L(LinkList&L,int i,int&e)//删除链表L中的第i个元素，并返回给e;
{
LinkList p=L;
LNode* q;
int j=0;
while(!p&&j<i-1) {p=p->next;j++;}//p指针定位于i-1；
if(!p->next||j>i-1) return ERROR;

e=p->next->data; //完成删除操作
q=p->next;
p->next=p->next->next;
free(q);
return OK;

}

int ListTraverse_L(LinkList L,int n)//链表的遍历
{
int i=0;
if(!L)return ERROR;
L=L->next;
while(L)
{
if(L->data==n)return i;
L=L->next;
i++;
}

return FALSE;
}

int InverseSingleList_L(LinkList &L)
{
if(!L->next||!L->next->next)//如果链表少于2个Node那么链表不需要改变顺序
return OK;
LNode *p,*q;
p=L->next; //第一次因为p是最后一个连接所以把p->next设为空
q=p->next;
p->next=NULL;
p=q;
while(p)
{
q=p->next; //用q去保留p后面一个Node;
p->next=L->next;
L->next=p;
p=q;
}
return OK;
}

int main()
{
int List[N];
LinkList L;

int ch,exit='N';
do
{
system("CLS");
printf("\t\t********************************************\n");
printf("\t\t* 1.创建一个顺序表 .........(1) *\n");
printf("\t\t* 2.在顺序表中查找元表.........(2) *\n");
printf("\t\t* 3.在顺序表中插入元表.........(3) *\n");
printf("\t\t* 4.在顺序表中删除元表.........(4) *\n");
printf("\t\t* 5.退出 .........(5) *\n");
printf("\t\t********************************************\n");
printf("\n请选择操作代码：");
ch=getchar();

switch(ch)
{
case '1':
printf("\n请输入十个元素");
CreatList_L(L);
for(length=0;length<N;length++)
{
scanf("%d",&List[length]);
getchar();
ListInsert_L(L,length+1,List[length]);
}
printf("\n创建成功！");
getchar();
break;
case '2':
scanf("%d",&List[0]);
if(ListTraverse_L(L,List[0]))printf("该元素存在该年表的第%d个位置",ListTraverse_L(L,List[0]));
else printf("不存在该元素");
getchar();
break;
case '3':
scanf("%d%d",&length,&List[0]);
ListInsert_L(L,length,List[0]);
system("pause");
break;
case '4':
scanf("%d",&length);
ListDelet_L(L,length,List[0]);
system("pause");
break;
case '5':
printf("\n您是否真的要退出程序(Y/N):");
getchar();
exit=getchar();
break;
default:
getchar();
printf("\n无效输入，请重新选择...:");
getchar();
break;

}

}while(exit!='y'&&exit!='Y');

}

⑦ 基于C语言的数据结构，怎样做顺序表插入

1、顺序表的插入，常用方法就是从插入点后平移数据。
2、例如：
void InsertSeqList(SeqList L, DataType x, int i)
{ //将元素x插入到顺序表L的第i个数据元素之前
if(L.length==Maxsize) exit("表已满");
if(i<1||i>L.length+1) exit("位置错");
for (j=L.lenght; j>=i;j--)
L.data[j]=L.data[j-1]; //平移插入点之后的数据
L.data[i-1]=x; //在插入点插入数据
L.length++;
}
L.data[j]=L.data[j-1];的意思是把要插入的位置后的数据都依次往后面移动一位，比如要插入在第6个位置上，共8个数据的链表里，先把第8个数据复制到第9个位置上，在把第7个数据复制到第8个位置上，在把第6个数据复制到第7个位置上。这样第6个位置后就可以写入，覆盖掉以前的值就好了。这样做的意思是腾出可以插入的地方而不破坏数据的顺序排放。

⑧ 数据结构（C语言描述） 线性表实验

#include<stdio.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct{
int * elem;
int length;
int listsize;
}SqList;
//SqList sq;
void InitList_Sq(SqList *sq) //初始化列表
{
sq->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
sq->length=0;
sq->listsize=LIST_INIT_SIZE;
printf("---申请空间成功---!\n");
}
void GetElem(SqList *sq,int i)//获取第i位置元素的值
{
int *p;
p=&(sq->elem[i-1]);
printf("%d",*p);
printf("\n");
}
int ListInsert_Sq(SqList *sq,int i,int a)//在i位置之前插入a
{
int *p,*q;
if(i<=0||i>sq->length+1)
{
printf("---位置不合法---!\n");
return 0;
}
if(sq->length>=sq->listsize)
{
int* newbase=(int *)realloc(sq->elem,(sq->listsize+LISTINCREMENT)*sizeof(int));
if(!newbase)
{
printf("申请空间溢出\n");
return 0;
}
sq->elem=newbase;
sq->listsize+=LISTINCREMENT;
}
p=&(sq->elem[i-1]);//p指向第i位置的元素
q=&(sq->elem[sq->length-1]);//q指向最后一个元素
for(;q>=p;--q) *(q+1)=*q;
*p=a;
++sq->length;
return 1;
}
int ListDelete_Sq(SqList *sq,int i) //删除i位置上的值
{
int *p,*q;
if(i<1||i>sq->length) return 0;
p=&(sq->elem[i-1]);//p指向第i位置的元素
q=sq->elem+sq->length-1;//q指向最后一个元素
for(++p;p<=q;++p)
{
*(p-1)=*p;
}
--sq->length;
return 1;
}
void visit(SqList *sq)//输出数据
{
int i=1;
for(;i<=sq->length;i++)
{
int *p;
p=&sq->elem[i-1];
printf("%d",*p);
printf(" ");
}
}
void main()
{
int i=1,a=0,boo=1,number=0;
SqList s,*sq;
sq=&s;
InitList_Sq(sq);
printf("初始化空表\n");
printf("输入数据个数：\n");
scanf("%d",&number);
printf("输入%d个数据：",number);
printf("\n");
for(;i<=number;i++)
{
scanf("%d",&a);
if(boo=ListInsert_Sq(sq,i,a))
{
printf("---插入成功！---\n");
}
else
{
printf("---插入不成功,重新插入---！\n");
i=i-1;
}
}
printf("输出所有元素\n");
visit(sq);
printf("\n");
printf("输出删除的位置:");
scanf("%d",&a);
if(boo=ListDelete_Sq(sq,a))
{
printf("---数据删除成功！---\n");
}else
{
printf("---没有删除成功---\n");
}
printf("输出所有元素:\n");
visit(sq);
printf("\n");
printf("输出要显示数据的位置：");
scanf("%d",&a);
printf("输出%d位置数值\n",a);
if(a<0||a>sq->length)
{
printf("---输出位置的数据不存在---\n");
}
else
{
GetElem(sq,a);
}

}
以上是可直接运行的源程序
运行结果：
---申请空间成功---!
初始化空表
输入数据个数：
3
输入1个数据：3
---插入成功！---
输入2个数据;8
---插入成功！---
输入3个数据:5
---插入成功！---
输出所有元素:3 5 8
输出删除的位置:2
---数据删除成功！---
输出所有元素；3 8
输出要显示数据的位置：2
"输出2位置数值:8

⑨ 数据结构c语言版 创建一个顺序表

http://blog.csdn.net/xuhang0910/article/details/48488881
线性表顺序存储基础

⑩ 数据结构C语言——顺序表的应用实例

第一个程序有两个错误:
错误一:
SeqList *L;
init_SeqList(L);
应改成:
SeqList s;
SeqList *L = &s;
init_SeqList(L);
错误原因:指针只有在初始化(即只有在指向具体对象)之后才可以参与运算，你只定义了一个指针，并未将指针指向具体的对象，当执行到init_SeqList(L); 这句时，会产生越界报错。

错误二:
printf("%d\t%s\n",L->elem[1].data,L->elem[1].n);
这个语句打印出来的永远是第一个元素，而不是删除的元素，应改成:
printf("%d\t%s\n",L->elem[i].data,L->elem[i].n); //其中i为被删除元素的下标

提示:
给数组赋值时，循环最好从i=0开始，for(i=1;i<=2;i++)你从i=1开始，实际上是将值赋给了数组的第二个元素。