顺序表的初始化c语言

① c语言(数据结构)顺序表的初始化需要申请结点空间吗

C语言(数据结构)顺序表的初始化需要申请结点空间。
初始化顺序表
1、/**
2、
*
初始化顺序表
3、
*
返回1
表示初始化成功
4、*
返回0
表示初始化失败
5、*/
6、int
initList_sq(sqlist
&L)
{
//只有在C++中才会有引用的存在
7、

L.elem
=
(SeqType
*)
malloc(sizeof(SeqType)
*
LIST_INIT_SIZE);
8、
if
(!L.elem)
9、

return
0;
//内存分配失败，存储空间不够
10、
L.length
=
0;
//表示顺序表为空
11、

L.listsize
=
LIST_INIT_SIZE;
//表示顺序表里，最大存储单元个数
分配顺序表的存储单元，初始化顺序表属性的值。
定义结构
typedef
int
SeqType;
//存储单元类型
typedef
struct{
SeqType
*elem;
//存储空间基地址
int
length;
//当前长度
int
listsize;
//当前分配的存储容量（以sizeof(ElemType)为单位）
}
SqList;
结构体内，有三个元素：存储空间基地址，类似于数组首地址；当前长度，记录顺序表中有效存储单元个数；当前分配的存储容量，顺序表中，最多容纳的存储单元个数。当顺序表中所有存储单元已经被使用，在下次插入元素之前，需要新增存储单元。这点是数组所不具有的特性。
*注：定义一个存储单元类型SeqType是为了使顺序表适和更多数据类型，使用的时候修改SeqType类型即可。

② C语言数据结构顺序表初始化

C数据结构的基础是指针。好好花上几天时间把指针搞懂再来学数据结构会事半功倍。

#include <stdlib.h>
#include <stdio.h>
#define MAX_SIZE 100
#define OK 0
#define ERROR -1

typedef struct tagSqList
{
int element[MAX_SIZE];
unsigned size;
} SqList;

int Initial(SqList *pL) // 定义指针变量用*，&在C里面是用来取地址的
{
// 通过指针变量访问结构体中的字段，应该使用->运算符，而不是通常的点运算符
pL->size = 0;

return OK;
}

int main(void)
{
SqList L;
Initial(&L); // 把变量的地址传递给指针形参
printf("%d\n", L.size);
return OK;
}

③ C语言数据结构顺序表初始化程序

你的SqList结构包含的元素是一个100个int类型的数组，和一个int变量。
在初始化函数中，首先参数sqlist *L，应该改成Sqlist *L
然后你给L->Elem_array进行赋值操作是不对的，因为Elem_array是数组首地址，是个常量，不能进行赋值操作。而且本身结构里面定义的是数组元素，所以已经有空间了，根本不需要再另外申请内存。如果需要动态申请内存，就把Elem_array声明为指针类型：ElemType *pElem_array

④ 请问初始化顺序表时，顺序表长度为什么要置零(C语言)

顺序表长度等于顺序表中元素的个数。初始化顺序表时，里面是没有元素的，所以必须要将长度置零。

⑤ 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语言(数据结构)顺序表的初始化

肯定是要分配空间的，你第一个程序的initsqlist函数中声明的结构体指针（Sqlist *a;），而第二个程序的initsqlist函数中是声明的结构体（Sqlist a;），前者只是在计算机内存中声明一个指针，而不会给这个指针分配内存空间，所以你初始化的时候要给这个指针用malloc函数分配空间，而后者是实实在在的定义了一个结构体，在内存在不仅仅是一个地址，还分配了空间，就像你定义了一个数组一样，已经在内存存在空间了，不需要再分配了。
总体来说就是你定义的是指针的话就要分配空间。

你的2个程序都是对的，但是一般用第一种定义链表！！！

⑦ C语言顺序表的初始化和取值这串代码哪里出问题了，谁来解释一下

1、你报错的原因是因为main函数里面的SqList *L没有初始化（没有开辟内存），应该修改为SqList *L = new SqList;
2、你的void PrintList(SqList *L)里面，输出的是L->elem[i]，但是你CreateList(SqList *L)函数里面，记录的却是scanf("%d",&L->a[i]);，这样你输出的就全是没有初始化的乱码了。
纯手打，还把你发的代码自己整理了一遍。。。望采纳~
程序修改之后如下：
#include <stdlib.h>
#include <stdio.h>

#define MAXSIZE 100
#define LISTINCREMENT 10

typedef int Elemtype;
typedef int Status;

typedef struct{
Elemtype *elem;
int length;
int a[MAXSIZE];
} SqList;

Status Inilist(SqList *L)
{
L->elem=(Elemtype*)malloc(MAXSIZE*sizeof(Elemtype));
L->length=0;
return 1;
}

void CreateList(SqList *L)
{
int i;
printf("请输入你要创建的顺序表元素个数");
scanf("%d",&L->length);
printf("请输入你要创建的顺序表：\n");
for(i=0; i<L->length; i++)
scanf("%d",&L->a[i]);
}

void PrintList(SqList *L)
{
int i;
for(i=0; i<L->length; i++)
printf("%3d",L->a[i]/*elem[i]*/);
}

int main()
{
//SqList *L;
SqList *L = new SqList;
Inilist(L);
CreateList(L);
PrintList(L);
return 0;
}

⑧ 顺序表的初始化怎么用C语言实现举个例子，不胜感激

你所说的顺序表就是指单向链表吧。举个例子：
声明：typedef struct queue{
int data;
struct queue * next;
}queuetype; //定义结构体类型
typedef queuetype * pqueuetype; //定义结构体指针类型
pqueuetype front,rear; //声明链表头指针和尾指针

操作：
void queueinital(){
front=NULL;
rear=NULL; }
这一段函数就是所谓的单向链表的初始化，即将链表头指针和尾指针都赋值为空而已。如果你指的是将链表各个单元中的所有数据初始化，那需要先明白一个问题，链表各单元并不是先申请空间再等待你输入值的，而是，你有一个值，程序申请空间，然后将值写入。看一下下面的入队函数：
void inqueue(int x){
pqueuetype p=(pqueuetype)malloc(sizeof(queuetype));
p->data=x;
p->next=NULL;
if(rear==UNLL){
rear=p;
front=p;
}
else{
rear->next=p;
rear=p;}
}
}
通过这个入队函数，将值写入链表，链表根据你写入值的多少一个个申请空间，改变长度，通过所有指针将所有数据单元相连。实现单向顺序链表结构。

⑨ C语言动态顺序表初始化

问题就在调用ini的时候出现的。因为L在使用时未分配空间，只是使用的一个临时指针变量，引用的时候出现非法地址访问。改一个地方即可！

⑩ c语言 顺序表的初始化 谁能帮我看一下我的程序应该怎么改谢谢大家了！

/*单词有错误，符号少写，漏写，这么低级的错误，自己都不愿意自己动手，还是劝手不要学习了*/

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

typedefintelem;
typedefstruct
{
	elem*p;
	intlength;
	intcapacity;
}list;
voidinitlist(list*l,intcapacity)
{
//	l->p(elem*)malloc(capacity*sizeof(elem))
l->p=(elem*)malloc(capacity*sizeof(elem));
	l->length=0;
	l->capacity=capacity;
}
voidappend(list*l,elemn)
{
	if(l->capacity==l->length)
	printf("false
");
	l->p[l->length]=n;
	l->length++;
}
voidshowlist(list*l)
{
	inti;
	for(i=0;i<l->length;i++)
	printf("%d",l->p[i]);
	printf("
");
}
intinsertitem(list*l,intp,elemn)
{
	inti;
	if(l->capacity==l->length)
	return0;
	if(p<1||p>l->length)
	return0;
	p--;
	for(i=l->length;i>p;i--)
	l->p[i]=l->p[i-1];
	l->p[p]=n;
	l->length++;
	return1;
}
intdeleteitem(list*l,intp)
{
	inti;
	if(p<1||p>l->length)
	return0;
	p--;
	for(i=p;i<l->length-1;i++)
	l->p[i]=l->p[i+1];
l->length--;
	return1;
}
voidclearlist(list*l)
{
	free(l);
	l->capacity=0;
	l->length=0;
}
intmain()
{
	listlist1;
	inti;
	initlist(&list1,10);
	for(i=0;i<9;++i)
	append(&list1,i);
	showlist(&list1);
	deleteitem(&list1,6);
	showlist(&list1);
	clearlist(&list1);
	return0;
}