c語言實現線性表的順序存儲

① 用c語言編寫程序實現線性表的順序存儲結構並實現以下功能： 1. 輸入一組整數構造線性表；

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

② c語言實現線性表的順序存儲結構

#include "stdio.h"
#include "stdlib.h"
int main()
{ int a[10],i,j,k,t,x;
for(i=0;i<9;i++)
a[i]=rand()%100; //給數組賦隨機值范圍0-100

for(i=0;i<8;i++) //數組從小到大排序
for(j=i+1;j<9;j++)
if(a[i]>a[j])
{ t=a[i];a[i]=a[j];a[j]=t;

}

//輸出一維數組中的數

for(i=0;i<9;i++)
printf("%d ",a[i]);
printf("\n");

//向數組插入一個數x
scanf("%d",&x);
if(x>a[8]) a[9]=x;
else if(x<a[0])
{
for(i=9;i>0;i--)
a[i]=a[i-1];
a[0]=x;
}

else
{for(i=0;i<8;i++)
if(x>a[i]&&x<a[i+1]) k=i+1;
for(j=9;j>k;j--)
a[j]=a[j-1];
a[k]=x;
}
//輸出插入後的數組
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");

//刪除數組中的一個元素
//輸入要刪除的元素的下標
scanf("%d",&k);
for(i=k;i<10;i++)
a[i]=a[i+1];
//輸出刪除後的數組
for(i=0;i<9;i++)
printf("%d ",a[i]);
printf("\n");

}

③ 數據結構c語言版 使用線性表的順序儲存結構定義(靜態)實現線性表的初

直接上源碼吧。
/*線性表功能的實現*/
#include<stdio.h>
//定義常量 存儲空間的初始化分配
#define MAXSIZE 20
#define TRUE 1
#define ERROR -1
#define FALSE 0
#define OK 1
//用typedef定義類型
typedef int Status;
typedef int ElemType;
//定義一個結構體類型
typedef struct{
ElemType data[MAXSIZE];
int length;
} sqlist;
//初始化函數
Status initList(SqList *L){
L->length = 0;
return OK;
}
//返回線性表的長度
Status getListLength(SqList L){
return L.length;
}
//線性表為空返回true,否則返回false
Status listEmpty(SqList L){
if(L.length == 0){
return TRUE;
}
return FALSE;
}
//線性表清空,長度為0
Status clearList(SqList *L){
L->length = 0;
return OK;
}
//獲取指定的元素的值,返回下標為i - 1的元素,賦值給e
Status getElem(SqList L, int i, ElemType *e){
//判斷元素位置是否合法[i]
if(i > L.length || i < 1){
printf("查找的位置不正確 \n");
return ERROR;
}
//判斷線性表是否為空
if(listEmpty(L)){
return ERROR;
}
*e = L.data[i - 1];
return OK;
}
//在線性表中查找指定的e相等的元素,如果查找成功,返回該元素的下標,否則返回ERROR
Status locateElem(SqList L, ElemType e){
int i;
for(i = 0; i < L.length - 1; i++){
if(L.data[i] == e){
return i;
}
}
printf("沒有查找到元素 %d 指定的下標\n",e);
return ERROR;
}
//自動創建 MAXSIZE 個元素,並賦值為0
Status createList(SqList *L){
int i;
for(i = 0; i < 10; i++){
L->data[i] = 0;
}
L->length = 10;
return OK;
}
//在線性表中第i個位置前插入新元素e
Status listInsert(SqList *L, int i, ElemType e){
//判斷長度是否可以允許插入新的數據
if(L->length >= MAXSIZE){
printf("空間已滿,不能再插入數據\n");
return FALSE;
}
//判斷插入位置的合法性
if(i < 1 || i > L->length) {
printf("插入位置不正確\n");
return FALSE;
}
int j;
for(j = L->length - 1; j >= i; j--){
L->data[j] = L->data[j - 1];
}
L->data[i - 1] = e;
L->length++;
return TRUE;
}
//刪除線性表中第i個元素,成功後表長減1,用e返回其值
Status deleteList(SqList *L, int i, ElemType *e){
//判斷線性表是否為空
if(listEmpty(*L)){
return ERROR;
}
//判斷刪除的位置是否合法
if(i < 1 || i > L->length) {
printf("刪除位置不合法\n");
return ERROR;
}
*e = L->data[i - 1];
for(i; i < L->length; i++){
L->data[i - 1] = L->data[i];
}
L->length--;
return TRUE;
}
//遍歷線性表
Status listTraverse(SqList L){
int i;
for(i = 0; i < L.length; i++){
printf("%d ",L.data[i]);
}
printf("\n");
return OK;
}
//主程序
int main(void){
SqList L;
ElemType e;
initList(&L);
int option = 1;
int input_number;
int res;
ElemType input_value;
printf("\n1.遍歷線性表 \n2.創建線性表 \n3.清空線性表 \n4.線性表插入 \n5.查找表中元素 \n6.判斷元素是否在表中 \n7.刪除某個元素 \n8.線性表長度\n9.線性表是否為空\n0.退出 \n請選擇你的操作：\n");
while(option){
scanf("%d",&option);
switch(option){
case 0:
return OK;
break;
case 1:
listTraverse(L);
break;
case 2:
createList(&L);
listTraverse(L);
break;
case 3:
clearList(&L);
listTraverse(L);
break;
case 4:
printf("請輸入插入的位置:");
scanf("%d",&input_number);
printf("\n");
printf("請輸入插入的值:");
scanf("%d",&input_value);
printf("\n");
listInsert(&L, input_number, input_value);
listTraverse(L);
break;
case 5:
printf("請輸入要查找的位置:");
scanf("%d",&input_number);
printf("\n");
getElem(L, input_number, &input_value);
printf("第%d個元素的值為:%d\n",input_number,input_value);
break;
case 6:
printf("請輸入要查找的元素:");
scanf("%d",&input_value);
printf("\n");
res = locateElem(L, input_value);
if(res != ERROR){
printf("值為%d在表中的第%d個位置\n",input_value,input_number);
}
break;
case 7:
printf("要刪除第幾個元素？");
scanf("%d",&input_number);
printf("\n");
deleteList(&L, input_number, &input_value);
listTraverse(L);
break;
case 8:
res = getListLength(L);
printf("線性表的長度是:%d",res);
break;
case 9:
res = listEmpty(L);
if(res){
printf("線性表的是空的");
}else{
printf("線性表的是不是空的");
}
break;
}
}
return OK;
}

線性表的特徵是:
1. 元素之間是有序的,如果元素存在多個,則第一個元素無前驅,最後一個無後繼,其它元素都有且只有一個前驅和後繼.
2. 元素個數是有限的. 當n=0是,稱為空表
線性表實現方式有兩種,分別是順序存儲結構和鏈式存儲結構,它們之間各有優缺點 . 根據需求的不同進行選擇不同的存儲結構.
線性表存儲結構的優缺點
優點:
1. 無須為表中元素之前的邏輯關系而增加額外的存儲空間
2. 可以快速的存取表中的任一位置的元素
缺點:
1. 插入和刪除操作需要移動大量元素
2. 當線性表長度變化較大時,難以確定存儲空間的容量.
3. 造成存儲空間的」碎片」.

④ 用C語言建立一個順序存儲的線性表並實現線性表的插入和刪除操作

此順序表實現了多個功能，代碼很完善，我將其改成從鍵盤輸入跟選擇刪除了，你根據你的需要自己再進行修改。

//common.h文件，頭文件
#ifndef_COMMON_H_
#define_COMMON_H_

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

#defineTRUE1
#defineFALSE0

#defineMAXSIZE100

typedefintdatatype;

typedefstruct
{
	datatypedata[MAXSIZE];
	intlength;
}sqnode,*sqlink;

voidcreat_sqlist(sqlink*sq);
voidset_empty_sqlist(sqlinksq);
intisempty_sqlist(sqlinksq);
intisfull_sqlist(sqlinksq);
intgetlength_sqlist(sqlinksq);
datatypegetelem(sqlinksq,inti);//i為第i個元素
intlocate_sqlist(sqlinksq,datatypex);//返回該元素在表中的位置
voidinsert_sqlist(sqlinksq,datatypex,inti);//表示在表中第i個位置前插入。
datatypedel_sqlist(sqlinksq,inti);//刪除表中第i個元素
voidshow_sqlist(sqlinksq);

#endif

//線性表實現的c代碼
#include"common.h"
voidcreat_sqlist(sqlink*sq)
{
	*sq=(sqlink)malloc(sizeof(sqnode));
	assert(*sq);
	bzero(*sq,sizeof(sqnode));
	(*sq)->length=0;
}

voidset_empty_sqlist(sqlinksq)
{
	sq->length=0;
}

intisempty_sqlist(sqlinksq)
{
	returnsq->length==0?TRUE:FALSE;
}

intisfull_sqlist(sqlinksq)
{
	returnsq->length==MAXSIZE?TRUE:FALSE;
}

intgetlength_sqlist(sqlinksq)
{
	returnsq->length;
}

datatypegetelem(sqlinksq,inti)//i為第i個元素
{
	if(i<1||i>getlength_sqlist(sq))
	{
		printf("iiswrong!
");
		returnFALSE;
	}
	returnsq->data[i-1];
}

intlocate_sqlist(sqlinksq,datatypex)//返回該元素在表中的位置
{
	intj=1;
	while(j<=getlength_sqlist(sq))
	{
		if(sq->data[j-1]==x)
			returnj;
		j++;
	}
	returnFALSE;
}
voidinsert_sqlist(sqlinksq,datatypex,inti)//表示在表中第i個位置前插入。
{
	intj=1;
	if(isfull_sqlist(sq))
	{
		printf("sqlistisfull!
");
		return;
	}
	if(i<1||i>getlength_sqlist(sq)+1)
	{
		printf("iisnotintherange!
");
		return;
	}
	for(j=getlength_sqlist(sq)-1;j>=i-1;j--)
	{
		sq->data[j+1]=sq->data[j];
	}
	sq->data[i-1]=x;
	++sq->length;
}
datatypedel_sqlist(sqlinksq,inti)//刪除表中第i個元素
{
	datatyperet;
	if(isempty_sqlist(sq))
	{
		printf("sqlistisempty!
");
		returnFALSE;
	}
	if(i<1||i>getlength_sqlist(sq))
	{
		printf("iisnotintherange!");
		returnFALSE;
	}
	for(i;i<getlength_sqlist(sq);i++)
		sq->data[i-1]=sq->data[i];
	--sq->length;
	returnret;
}

voidshow_sqlist(sqlinksq)
{
	intj=0;
	for(j;j<getlength_sqlist(sq);j++)
		printf("%d,",sq->data[j]);
	putchar('
');
}
//main函數
#include"common.h"

intmain(intargc,char*argv[])
{
	inti=0,n,id;
	intnum;
	printf("你要往順序表中插入幾個元素
");
	scanf("%d",&num);
	printf("請往順序表中插入%d個元素：
",num);
	sqlinksq=NULL;
	creat_sqlist(&sq);
	while(i<num)
	{
	scanf("%d",&n);
		insert_sqlist(sq,n,1);
		i++;
	}
	printf("順序表的存儲如下：
");
	show_sqlist(sq);
	printf("你要刪除第幾個元素?
");
	scanf("%d",&id);
	del_sqlist(sq,id);
	printf("刪除第%d個元素之後的順序表為：
",id);
	show_sqlist(sq);
	return0;
}

⑤ 用c語言建立一個順序存儲的線性表，實現線性表的插入、刪除操作

鏈表
1。是由結構體和指針構成的。
2。包括兩個部分一個是數據域和指針域。
3。鏈表中的結點分為兩類：頭結點和一般結點。頭結點是沒有數據域的。
4。基本操作有：初始化鏈表，增加結點和刪除結點，求鏈表的長度等等。
struct Linknode{
int data;
struct Linknode *next;
};
這個地方有個知識點：這個是鏈表的數據結構是有結構體和指針構成。結構體名為Linknode.但這裡面沒有定義結構體變數，只有我們定義了結構體變數才能使用結構體。
結構體變數怎麼定義呢？
有兩種方式：
1。struct Linknode Linklist;
2.typedef struct linknode Linklist.
一般我們都希望採用第2種，這樣的好處是: 當我們再定義結構體變數時，可以用：Linklist p;而如果我們採用第一種還必須採用 struct Linknode p;對比一下就可以知道第2種要簡單很多。那麼下面我們都採用第2種方式來定義結構體變數。
上面我們已經定義了一個鏈表：
1。初始化鏈表。
#include<stdio.h>
#include<stdlib.h>
int InitLinkList(Linklist **Lnode)
{
*Lnode=(Linklist)malloc(sizeof(Linklist));//*Lnode等於L，對與*Lnode的分配空間相當與對主函數中的L分配空間。
if(!*Lnode)
return 0;
（*Lnode）->next=NULL;
}
在初始化鏈表的時候，我們用到了2級指針為什麼呢？因為我們希望在InitLinkList函數生成的頭結點，主函數中也能指向這個頭結點。如果我們用一級指針的話，用malloc分配空間的時候，它將會返回分配空間的首地址給指針變數Lnode，而不能使是的空間被主函數中指針變數L得到這個地址。所以我們要用2級指針。
void main()
{
Linklist *L;
InitLikList(&L);
}
2。增加鏈表結點
增加鏈表結點其實很簡單，一般用到三個結構體指針變數和一個循環結構。
InsertLinkList(Linklist *Lnode)
{
Linklist *p,*q;
int d;
{
scanf("%d",&d);
if(d==-9999)
break;
p=Lnode->next;//p指向頭結點
//通過while循環和指針變數p定位要插入的結點q的位置。
while（p）
p=p->next;
//生成一個要插入的結點
q=(Linklist)malloc(sizeof(Linklist));//申請要插入的結點空間
q->data=d;//填充要插入結點的數據域
q->next=p->next;//首先填充要插入結點q的指針域進行填充。
p->next=q;//然後把定位好的p指針域進行修改指向q.

}while(9);//循環退出的條件是輸入的數據-9999

}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一個頭結點
InsertLinkList(L);//插入結點
}
3。求鏈表的長度：
int LengthLinkList(Linklist *Lnode)
{
int i=0;
Linklist *p;
p=Lnode->next;//p指向鏈表的第一個結點。
while(p)
{
i++;
p=p->next;
}
return i;
}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一個頭結點
InsertLinkList(L);//插入一個結點
LengthLinkList(L)//求鏈表的長度。
}
4.刪除結點
刪除鏈表結點其實很簡單，一般用到三個結構體指針變數和一個循環結構。
DestroyLinkList(Linklist *Lnode)
{
Linklist *p,*q;
p=Lnode;//p指向鏈表的頭結點
while(p)
{
q=p->next;//q指向當前結點的下一個結點。
free(p);//釋放當前結點
p=q;//p指向下一個結點
}
}
void main()
{
Linklist *L;
InitLinkList(&L);//生成一個頭結點
InsertLinkList(L);//插入結點
LengthLinkList(L)//求鏈表的長度。
DestroyLinkList(L);//刪除鏈表結點
}

⑥ 利用c語言實現順序存儲線性表的插入!

有時會出現這種情況。他會以為是木馬。
int GetElem();
int InstInsert();
typedef int ElemType;
typedef struct{
ElemType *elem; //存儲空間基地址
int length; //當前長度
int listsize;//當前分配的存儲容量
}SqList;
int InitList(SqList *L){
L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L->elem)exit(-1);//存儲空間分配失敗
L->length=0; //空表長度為0
L->listsize=LIST_INIT_SIZE; //初始存儲容量
printf("線性鏈表創建成功\n");
return OK;
}
int Input(SqList *L){
ElemType temp,*newbase;
printf("輸入順序列表的數據，以0為結束標志\n");
scanf("%d",&temp);
while(temp!=0){
if(L->length>=L->listsize){
newbase=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!newbase) exit(-1);//存儲空間分配失敗
L->elem=newbase; //空間新基地址
L->listsize+=LISTINCREMENT; //增加存儲容量
}
L->elem[L->length++]=temp;
scanf("%d",&temp);
}
printf("輸入數據結束！！\n");
return OK;
}
int Onput(SqList *L){
int i=0;
printf("輸出線性表數據：");
while(i<L->length){
printf("%d\t",L->elem[i]);
i++;
}
printf("\n");
}
int ClearList(SqList *L){
L->length=0;
printf("清除成功!\n");
return OK;
}
void ListEmpty(SqList L){
if(L.elem!=NULL)
printf("true!\n");
else
printf("false!\n");
}
void ListLength(SqList L){
printf("線性表的長度是：%d\n",L.length);
return ;
}
int GetElem(SqList L,int i,SqList *e){
e=L.elem[i-1];
return e;
}
void PriorElem(SqList L,int cur_e,SqList *pre_e){
if(cur_e!=L.elem[0]){
pre_e=L.elem[0];
printf("前驅值為：%d\n",pre_e);
}
else
printf("pre_e無意義\n");
}
void NextElem(SqList L,int cur_e,SqList *next_e){
if(cur_e!=L.elem[L.length-1]){
next_e=L.elem[L.length-1];
printf("後繼值為：%d\n",next_e);
}
else
printf("next_e無意義\n");
}
int ListInsert(SqList *L,int i,int e){
ElemType *newbase,*p,*q;
if(1>i||i>(L->length+1))
return -1;
if(L->length>=L->listsize){ //新增內存
newbase=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); //開辟新內存空間
if(!newbase)
exit(-1); //存儲分配失敗
L->elem=newbase; //新基地址
L->listsize+=LISTINCREMENT; //新增內存容量
}
q=&(L->elem[i-1]);
for(p=&(L->elem[L->length-1]);p>=q;p--){
*(p+1)=*p;
}
*q=e;
++L->length;
return OK;
}
int ListDelete(SqList *L,int i,int e){
ElemType *p,*q;
if(i<1||i>L->length)
return -1;
q=&(L->elem[i-1]);
e=L->elem[i-1];
p=L->elem+L->length-1;
for(;p>=q;q++)
*q=*(q+1);
--L->length;
printf("刪除的值為：%d\n",e);
return OK;
}

⑦ 用C語言的一維數組實現線性表的順序存儲

還是說只要是在內存中申請了一塊連續的地址空間存儲數據只要知道其首地址都可以用數組的形式訪問其中的元素呢？
就是這樣的。
線性表的特點就是長度可變，如果使用常規的數組，就不能實現這個特性，因為數組是定長的。而在堆中申請的內存可以通過參數在運行時指定它的大小，且可以調整它的大小，並且其使用方式和數組一樣，使用索引訪問。
int*p = (int*)malloc(sizeof(int)*5);
p[0]; //第一個元素
p[1]; //第二個元素
p[2]; //第三個元素
//...
free(p);

⑧ 利用線性表的順序存儲結構完成一個班級的所有課程的管理c語言要求實現增加，刪除，修改學生成績記錄等功

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

typedef struct LNode{
int data; //鏈表數據
struct LNode* next; //鏈表指針
}LNode,*LinkList;

/*頭插法-建立單鏈表*/
LinkList HeadCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode)); //建立頭結點
la->next=NULL;
scanf("%d",&num);
while(num!=10)
{
LNode *p=(LinkList)malloc(sizeof(LNode));
p->data=num;
p->next=la->next;
la->next=p;
scanf("%d",&num);
}
return la;
}

/*尾插法-建立單鏈表*/
LinkList TailCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode));
la->next=NULL;
LinkList s,r=la;
scanf("%d",&num);
while(num!=10)
{
s=(LinkList)malloc(sizeof(LNode));
s->data=num;
r->next=s;
r=s;
scanf("%d",num);
}
r->next=NULL;
return la;
}

/*單鏈表遍歷*/
void TravelList(LinkList la)
{
LinkList p=la->next;
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("\n");
}

/*單鏈表的按位查找*/
LinkList GetElem(LinkList la,int i)
{
int j=1;
LNode* p=la->next;
if(i<1)
return NULL;
while(p && j<i)
{
p=p->next;
j++;
}
return p;
}

/*單鏈表的按值查找*/
LinkList LocalElem(LinkList la,int e)
{
LNode* p=la->next;
while(p!=NULL && p->data!=e)
p=p->next;
return p;
}

/*單鏈表插入操作*/
bool InsertList(LinkList la,int i,int e)
{
//在la鏈表中的i位置插入數值e
int j=1;
LinkList p=la,s;
while(p && j<i)
{
p=p->next;
j++;
}
if(p==NULL)
return false;
if((s=(LinkList)malloc(sizeof(LNode)))==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}

/*單鏈表刪除操作*/
bool DeleteList(LinkList la,int i)
{
int j=1;
LinkList p=la,q;
while(p && j<i) //p指向第i-1個元素
{
p=p->next;
j++;
}
if(p==NULL || p->next==NULL) //表示不存在第i-1個和第i的元素
return false;
q=p->next;
p->next=q->next;
free(q);
return true;
}

/*單鏈表的表長*/
int LengthList(LinkList la)
{
int nLen=0;
LinkList p=la->next;
while(p)
{
p=p->next;
nLen++;
}
return nLen;
}

/*單鏈表逆置*/
LinkList Reserve(LinkList la)
{
if(la==NULL || la->next==NULL)
return la;
LinkList p=la->next,q=p->next,r=q->next;
la->next=NULL;
p->next=NULL;
while(r!=NULL)
{
q->next=p;
p=q;
q=r;
r=r->next;
}
q->next=p;
la->next=q;
return la;
}

int main()
{
LNode la;
LinkList p;
p=HeadCreate(&la); //頭插法創建單鏈表
TravelList(p);
printf("%p\n",GetElem(p,1)); //獲得第1個結點地址
InsertList(p,2,10); //在鏈表的第2個位置插入元素10
TravelList(p);
DeleteList(p,3); //刪除鏈表的第3個元素
TravelList(p);
printf("%d\n",LengthList(p)); //獲得鏈表長度
p=Reserve(p);
TravelList(p);
return 0;
}

//運行結果
//5 6 12 7 8 14 9 3 2 5 14 10 頭插法創建鏈表
//14->5->2->3->9->14->8->7->12->6->5-> 顯示鏈表
//00382490 第一個結點的地址
//14->10->5->2->3->9->14->8->7->12->6->5-> 插入元素值為10的結點
//14->10->2->3->9->14->8->7->12->6->5-> 刪除第三個結點
//11 獲得鏈表長度
//5->6->12->7->8->14->9->3->2->10->14-> 鏈表逆置
//Press any key to continue

這是我寫的一個線性表鏈式存儲的綜合程序，包含了你所要的創建、刪除、插入、按值查找的功能，還有一些額外的功能。下面加註釋的是程序運行結果，你可以參考試著改改程序，讓程序更加完美。希望對你有幫助，呵呵！

⑨ C語言線性表順序存儲

建鏈表的函數用引用就好了

#include"stdafx.h"

#include<stdio.h>
#include<stdlib.h>
//-------------------
#defineMAXSIZE100//Thelargestnumberofpeople
typedefintElemType;
typedefstruct
{
	ElemTypedata[MAXSIZE];
	ElemTypepassward[MAXSIZE];
	intlength;
}seqList;
seqList*L;
voidCreaList(seqList*&L,int[MAXSIZE],intn);/////引用
voidPrintList(seqList*L,intn);//不一致
intmain(void)
{
	intn=0,m=0;
	inta[MAXSIZE];
	do
	{
		if(n>MAXSIZE)
		{
			printf("Thenumberofpeopletoomuch,pleaseinputagain!
");
		}
		printf("Pleaseenterthenumberofpeople(upto%d):",MAXSIZE);
		scanf_s("%d",&n);
	}while(n>MAXSIZE);
	printf("Pleaseentertheinitailpassword:");
	scanf_s("%d",&m);
	CreaList(L,a,n);
	printf("--------printthelineartable--------

");
	PrintList(L,n);
	printf("初始化成功...

");
	system("pause");
}
voidCreaList(seqList*&L,inta[MAXSIZE],intn)/////引用
{
	intiPassword;
	L=(seqList*)malloc(sizeof(seqList));
	for(inti=1;i<=n;i++)
	{
		L->data[i]=a[i];
		printf("Pleaseenterthe%dpersonalpassword:",i);
		scanf_s("%d",&iPassword);
		L->passward[i]=iPassword;
	}
	L->length=n;
}
voidPrintList(seqList*L,intn)
{
	for(inti=1;i<=n;i++)
	{
		printf("--------ID---------PASSWORD--------
");
		printf("%6d%5d
",L->data[i],L->passward[i]);
	}
}