‘壹’ c语言——线性表
#include"stdio.h"
#include<malloc.h>
typedef char ElemType;
typedef struct LNode
{ElemType data;
struct LNode *next;
}LinkList;
void CreatListF(LinkList *&L,ElemType a[],int n) //头插法建表
{
LinkList *s;int i;
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;
}
}
void CreateListR(LinkList *&L,ElemType a[],int n) //尾插法建表
{
LinkList *s,*r;int i;
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;
}
void InitList(LinkList *&L) //初始化线性表
{
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}
void DestroyList(LinkList *&L) //销毁线性表
{
LinkList *p=L,*q=p->next;
while(q!=NULL)
{
free(p);
p=q;
q=p->next;
}
free(p);
}
int ListEmpty(LinkList *L) //判断线性表是否为空
{
return(L->next==NULL);
}
int ListLength(LinkList *L) //求线性表的长度
{
LinkList *p=L;int n=0;
while(p->next!=NULL)
{
n++;p=p->next;
}
return(n);
}
void DispList(LinkList *L) //输出线性表
{
LinkList *p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
}
int GetElem(LinkList *L,int i,ElemType &e) //求线性表中某个数据元素值
{
int j=0;
LinkList *p=L;
while(j<i&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return 0;
else
{
e=p->data;return 1;
}
}
int LocateElem(LinkList *L,ElemType e) //按元素值查找
{
LinkList *p=L->next;
int i=1;
while(p!=NULL&&p->data!=e)
{
p=p->next;i++;
}
if(p==NULL)return(0);
else return(i);
}
int ListInsert(LinkList *&L,int i,ElemType e) //插入数据元素
{
int j=0;
LinkList *p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)return 0;
else
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=e; s->next=p->next; p->next=s;
return 1;
}
}
int ListDelete(LinkList *&L,int i,ElemType &e) //删除数据元素
{
int j=0;
LinkList *p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return 0;
else
{
q=p->next;
if(q==NULL)return 0;
e=q->data;
p->next=q->next;
free(q);
return 1;
}
}
int main()
{
ElemType e,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("\n"); //输出顺序表h
printf("该单链表的长度为：");
printf("%d",ListLength(h)); printf("\n"); //输出顺序表h的长度
if(ListEmpty(h)) printf("该单链表为空。\n");
else printf("该单链表不为空。\n"); //判断顺序表h是否为空
GetElem(h,3,e);printf("该单链表的第3个元素为：");
printf("%c",e); printf("\n"); //输出顺序表h的第3个元素
printf("该单链表中a的位置为：");
printf("%d",LocateElem(h,'a')); printf("\n"); //输出元素'a'的位置
ListInsert(h,4,'f'); //在第4个元素位置插入'f'素
printf("在第4 个元素位置上插入'f'后单链表为：");
DispList(h); printf("\n"); //输出顺序表h
ListDelete(h,3,e); //删除L的第3个元素
printf("删除第3个元素后单链表为：");
DispList(h); printf("\n"); //输出顺序表h
DestroyList(h); //释放顺序表h
return 0;
}
‘贰’ 一个c语言数据结构线性表的问题，编译没错，运行结果有问题
printf_SqList(SqList *L)里面，if(i=9)错了，改成i==9
#include<stdio.h>
#defineMAXSIZE100
typedefintElemType;
typedefstruct{
ElemTypedata[MAXSIZE];
intlength;
}SqList;
voidReverse_SqList(SqList*L){
intn=L->length;
if(n==0||n==1)return;
inti=0,j=n-1;
ElemTypetemp;
while(i<j){
temp=L->data[i];
L->data[i]=L->data[j];
L->data[j]=temp;
i++;
j--;
}
}
voidcreat_SqList(SqList*L,intn){
inti;
L->length=n;
for(i=0;i<n;i++){
printf("inputaintnum ");
scanf("%d",&L->data[i]);
}
}
voidprintf_SqList(SqList*L){
intn,i;
n=L->length;
for(i=0;i<n;i++){
if(i==9){
printf(" ");
}
printf("%d",L->data[i]);
}
}
voidmain(){
SqListL;
intn;
printf("intputn: ");
scanf("%d",&n);
printf_SqList(&L);
Reverse_SqList(&L);
printf_SqList(&L);
}
‘叁’ 谁能给一个简单的线性表操作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语言
#define MAXSIZE 100 //表中元素的最大个数
typedef int ElemType；//元素类型
typedef struct list{
ElemType elem[MAXSIZE];//静态线性表
int length; //表的实际长度
}SqList;//顺序表的类型名
‘伍’ 线性表的基本操作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 <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语言）
//---------------------------------------------------------------------------
#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语言编写线性表
/*
1.输入2.修改3.查找4.删除。
*/
#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语言编写线性表相关的要求可以WINTC运行出来
#include
<stdio.h>
#include<stdlib.h>
#define
MAX
5
typedef
int
datatype;
typedef
struct
List
{
datatype
elem[MAX];
int
Last;
}*SeqList;SeqList
InitList()
{
SeqList
L;
L=(SeqList)malloc(sizeof(struct
List));
L->Last=-1;
return
L;
}
void
CreateList(SeqList
L)
{
int
n,i;
printf("请输入你要创建的顺序表元素个数n=");
scanf("%d",&n);
printf("请输入你要创建的顺序表::");
for(i=0;i<n;i++)
{
scanf("%d",L->elem[i]);
L->Last++;
}
}
int
Location(SeqList
L,datatype
x)
{
int
i=0;
while(L->elem[i]!=x&&i<=L->Last)
{
i++;
}
if(i>L->Last)
return
-1;
else
return
i;
}
void
Insertelem(SeqList
L,datatype
m)
{
int
n,i;
printf("请输入你要插入的位置");n=scanf("%d",&n);
if((L->Last+1)>MAX)
printf("表以满,不能插入\n");
else
{
L->Last++;
for(i=L->Last;i>=n-1;i--)
{
L->elem[i+1]=L->elem[i];
}
L->elem[n-1]=m;
}
}
void
Deleteelem(SeqList
L,datatype
m)
{
int
i,j;
i=Location(L,m);
while(i==-1)
{
datatype
n;
printf("你所查找的元素不在表中,请重新输入你要删除的元素\n");
scanf("%d",&n);
i=Location(L,n);
}
for(j=i;j<=L->Last;j++)
{
L->elem[i]=L->elem[i+1];
}
L->Last--;
}
void
ShowList(SeqList
L)
{
int
i;
printf("当前顺序表元素为::");
for(i=0;i<=L->Last;i++)
{
printf("%d
",L->elem);
}
printf("\n");
}
void
main()
{
int
tp;
SeqList
L;
L=InitList();
CreateList(L);
printf("输入操作(1)为删除某元素(2)为插入(3)为查找(4)为输出当前顺序表(5)为退出");
while(tp!=5)
{
scanf("%d",&tp);
if(tp==1)
{
int
n;
printf("请输入你要删除的元素n=");
scanf("%d",&n);
Deleteelem(L,n);
}
if(tp==2)
{
int
n;
printf("请输入你要插入的元素n=");
scanf("%d",&n);
Insertelem(L,n);
}
if(tp==3)
{
datatype
x;
printf("请输入你要查找的元素x=");
scanf("%d",&x);
printf("´此元素在顺序表中的位置为:\n",Location(L,x)+1);
}
if(tp==4)
{
ShowList(L);
}
if(tp==5)
{
break;
}
}
}
复制的话
有些地方中文是乱码
很好搞的，，，~~~~~~~~~~~~~~
‘拾’ 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);
}
}
这个是我最近编写的 顺序表也是线性表的
这里还有链表的程序 用的话再传给你