① 誰有有關線性表的基本操作的c語言程序
我有嚴蔚敏那本書上所有的演算法 他沒寫的也有 我們老師給我的 你要的話 給我郵箱
求採納
② 線性表問題。那個ADTlist中的基本操作是什麼意思是可以直接在c語言中使用嗎我用的是嚴蔚敏數據結構c
嘿嘿，這是抽象數據類型中的基本操作。就是你自己定義了一種數據類型，但是光有名字不行呀，你還想要它能動起來，於是你再定義一些基本操作。書上的代碼很像C，但並不是C，所以你可以把它翻譯成C，這樣就能實現了!
③ 線性表的操作（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語言實現
代碼如下：
頭文件：
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語言庫函數里有線性表基本操作函數嗎
在實際應用中，線性表都是以棧、隊列、字元串、數組等特殊線性表的形式來使用的。
C語言標准庫沒有線性表的操作
但是C++ STL提供了很多函數/數據結構
⑥ 誰能給一個簡單的線性表操作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語言實現線性表的基本操作，能創建一個基於學生信息管理的鏈表
已經調通的一個程序，你細微修改一下就好了
/*C語言封筆*/
#include<stdio.h>
#include<malloc.h>
#define NULL 0
#define dd sizeof(struct stu)
struct stu{
int num;
char name[10];
struct stu *next;
};
int n=0;
struct stu *create(void)/*創建*/
{struct stu *p1,*p2,*head=NULL;
p1=p2=(struct stu *)malloc(dd);
printf("input num,name then enter\n");
scanf("%d,%s",&p1->num,&p1->name);
head=p1;
for(n=0;n<3;n++)
{p2->next=p1;
p2=p1;
if(n==2);
else
{p1=(struct stu *)malloc(dd);
printf("input num,name then enter\n");
scanf("%d,%s",&p1->num,&p1->name);
}
}
p2->next=NULL;
return(head);
}
void output(struct stu *head)/*輸出*/
{struct stu *p;
p=head;
while(p!=NULL)
{n++;
printf("%5d,%10s\n",p->num,p->name);
p=p->next;
}
}
/*插入*/
struct stu *charu(struct stu *head)
{struct stu *p1,*p2,*p3;
p2=(struct stu *)malloc(dd);
printf("input a point,num,name");
scanf("%d,%s",&p2->num,&p2->name);
p1=head;
n=0;
if (p2->num<p1->num)
{head=p2;head->next=p1;}
else
{for(n=1;n<3;n++)
{p3=p1;
p1=p1->next;
if (p2->num<p1->num)
{p3->next=p2;
p2->next=p1;
}
}
}
if(p1->num<p2->num)
{p1->next=p2;
p2->next=NULL;
}
return(head);
}
/*刪除*/
struct stu *delect(struct stu *head)
{struct stu *p1,*p2;
int m;
printf("input a num, then delete\n");
scanf("%d",&m);
p1=head;
p2=p1->next;
n=0;
if (m==p1->num)
head=p2;
else
{for(n=1;n<=3;n++)
{if (m==p2->num)
p1->next=p2->next;
p1=p2;
p2=p2->next;
}
}
return(head);
}
/*修改*/
struct stu *xiugai(struct stu *head)
{struct stu *p1;
int m;
printf("input the num, then xiugai\n");
scanf("%d",&m);
p1=head;
for(n=0;n<3;n++)
{if (m==p1->num)
{printf("xiu gai kai shi,input num,name\n");
scanf("%d,%s",&p1->num,&p1->name);
break;}
p1=p1->next;
}
return(head);
}
void main()
{struct stu *create(void);
struct stu *xiugai(struct stu *head);
struct stu *delect(struct stu *head);
struct stu *charu(struct stu *head);
void output(struct stu *head);
struct stu *head;int m;
head=create();
output(head);
printf("scan 1 to charu,2 to delet,3 to xiugai,please");
scanf("%d",&m);
switch(m)
{
case 1:head=charu(head);output(head);break;
case 2:head=delect(head);output(head);break;
case 3:head=xiugai(head);output(head);break;
}
}
⑧ 線性表順序存儲的12個基本操作，求c語言程序，在c++6.0環境下編譯的
#include<stdio.h>
typedef int elemType;
/************************************************************************/
/* 以下是關於線性表順序存儲操作的16種演算法 */
/************************************************************************/
struct List{
elemType *list;
int size;
int maxSize;
};
void againMalloc(struct List *L)
{
/* 空間擴展為原來的2倍，並由p指針所指向，原內容被自動拷貝到p所指向的存儲空間 */
elemType *p = realloc(L->list, 2 * L->maxSize * sizeof(elemType));
if(!p){ /* 分配失敗則退出運行 */
printf("存儲空間分配失敗! ");
exit(1);
}
L->list = p; /* 使list指向新線性表空間 */
L->maxSize = 2 * L->maxSize; /* 把線性表空間大小修改為新的長度 */
}
/* 1.初始化線性表L，即進行動態存儲空間分配並置L為一個空表 */
void initList(struct List *L, int ms)
{
/* 檢查ms是否有效，若無效的則退出運行 */
if(ms <= 0){
printf("MaxSize非法! ");
exit(1); /* 執行此函數中止程序運行，此函數在stdlib.h中有定義 */
}
L->maxSize = ms; /* 設置線性表空間大小為ms */
L->size = 0;
L->list = malloc(ms * sizeof(elemType));
if(!L->list){
printf("空間分配失敗! ");
exit(1);
}
return;
}
/* 2.清除線性表L中的所有元素，釋放存儲空間，使之成為一個空表 */
void clearList(struct List *L)
{
if(L->list != NULL){
free(L->list);
L->list = 0;
L->size = L->maxSize = 0;
}
return;
}
/* 3.返回線性表L當前的長度，若L為空則返回0 */
int sizeList(struct List *L)
{
return L->size;
}
/* 4.判斷線性表L是否為空，若為空則返回1, 否則返回0 */
int emptyList(struct List *L)
{
if(L->size ==0){
return 1;
}
else{
return 0;
}
}
/* 5.返回線性表L中第pos個元素的值，若pos超出范圍，則停止程序運行 */
elemType getElem(struct List *L, int pos)
{
if(pos < 1 || pos > L->size){ /* 若pos越界則退出運行 */
printf("元素序號越界! ");
exit(1);
}
return L->list[pos - 1]; /* 返回線性表中序號為pos值的元素值 */
}
/* 6.順序掃描(即遍歷)輸出線性表L中的每個元素 */
void traverseList(struct List *L)
{
int i;
for(i = 0; i < L->size; i++){
printf("%d ", L ->list[i]);
}
printf(" ");
return;
}
/* 7.從線性表L中查找值與x相等的元素，若查找成功則返回其位置，否則返回-1 */
int findList(struct List *L, elemType x)
{
int i;
for(i = 0; i < L->size; i++){
if(L->list[i] == x){
return i;
}
}
return -1;
}
/* 8.把線性表L中第pos個元素的值修改為x的值，若修改成功返回1，否則返回0 */
int updatePosList(struct List *L, int pos, elemType x)
{
if(pos < 1 || pos > L->size){ /* 若pos越界則修改失敗 */
return 0;
}
L->list[pos - 1] = x;
return 1;
}
/* 9.向線性表L的表頭插入元素x */
void inserFirstList(struct List *L, elemType x)
{
int i;
if(L->size == L->maxSize){
againMalloc(L);
}
for(i = L->size - 1; i >= 0; i--){
L->list[i + 1] = L ->list[i];
}
L->list[0] = x;
L->size ++;
return;
}
/* 10.向線性表L的表尾插入元素x */
void insertLastList(struct List *L, elemType x)
{
if(L->size == L ->maxSize){ /* 重新分配更大的存儲空間 */
againMalloc(L);
}
L->list[L->size] = x; /* 把x插入到表尾 */
L->size++; /* 線性表的長度增加1 */
return;
}
⑨ 線性表的基本操作
你用的是順序表還是鏈表啊?
舉個順序表的例子好了~
#include <stdio.h>
#define n 10
void main()
{
int i,j=0,LA[n],LB[n/2],LC[n-n/2];
printf("Please input LA array here:\n");
for(i=0;i<n;i++)
scanf("%d",&LA[i]);
for(i=0;i<n;i+=2)
{
LB[j++]=LA[i];
printf("%-3d",LB[j-1]);
}
j=0;
printf("\n");
for(i=1;i<n;i+=2)
{
LC[j++]=LA[i];
printf("%-3d",LC[j-1]);
}
printf("\n");
}
⑩ 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);
}