c语言空表顺序

‘壹’ 在c语言中，如何构造一个空的顺序线性表,然后怎么用

#include<stdio.h>
#define MAXSIZE 100
struct List
{
int L[MAXSIZE];
int top;
};
int Init()//橘芦top指针初始化为0
{
int top;
top=0;
return top;
}
void Input(struct List *t,int p,int n)//输入n个数据
{
if(n==0||n>=MAXSIZE)printf("空队列\n");
else
for(p=0;p<n;p++)
scanf("%d",&t->L[p]);
}
void Output(struct List *s,int i,int m)//闭租输出m(=n)个数据哈
{

if(m==0||m>圆态带=MAXSIZE)printf("无法输出\n");
else
for(i=0;i<m;i++)
printf("%d ",s->L[i]);
}
void main()
{
struct List r;
int n,m;
scanf("%d",&n);
m=Init();
Input(&r,m,n);
Output(&r,0,n);
}

‘贰’ 如何用C语言建立空顺序表，只要一个空表，求大神给串完整的代码，能运行的，谢谢

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

constintMAXSIZE=档岩漏20;//表长
typedefintDataType;

typedefstructlist{
	DataTypedata[MAXSIZE];
	intsize;
}SqList;

intmain(){
	SqListaL;//声明一个表
	inti,j,flag;
	DataTypex;
	memset(aL.data,0,MAXSIZE);//表元素清零
	aL.size=0;
	srand((unsigned)time(NULL));
	for(i=0;i<MAXSIZE;行烂++i){
		x=rand()%100+1;
		flag=1;
		for(j=0;j<aL.size&&flag;++j)
			flag=(aL.data[j]!=x);
		if(flag==0)--i;
		else{
			aL.data[aL.size]=枣郑x;
			++aL.size;
		}
	}
	for(i=0;i<aL.size;++i)
		printf("%d",aL.data[i]);
	printf("
");
	return0;
}

‘叁’ c语言顺序表的创建程序

/*
*程序不足之处：1，main函数不应该为 void main
* 2，创建空的顺序表函数中 SqList L;//定义顺序表L L是局部变量，

函数结束即销毁，应该用指针代替
* 3，SqList CreateList(SqList L) //创建顺序表（非空）函数中：

scanf("%d",&L.elem); L里面的elem本来就是地址，

没必要再加&符号，且每次输入都一直放在首地址，

没达到程序所要表达的意思
* 4，void print(SqList L) //输出当前顺序表 函数中：

printf("%-3d",L.elem); 和上面是一样的道理
* 5，main函数中没有将申请的内存释放
*现将程序稍作修改如下，望采纳
*/

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100
#define Icreament 20
typedef int ElemType; //用户自定义数据元素类型

typedef struct
{
ElemType *elem; //顺序表的基地址
int length; //顺序表的当前长度
int listsize; //预设空间容量
}SqList; //线性表的顺序存储结构

SqList* InitList() //创建空的顺序表
{
SqList* L = (SqList*)malloc(sizeof(SqList));//定义顺序表L
if(!L)
{
printf("空间划分失败，程序退出 ");
return NULL;
}
L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem)
{
printf("空间划分失败，程序退出 ");
return NULL;
}
L->length=0;
L->listsize=LIST_INIT_SIZE;
return L;
}

int CreateList(SqList* L) //创建顺序表（非空）
{
int number; //顺序表中元素的个数
int i; //循环变量
printf("请输入顺序表中元素的个数：");
scanf("%d",&number);
if(number > LIST_INIT_SIZE)//一定要判断输入的个数是否大于顺序表的最大长度
{
printf("输入个数大于顺序表的长度 ");
return 0;
}

for(i=0;i<number;i++)
{
printf("输入第%d个数: ",i+1);
scanf("%d",L->elem+i);//L->elem+i：每次的输入都保存在顺序表元素中的下一个地址，而不是一直放在元素的首地址
}//给顺序表中每个数据元素赋值
L->length=number; //当前顺序表的长度
return 1;
}
void print(SqList* L) //输出当前顺序表
{
int i;
for(i=0;i<L->length;i++)
{
printf("%-3d",*(L->elem + i));//L->elem+i：和输入是一个道理
}
printf(" ");
}
int main()
{
SqList* L = InitList();//申请一个指向顺序表的指针，并对其初始化
if(!L)//判断申请是否成功
{
printf("初始化线性表失败 ");
return 1;
}
if(!CreateList(L))//判断创建顺序表是否成功
{
printf("创建顺序表失败 ");
return 1;
}
print(L);//打印顺序表
free(L->elem);//释放申请的顺序表元素的内存
free(L);//释放申请的顺序表内存
return 0;
}

运行效果如图：

‘肆’ c语言实现顺序表

--顺序表.h
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define TRUE 1
#define FLASE 0
typedef int Elemtype;
typedef int Status;

/*接口定义
Status InitList_Sq(SqList &L,int size,int inc);
void CreateList_Sq(SqList &L);
void print_Sq(SqList &L);
int Search_Sq(SqList L, Elemtype e);
Status DestroyList_Sq(SqList &L);
Status ClearList_Sq(SqList &L);
Status ListEmpty_Sq(SqList L);
int ListLength_Sq(SqList L);
Status GetElem_Sq(SqList L, int i, Elemtype &e);
Status PutElem_Sq(SqList &L, int i, Elemtype e);
Status Append_Sq(SqList &L, Elemtype e);
Status DeleteLast_Sq(SqList &L, Elemtype &e);
*/
--------------------
#include "顺序表.h"

//定义顺序表类型
typedef struct {
Elemtype *elem;
int length;
int listsize;
int increment;
}SqList;

//初始化顺序表
Status InitList_Sq(SqList &L,int size,int inc) {

L.elem = (Elemtype *)malloc(size * sizeof(Elemtype));
L.length = 0;
L.listsize = size;
L.increment = inc;
return TRUE;
}

//创建顺序表
Status CreateList_Sq(SqList &L) {
int i;
printf("请输入你要创建的顺序表元素个数：\n");
scanf_s("%d", &L.length);
if (L.length >= L.listsize) {
L.elem = (Elemtype *)realloc(L.elem, (L.listsize + L.increment) * sizeof(Elemtype));
}
if (!L.elem) {
return FLASE;
}
printf("请输入你要创建的顺序表：\n");
for (i = 0; i<L.length; i++) {
scanf_s("%d", &L.elem[i]);
}
}

//遍历顺序表
void print_Sq(SqList &L) {
int i;
for (i = 0; i<L.length; i++) {
printf("%4d", L.elem[i]);
}
}

//查找元素的位置
int Search_Sq(SqList L, Elemtype e) {
int i = 0;
while (L.elem[i] != e&&i<L.length) {
i++;
}
if (i>L.length)
return -1;
else
return i + 1;//因为C语言是从下标为0开始的，当i=0时表示第一个元素
}

//销毁顺序表
Status DestroyList_Sq(SqList &L) {
if (L.elem == NULL)
return -1;
else
free(L.elem);
printf("\n销毁成功\n");
return TRUE;
}

//清空顺序表
Status ClearList_Sq(SqList &L) {
if (L.elem == NULL)
exit(0);
int i;
Elemtype *p_elem = L.elem;
for (i = 0; i<L.length; i++) {
*L.elem = NULL;
L.elem++;
}
L.elem = p_elem;
}

//判断顺序表是否为空
Status ListEmpty_Sq(SqList L) {
int i;
Elemtype* p_elem = L.elem;
for (i = 0; i<L.length; i++) {
if (*L.elem != 0) {
L.elem = p_elem;
return FLASE;
}
L.elem++;
}
return TRUE;
}

//求顺序表的长度
int ListLength_Sq(SqList L) {
return L.length;
}

//用e返回顺序表L中第i个元素的值
Status GetElem_Sq(SqList L, int i, Elemtype &e) {
int j;
Elemtype* p_elem = L.elem;
if (i<1 || i>L.length)
return FLASE;
for (j = 1; j <= i; j++)
L.elem++;
e = *L.elem;
L.elem = p_elem;
return TRUE;
}

//将顺序表L中第i个元素赋值为e
Status PutElem_Sq(SqList &L, int i, Elemtype e) {
L.elem[i - 1] = e;
return TRUE;
}

//在顺序表L表尾添加元素e
Status Append_Sq(SqList &L, Elemtype e) {

L.elem[L.length] = e;
L.length++;
L.listsize += L.increment;
return TRUE;
}

//删除顺序表L表尾元素
Status DeleteLast_Sq(SqList &L, Elemtype &e) {
e = L.elem[L.length - 1];
L.length--;
return TRUE;
}

********************************************主函数.c*************************************************

#include <stdio.h>
#include <stdlib.h>
#include "顺序表.h"
#include "源代码.h"

//--------------------主函数入口--------------------

int main(){
SqList L;
int size, inc;
int e;
int a;
int length;
int i;
int temp;
int j=10;
int ee;
printf("\n--------------------顺序表初始化------------------\n");
printf("请输入顺序表的长度size以及扩容量：\n");
scanf_s("%d %d", &size, &inc);
InitList_Sq(L, size, inc);
CreateList_Sq(L);

printf("\n--------------------判断是否为空------------------\n");

if(ListEmpty_Sq(L)){
printf("该顺序表为空\n");
}
else
printf("该顺序表不为空\n");

printf("\n--------------------遍历顺序表--------------------\n");

printf("此时顺序表为：\n");
print_Sq(L);

printf("\n--------------------查找元素----------------------\n");

printf("\n请输入要查找的元素：\n");
scanf_s("%d",&e);
a = Search_Sq(L, e);
printf("%d为第%d位：\n",e,a);

printf("\n--------------------输出长度----------------------\n");

length = ListLength_Sq(L);
printf("顺序表的长度为%d\n",length);

printf("\n----------将顺序表L中第i个元素赋值为temp----------\n");

printf("请输入第i个元素的i值和temp值：\n");
scanf_s("%d %d",&i,&temp);
PutElem_Sq(L, i, temp);
printf("\n此时顺序表为：\n");
print_Sq(L);

printf("\n---------------在顺序表表尾添加元素---------------\n");

Append_Sq(L, j);
printf("\n此时顺序表为：\n");
print_Sq(L);

printf("\n---------------在顺序表表尾删除元素---------------\n");

DeleteLast_Sq(L, ee);
printf("\n被删除的元素为%d\n",ee);
printf("此时顺序表为：\n");
print_Sq(L);

printf("\n-------------------清空顺序表---------------------\n");

ClearList_Sq(L);
if(ListEmpty_Sq(L)){
printf("\n清空成功\n");
}

printf("\n------------------销毁顺序表----------------------\n");

DestroyList_Sq(L);
getchar();
getchar();
return 0;
}

‘伍’ c语言程序问题 数据结构之空顺序表定义

l=(senlsy*)macllo(sizeof(senlsy));当程序执行完这步这后，
l就指向了这个新申请的节点。
还贺渗简有l->length=0;执行完这步禅裤，l没变喊睁化。

其实你可以调试一下，l的具体值你都可以知道。

‘陆’ C语言建立顺序表

#include"iostream.h"
#include"malloc.h"
#include"stdio.h"
#define MAX_LIST_SIZE 100
typedef int elemtype;
typedef struct Node
{
elemtype *data;
int length;
int listsize;
}SqList;

void InitList(SqList &L)
{
L=(SqList *)malloc(MAX_LIST_SIZE*sizeof(SqList));
L->length=0;
L->listsize=MAX_LIST_SIZE;
}
void Insert(SqList &L,int i,elemtype x)
{
int k;
for(k=L->length;k>=i;k--)
*L->data[k+1]=*L->data[k];
*L->data[k]=x;
}
void Print(SqList L)
{
for(int i=0;i<L->length;i++)
cout<<*L->data[i]<<" ";
}

void main()
{
elemtype e;
int n;
SqList *L;
InitList(L);
cout<<"输入你要插入的元素:"<<endl;
cin>>e;
cout<<"输入你要插入的位置:"<<endl;
cin>>n;
Insert(L,n,e);
Print(L);
}
这里就简要的写了下第一小问，时间问题，没有调试，你自己看看
其实网上这方面的资料很多的，你可以网络一下

‘柒’ c语言数据结构，顺序表

创建顺序表

/**
* 创建顺序表
*/
SqList createList_sq() {
//SqList list;
//return list;

SqList* list = (SqList*)malloc(sizeof(SqList));
return *list;
}
这里模亮提供两种创建顺序表的代码，一种是由系统分配list占用的内存，一种李码羡是自己动态哪拍分配的内存，需要在程序运行之前手动释放占用的内存空间。
初始化顺序表

/**
* 初始化顺序表
* 返回1 表示初始化成功
* 返回0 表示初始化失败
*/
int initList_sq(SqList &L) { //只有在C++中才会有引用的存在
L.elem = (SeqType *) malloc(sizeof(SeqType) * LIST_INIT_SIZE);
if (!L.elem)
return 0; //内存分配失败，存储空间不够
L.length = 0; //表示顺序表为空
L.listsize = LIST_INIT_SIZE; //表示顺序表里，最大存储单元个数
return 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
分配顺序表的存储单元，初始化顺序表属性的值。
插入元素

/**
* 插入顺序表
* 下标是负数就插入到结尾

‘捌’ C语言顺序表的基本操作

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

typedefintDataType;//定义数据数据类型

typedefstruct{
	DataType*data;//data指向数据区的首个数据
	intlength;//数据长度
}SqList;

voidSort(SqList*L){
	inti,j,k;
	DataTypetmp;
	for(i=0;i<L->length-1;++i){
		k=i;
		for(j=i+1;j<L->length;++j)
			if(L->data[k]>L->data[j])
				k=j;
		if(k!=i){
			tmp=L->data[k];
			L->data[k]=L->data[i];
			L->data[i]=tmp;
		}
	}
}

SqList*CreateList(DataTypea[],intn){
	inti;
	SqList*L;
	L=(SqList*)malloc(sizeof(SqList));
	L->data=(DataType*)malloc(n*sizeof(DataType));
	L->length=n;
	for(i=0;i<n;++i)L->data[i]=a[i];
	Sort(L);
	returnL;
}

intInsertList(SqList*L,DataTypex){
	inti,j;
	for(i=0;i<L->length;i++){
		if(x<=L->data[i]){
			for(j=L->length;j>=i;j--)
				L->data[j+1]=L->data[j];//结点后移
			L->data[i]=x;
			L->length++;
			return1;
		}
	}
	L->data[L->length++]=x;
	return1;
}

intRemoveListElem(SqList*L,DataTyped){
	inti,j;
	for(i=0;i<L->length;++i){
		if(L->data[i]==d){
			for(j=i;j<L->length-1;++j)
				L->data[j]=L->data[j+1];
			L->length--;
			return1;
		}
	}
	return0;
}

SqList*AndList(SqList*A,SqList*B){/*A∩B*/
	inti,j,k=0;
	intlen=(A->length>B->length)?B->length:A->length;
	SqList*C=(SqList*)malloc(sizeof(SqList));
	C->length=len;
	C->data=(DataType*)malloc(len*sizeof(DataType));
	for(i=0;i<A->length;++i){
		for(j=0;j<B->length;++j){
			if(A->data[i]==B->data[j]){
				C->data[k++]=A->data[i];
				break;
			}
		}
	}
	C->length=k;
	returnC;
}

SqList*OrList(SqList*A,SqList*B){/*A∪B*/
	inti,j,flag;
	DataTypee;
	SqList*C=(SqList*)malloc(sizeof(SqList));
	C->length=A->length+B->length;
	C->data=(DataType*)malloc(C->length*sizeof(DataType));
	for(i=0;i<A->length;++i)C->data[i]=A->data[i];
	for(i=0;i<B->length;++i){
		e=B->data[i];
		flag=1;
		for(j=0;j<C->length;++j){
			if(e==C->data[j]){
				flag=0;
				break;
			}
		}
		if(flag)InsertList(C,e);
	}
	returnC;
}

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

voidFreeList(SqList*L){
	free(L->data);
	free(L);
}

voidmain(){
	DataTypex;
	DataTypearra[]={36,24,31,5,90,65,70,39,37};
	DataTypearrb[]={9,8,43,51,37,89,33,46,29,80,56};
	intalen=sizeof(arra)/sizeof(arra[0]);
	intblen=sizeof(arrb)/sizeof(arrb[0]);
	SqList*A=CreateList(arra,alen);
	printf("A线性表为:");
	PrintList(A);
	SqList*B=CreateList(arrb,blen);
	printf("B线性表为:");
	PrintList(B);
	SqList*C=AndList(A,B);
	SqList*D=OrList(A,B);
	printf("C=A∩B:");
	PrintList(C);
	printf("D=A∪B:");
	PrintList(D);

	printf("在D表中插入数据:");
	scanf("%d",&x);
	InsertList(D,x);
	printf("D表插入x后:");
	PrintList(D);
	
	printf("删除D表中数据:");
	scanf("%d",&x);
	RemoveListElem(D,x);
	printf("删除x后的D表为:");
	PrintList(D);
	FreeList(A);
	FreeList(B);
	FreeList(C);
	FreeList(D);
}

‘玖’ c语言建立空顺序表

从答游贴上来的代码看不出有什么问题，下面提两条建议:
1、作为链表数据类型，其内部应该有一个预先定义大小的数升咐组，你这里用int *elem，这只是一个指针，你是否打算在需要时再申请动态内存空间?
2、链表数据&L作为函吵举纯数实参是什么意思？应该是*L才对，而作为函数形参，*L是错的，而&L是对的。请体会！

‘拾’ 如何建造一个空的顺序表，然后再向里面插入数据，C语言

#include<stdio.h>
#include<stdlib.h>
/*
1.创建结构体-----具体事物的抽象
2.创建链表
3.创建结点
4.插入操作
4.1表头插入
4.2表尾插入
4.3指定位置插入(指定位置的前面)
5.删除操作
5.1表头删除
5.2表尾删除
5.3指定位置删除
6.判断是否为空
7.打印链表
*/
//单链表的结构体
typedefstructSingleList
{
//数据域
intdata;//以这个数据为例
//structMMmyMM;
//指针域
structSingleList*next;
}LIST,*LPLIST;
/*
别名:习惯大写
起别名---小名
//好处:单词少,好看(含义更精简)
structSingleList换一种叫法:LIST;
strcutSingleList*换一种叫法:LPLIST
*/
//------->2.创建链表---任何结构都需要用一个东西去表示
LPLISTCreateList()
{
//创建过程就是初始化过程---初始化基本数据成员过程
//需要内存空间
LPLISTList=(LPLIST)malloc(sizeof(LIST));
if(List==nullptr)
{
printf("失败了
");
system("pause");
exit(0);
}
//初始化基本数据成员----有表头的链表
List->next=nullptr;
returnList;
}
//------->3.创建结点
LPLISTCreateNode(intdata)
{
//1.需要内存
LPLISTNode=(LPLIST)malloc(sizeof(LIST));
//2.初始化基本数据成员
Node->data=data;//和创建链表多了数据域
Node->next=nullptr;
returnNode;
}
//------->4.1头插法
//函数写法:形参可以表示要操作的东西
//插入的链表是(List),插入的数据是多少(data)
voidInsertListHeadNode(LPLISTList,intdata)
{
//插入:创建插入的结点
LPLISTnewNode=CreateNode(data);//创建结点卖察
//插入操作
newNode->next=List->next;
/*
c=1
b=2
a=c;
c=b;
*/
List->next=newNode;
}
//------->4.2尾插法
voidInsertListTailNode(LPLISTList,intdata)
{
//找到表尾--->定义一个移动的指针
LPLISTtailNode=List;
while(tailNode->next!=nullptr)
{
tailNode=tailNode->next;
}
//创建插入的结点
LPLISTnewNode=CreateNode(data);
tailNode->next=newNode;
}
//------->4.3指定位置
voidInsertListAppoinNode(LPLISTList,intdata,intPosData)
{
//创建两个移动的指针:去找指定位置和指定位置的前面
LPLISTfrontNode=List;
//frontNode->next==taiNode:判断相邻
LPLISTtailNode=List->next;
//判断是否为空
while(tailNode->data!=PosData)
{
/*
frontNode=frontNode->next;
tailNode=tailNode->next;
*/
frontNode蔽配亩=tailNode;
tailNode=frontNode->next;
if(tailNode==nullptr)
{
printf("未找到指定位置
");
system("pause");
exit(0);
}
}
//tailNode->data=data;
宏森//找到后创建插入的结点
LPLISTnewNode=CreateNode(data);
frontNode->next=newNode;
newNode->next=tailNode;
}

//------->5.判断是否为空
//和创建的时候比较
intIsEmptyList(LPLISTList)
{
if(List->next==nullptr)
return1;//返回1表示为空
return0;//表示不为空
}
////------->6.打印数据
voidPrintList(LPLISTList)
{
if(IsEmptyList(List))
{
printf("链表为空,无法打印");
system("pause");
exit(0);
}
LPLISTpNext=List->next;
while(pNext!=nullptr)
{
printf("%d	",pNext->data);
pNext=pNext->next;
}
printf("
");
}
//------->7.删除
//头删除
voidDeleteListHeadNode(LPLISTList)
{
if(IsEmptyList(List))
{
printf("链表为空,无法删除
");
system("pause");
exit(0);
}
LPLISTDNode=List->next;
List->next=DNode->next;
free(DNode);
DNode=nullptr;
}
//------->8.尾删
voidDeleteListTailNode(LPLISTList)
{
if(IsEmptyList(List))
{
printf("链表为空,无法删除
");
system("pause");
exit(0);
}
//找到表尾--->定义一个移动的指针
LPLISTtailNode=List->next;
LPLISTtailFront=List;
while(tailNode->next!=nullptr)
{
tailFront=tailNode;
tailNode=tailFront->next;
}
tailFront->next=nullptr;
free(tailNode);
}
//------->9.指定位置删除
voidDeleteListAppoinNode(LPLISTList,intPosData)
{
//创建两个移动的指针:去找指定位置和指定位置的前面
LPLISTfrontNode=List;
//frontNode->next==taiNode:判断相邻
LPLISTtailNode=List->next;
//判断是否为空
while(tailNode->data!=PosData)
{
/*
frontNode=frontNode->next;
tailNode=tailNode->next;
*/
frontNode=tailNode;
tailNode=frontNode->next;
if(tailNode==nullptr)
{
printf("未找到指定位置
");
system("pause");
exit(0);
}
}
frontNode->next=tailNode->next;
free(tailNode);
}

intmain()
{
LPLISTList=CreateList();//List创建成功
printf("插入:
");
InsertListHeadNode(List,1);
InsertListHeadNode(List,2);
InsertListHeadNode(List,3);
InsertListTailNode(List,0);
PrintList(List);
printf("删除:
");
DeleteListHeadNode(List);
PrintList(List);
DeleteListTailNode(List);
PrintList(List);
printf("指定位置:
");
//看不懂,可以找群主
InsertListAppoinNode(List,4,2);
InsertListAppoinNode(List,3,2);
//C/C++8群
PrintList(List);
//491994603
DeleteListAppoinNode(List,2);
PrintList(List);
system("pause");
return0;
}

以上代码偏多,主要是多个层次和多个角度,全方位书写顺序表,真正项目一般使用一种插入和删除方法.