编译一个程序来构建一个线性表

1. 一个线性表的编程

//花了一个晚上和这个中午的时间，终于做好了，可以再VC 6.0里正确运行，基本可以到达你的要求，代码：#include<iostream.h>
typedef int datatype; //线性表结点的数据类型，假设是 int
const int maxsize=100; //线性表可能的最大长度，这里假设是 100；
typedef struct{
datatype data[maxsize+1]; // 定义线性表的数据
int n; //线性表的长度
}sqlist;//建表
sqlist* creat()
{
datatype x;
int i=1;
sqlist *L;
L=new sqlist;
while(cin>>x,x!=0)
{
L->data[i]=x;
i++;
}
L->n=i-1;
L->data[0]=L->n;
return L;
}//插入函数
int insert(sqlist *L,datatype x,int i) { //将 x 插入到顺序表 L得到第 i 个位置
int j;
if(L->n==maxsize) { cout<<"表满，不能插入!(上溢)\n"; return -1; }
if(i<1 || i>L->n+1) {cout<<"非法插入位置!\n"; return 0; }
L->n++;
for(j=L->n;j>i;j--)
L->data[j]=L->data[j-1]; //结点后移
L->data[i]=x;
return 1;
}//删除函数
int deletex(sqlist *L,datatype x) {
if(L->n==0) { cout<<"表空，不能删除!(下溢)\n"; return 0;}
for(int j=1;j<=L->n;j++)
if(L->data[j]==x) //查找 匹配值 x
for(;j<=L->n;j++)
L->data[j]=L->data[j+1]; //结点前移
L->n--;
return 1;
}

//显示顺序表
void disp(sqlist *L)
{
cout<<"顺序表的表长为 "<<L->n<<"\n 数据:\n";
for(int i=1;i<=L->n;i++)
cout<<"序号: "<<i<<" 数据: "<<L->data[i]<<endl;
}
void main()
{
sqlist *L=NULL;
datatype x;
int ch,i;
XX: while(1)
{
cout<<" 主菜单 \n "
<<" 0.退出\n "
<<" 1.建立顺序表\n "
<<" 2.插入数据\n "
<<" 3.删除数据\n "
<<" 4.显示顺序表\n ";
cin>>ch;
switch(ch)
{
case 0:
delete(L); //退出程序，撤销顺序表
return;
break;
case 1:
cout<<"请输入顺序表的数据(输入 0 退出!)"<<endl;
L=creat();
cout<<"顺序表已建成!\n";
break;
case 2:
cout<<"请输入您要插入的值\n";
cin>>x;
cout<<"插入的位置:\n";
cin>>i;
if( insert(L,x,i)==1 ) cout<<"插入成功!"<<endl;
else cout<<"插入失败! "<<endl;
break;
case 3:
cout<<"请输入您要删除的值\n";
cin>>x;
if(deletex(L,x)==1) cout<<"成功删除数据 "<<x<<endl;
else cout<<"该顺序表没有数据 "<<x<<endl;
break;
case 4:
disp(L);
break;
default:
cout<<" 输入非法! 请输入 0~4选项!"<<endl;
goto XX;

}
}
}
//如果，还有什么问题，欢迎追问！.^_^.

2. 作业要求： 用c语言编写一个完整的程序，功能如下： 1，创建一个线性表，采用顺序存储的方式，键盘输入初

#include <stdio.h>
#include <malloc.h>
#define NULL 0
struct link{
int num;
struct link *next;
};

struct link *creat(void)
{struct link *p1,*p2,*head;
p1=(struct link *)malloc(sizeof(struct link));
scanf("%d",&p1->num);
head=p1;
while(p1->num!=0)//这里一定要以数字0结束，而不能设置成#，因为num是整型。
{
p2=(struct link *)malloc(sizeof(struct link));
scanf("%d",&p2->num);
p1->next=p2;
p1=p2;
}
p1->next=NULL;
return head;
}

void print(struct link *head)
{struct link *p;
printf("\n结果是：\n");
p=head;
//这里不能加p=p->next;因为 p=head;已经是相当是p==head了，不能用谁指向谁来理解
while(p!=NULL)
{
printf("%d",p->num);
printf("\n");
p=p->next;
}
}

struct link *delet(struct link *head,int i)//有问题
{
struct link *p,*q;
int j=0;
p=head;

if(i==1)
{
p=p->next;
head=p;

}
else
{
while(p->next && j<(i-2))
{
p=p->next;
++j;
}
if(!(p->next) || j>i-2)
printf("删除位置不合理");
q=p->next;
p->next=q->next;
free(q);
}

return head;
}

void main()
{
struct link *head1,*head2;
int i;
head1=creat();
print(head1);
printf("\n你要删除第几个数据：\n");
scanf("%d",&i);
head2=delet(head1,i);/*这里一定要用head2与前面的head1区分对待，否则如果如果链表并无改变
而仅仅是头指针指向了第二个结点，那么实际上也是从第一个结点开始输出*/
printf("\n删除后的结果是：\n");
print(head2);
}

3. 求构建一个线性表的完整程序 数据结构C语言版

#include "stdafx.h"
#define maxSize 100
typedef int elemType;
#include <stdio.h>
#include <stdlib.h>
typedef int elemType;
struct SeqList {
elemType *list;
int size;
int LmaxSize;
};

/* 初始化线性表L，即进行动态存储空间分配并置L为一个空表 */
void initList(struct SeqList *L, int ms)
{
/* 检查ms是否有效，若无效的则退出运行 */
if(ms <= 0){
printf("MaxSize非法！");
exit(1); /* 执行此函数中止程序运行，此函数在stdlib.h中有定义 */
}
L->LmaxSize = ms; /* 设置线性表空间大小为ms */
L->size = 0;
L->list = (int *)malloc(ms * sizeof(elemType));
if(!L->list){
printf("空间分配失败！");
exit(1);
}
return;
}

/* 空间扩展为原来的2倍，并由p指针所指向，原内容被自动拷贝到p所指向的存储空间 */
void againMalloc(struct SeqList *L)
{
elemType *p = (int *)realloc(L->list, 2 * L->LmaxSize * sizeof(elemType));
if(!p){ /* 分配失败则退出运行 */
printf("存储空间分配失败！ ");
exit(1);
}
L->list = p; /* 使list指向新线性表空间 */
L->LmaxSize = 2 * L->LmaxSize; /* 把线性表空间大小修改为新的长度 */
}

/* 清除线性表L中的所有元素，释放存储空间，使之成为一个空表 */
void clearList(struct SeqList *L)
{
if(L->list != NULL){
free(L->list);
L->list = NULL;
L->size = L->LmaxSize = 0;
}
return;
}
/* 返回线性表L当前的长度，若L为空则返回0 */
int sizeList(struct SeqList *L)
{
return L->size;
}

/* 判断线性表L是否为空，若为空则返回1, 否则返回0 */
int emptyList(struct SeqList *L)
{
if(L->size ==0){
return 1;
}
else{
return 0 ;
}
}

/* 返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行 */
elemType getElem(struct SeqList *L, int pos)
{
if(pos < 1 || pos > L->size){ /* 若pos越界则退出运行 */
printf("元素序号越界！");
exit(1);
}
return L->list[pos - 1]; /* 返回线性表中序号为pos值的元素值 */
}

/* 顺序扫描（即遍历）输出线性表L中的每个元素 */
void traverseList(struct SeqList *L)
{
int i;
for(i = 0; i < L->size; i++){
printf("%d ", L ->list[i]);
printf(" ");
}
return;
}

/* 从线性表L中查找值与x相等的元素，若查找成功则返回其位置，否则返回-1 */
int search(struct SeqList *L, elemType x)
{
int i;
for(i = 0; i < L->size; i++){
if(L->list[i] == x){
return i;
}
}
return -1;
}
/* 把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0 */
int updatePosList(struct SeqList *L, int pos, elemType x)
{
if(pos < 1 || pos > L->size){ /* 若pos越界则修改失败 */
return 0;
}
L->list[pos - 1] = x;
return 1;
}

/* 向线性表L的表头插入元素x */
void inserFirstList(struct SeqList *L, elemType x)
{
int i;
if(L->size== L->LmaxSize){ /* 重新分配更大的存储空间 */
againMalloc(L);
}
for(i = L->size - 1; i >= 0; i--)/*元素后移*/
L->list[i + 1] = L ->list[i];
L->list[0] = x;
L->size ++;
}

/* 向线性表L的表尾插入元素x */
void insertLastList(struct SeqList *L, elemType x)
{
if(L->size == L ->LmaxSize){ /* 重新分配更大的存储空间 */
againMalloc(L);
}
L->list[L->size] = x; /* 把x插入到表尾 */
L->size++; /* 线性表的长度增加1 */
return;
}

/* 向线性表L中第pos个元素位置插入元素x，若插入成功返回1，否则返回0 */
int insertPosList(struct SeqList *L, int pos, elemType x)
{
int i;
if(pos < 1 || pos > L->size + 1){ /* 若pos越界则插入失败 */
return 0;
}
if(L->size == L->LmaxSize){ /* 重新分配更大的存储空间 */
againMalloc(L);
}
for(i = L->size - 1; i >= pos - 1; i--){
L->list[i + 1] = L->list[i];
}
L->list[pos - 1] = x;
L->size++;
return 1;
}

/* 向有序线性表L中插入元素x,使得插入后仍然有序*/
void insertOrderList(struct SeqList *L, elemType x)
{
int i, j;
/* 若数组空间用完则重新分配更大的存储空间 */
if(L->size == L->LmaxSize){
againMalloc(L);
}
/* 顺序查找出x的插入位置 */
for(i = 0; i < L->size; i++){
if(x < L->list[i]){
break;
}
}
/* 从表尾到下标i元素依次后移一个位置， 把i的位置空出来 */
for(j = L->size - 1; j >= i; j--)
L->list[j+1] = L->list[j];
/* 把x值赋给下标为i的元素 */
L->list[i] = x;
/* 线性表长度增加1 */
L->size++;
return;
}
/* 从线性表L中删除表头元素并返回它，若删除失败则停止程序运行 */
elemType deleteFirstList(struct SeqList *L)
{
elemType temp;
int i;
if(L ->size == 0){
printf("线性表为空，不能进行删除操作！ ");
exit(1);
}
temp = L->list[0];
for(i = 1; i < L->size; i++) /* 元素前移 */
L->list[i-1] = L->list[i];
L->size--;
return temp;
}

/* 从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行 */
elemType deleteLastList(struct SeqList *L)
{
if(L ->size == 0){
printf("线性表为空，不能进行删除操作！ ");
exit(1);
}
L->size--;
return L ->list[L->size]; /* 返回原来表尾元素的值 */
}

/* 从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行 */
elemType deletePosList(struct SeqList *L, int pos)
{
elemType temp;
int i;
if(pos < 1 || pos > L->size){ /* pos越界则删除失败 */
printf("pos值越界，不能进行删除操作！ ");
exit(1);
}
temp = L->list[pos-1];
for(i = pos; i < L->size; i++)
L->list[i-1] = L->list[i];
L->size--;
return temp;
}

/* 从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0 */
int deleteValueList(struct SeqList *L, elemType x)
{
int i, j;
/* 从线性表中顺序查找出值为x的第一个元素 */
for(i = 0; i < L->size; i++){
if(L->list[i] == x){
break;
}
}
/* 若查找失败，表明不存在值为x的元素，返回0 */
if(i == L->size){
return 0;
}
/* 删除值为x的元素L->list[i] */
for(j = i + 1; j < L->size; j++){
L->list[j-1] = L->list[j];
}
L->size--;
return 1;
}

int main(int argc, char* argv[])
{

struct SeqList * ListPerson;
int Listsize=10;
int i;
int num;

ListPerson=(SeqList*)malloc(sizeof(SeqList)); //这句话很重要
initList(ListPerson,Listsize);

for (i=0;i<10;i++)
{
inserFirstList(ListPerson, i);
}

for (i=0;i<5;i++)
{
inserFirstList(ListPerson, i);
}

num=sizeList(ListPerson);

for (i=0;i<num;i++)
{
printf(" %d ", ListPerson->list[i]);
}

printf("\n");
insertPosList(ListPerson, 5, 100);

num=sizeList(ListPerson);

for (i=0;i<num;i++)
{
printf(" %d ", ListPerson->list[i]);
}

return 0;

}

4. 用C语言编写程序实现线性表的顺序存储结构并实现以下功能： 1. 输入一组整数构造线性表；

比如你要在第i个元素之后插入，就把i+1直到最后一个元素依次向后移动一位，再把你要放的元素放到第i+1位置即可

5. 求一个c++的建立线性表最简单的程序，要能运行的

#include<malloc.h> // malloc()等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()

// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int ElemType;

#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量
#define LISTINCREMENT 2 // 线性表存储空间的分配增量

线中间就是线性表的定义和函数。

————————————————————————————————————
struct SqList
{
ElemType *elem; // 存储空间基址
int length; // 当前长度
int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)
};

Status InitList(SqList &L) // 算法2.3
{ // 操作结果：构造一个空的顺序线性表
L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if (!L.elem)
exit(OVERFLOW); // 存储分配失败
L.length = 0; // 空表长度为0
L.listsize = LIST_INIT_SIZE; // 初始存储容量
return OK;
}

Status DestroyList(SqList &L)
{ // 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L
free(L.elem);
L.elem = NULL;
L.length = 0;
L.listsize = 0;
return OK;
}

Status ClearList(SqList &L)
{ // 初始条件：顺序线性表L已存在。操作结果：将L重置为空表
L.length = 0;
return OK;
}

Status ListEmpty(SqList L)
{ // 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
if (L.length == 0)
return TRUE;
else
return FALSE;
}

int ListLength(SqList L)
{ // 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数
return L.length;
}

Status GetElem(SqList L, int i, ElemType &e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：用e返回L中第i个数据元素的值
if (i<1 || i>L.length)
exit(ERROR);
e = *(L.elem + i - 1);
return OK;
}

int LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{ // 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0)
// 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
// 若这样的数据元素不存在，则返回值为0。算法2.6
ElemType *p;
int i = 1; // i的初值为第1个元素的位序
p = L.elem; // p的初值为第1个元素的存储位置
while (i <= L.length&&!compare(*p++, e))
++i;
if (i <= L.length)
return i;
else
return 0;
}

Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e)
{ // 初始条件：顺序线性表L已存在
// 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
// 否则操作失败，pre_e无定义
int i = 2;
ElemType *p = L.elem + 1;
while (i <= L.length&&*p != cur_e)
{
p++;
i++;
}
if (i>L.length)
return INFEASIBLE;
else
{
pre_e = *--p;
return OK;
}
}

Status NextElem(SqList L, ElemType cur_e, ElemType &next_e)
{ // 初始条件：顺序线性表L已存在
// 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
// 否则操作失败，next_e无定义
int i = 1;
ElemType *p = L.elem;
while (i<L.length&&*p != cur_e)
{
i++;
p++;
}
if (i == L.length)
return INFEASIBLE;
else
{
next_e = *++p;
return OK;
}
}

Status ListInsert(SqList &L, int i, ElemType e) // 算法2.4
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
ElemType *newbase, *q, *p;
if (i<1 || i>L.length + 1) // i值不合法
return ERROR;
if (L.length >= L.listsize) // 当前存储空间已满,增加分配
{
if (!(newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(ElemType))))
exit(OVERFLOW); // 存储分配失败
L.elem = newbase; // 新基址
L.listsize += LISTINCREMENT; // 增加存储容量
}
q = L.elem + i - 1; // q为插入位置
for (p = L.elem + L.length - 1; p >= q; --p) // 插入位置及之后的元素右移
*(p + 1) = *p;
*q = e; // 插入e
++L.length; // 表长增1
return OK;
}

Status ListDelete(SqList &L, int i, ElemType &e) // 算法2.5
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
ElemType *p, *q;
if (i<1 || i>L.length) // i值不合法
return ERROR;
p = L.elem + i - 1; // p为被删除元素的位置
e = *p; // 被删除元素的值赋给e
q = L.elem + L.length - 1; // 表尾元素的位置
for (++p; p <= q; ++p) // 被删除元素之后的元素左移
*(p - 1) = *p;
L.length--; // 表长减1
return OK;
}

Status ListTraverse(SqList L, void(*vi)(ElemType&))
{ // 初始条件：顺序线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败
// vi()的形参加'&'，表明可通过调用vi()改变元素的值
ElemType *p;
int i;
p = L.elem;
for (i = 1; i <= L.length; i++)
vi(*p++);
printf("\n");
return OK;
}
————————————————————————————————————

void print(ElemType &c)
{
printf("%d ", c);
}

void main()
{
SqList La;
int j;
InitList(La);
for (j = 1; j <= 5; j++) // 在表La中插入5个元素
ListInsert(La, j, j);
printf("La= "); // 输出表La的内容
ListTraverse(La, print);
}

6. 如何用c++建立一个线性表

用c++建立一个线性表有以下5步：

1、准备数据：

7. 怎么构造一个空的线性表

构造一个空的线性表，就是对SqList线性表类型的三个分量elem、listsize和length赋初值的过程。

1.操作步骤（1）申请一片连续的存储空间，并把其地址空间赋给elem指针变量。

（2）开始时length的初值为0。

（2）对listsize赋初值，其值是申请函数申请空间的最大容量。

2）构造空线性表的算法2）把构造空线性表的算法改成程序算法与程序不同，为帮助初学者理解两者的区别，把算法2.1转化成程序的操作步骤如下：

（1）添加C程序用的头文件和宏定义：（2）线性表类型定义：（2）构造空线性表的函数定义。

为了便于对线性表以后的操作，L可被定义成全局变量，若把算法2.1改成程序，需要增加对线性表赋值和输出的语句。（4）记住一定要加主函数：

图1算法2.1

8. 用c语言编写程序1.建立一个线性表，输入n个元素并输出2.查找最大元素并输出

线性表 可以使用链表 或者数组实现

以动态数组为例

#include<stdio.h>
#include<stdlib.h>
intmain()
{
int*a,n,max,i;
scanf("%d",&n);
a=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
scanf("%d",a+i);
for(i=1,max=a[0];i<n;i++)
if(max<a[i])max=a[i];
printf("%d
",max);
free(a);
return0;
}