线性表的顺序存储

Java代码  

1. package com.stucture.sqlList;  
2.   
3. /** 
4.  * 线性表顺序存储结构的接口 
5.  * 指的是用一段地址连续的存储单元一次存储线性表的数据元素 
6.  * @ClassName: ISeqList  
7.  * @author 小学徒 
8.  * @date 2013-2-27 
9.  */  
10. public interface ISeqList<T> {  
11.       
12.     /** 
13.      * 获得元素 
14.      * @param i 需要获得的第i个元素 
15.      * @return  
16.      */  
17.     public T getElem(int i);  
18.       
19.   
20.     /** 
21.      * 插入元素 
22.      * @param i 元素的插入位置 
23.      * @param t 需要插入的元素 
24.      * @return  是否成功插入 
25.      */  
26.     public boolean insertElem(int i, T t);  
27.       
28.     /** 
29.      * 删除元素 
30.      * @param i 需要删除元素的位置 
31.      * @return 
32.      */  
33.     public T deleteElem(int i);  
34. }  

Java代码  

1. package com.stucture.sqlList;  
2.   
3. /** 
4.  * 线性表顺序存储结构 
5.  * 指的是用一段地址连续的存储单元一次存储线性表的数据元素 
6.  * @ClassName: SeqList  
7.  * @author 小学徒 
8.  * @date 2013-2-27 
9.  */  
10. public class SeqList<T> implements ISeqList<T> {  
11.     public static final int MAXSIZE = 20;   //存储空间的初始化配量  
12.       
13.     private T[] data;   //数组存储数据元素  
14.     private int length; //线性表当前长度         
15.       
16.     public SeqList() {  
17.         data = (T[]) new Object[MAXSIZE];  
18.     }  
19.       
20.     // 获得元素  
21.     public T getElem(int i) {  
22.         if(i < 0 || i >MAXSIZE) {  
23.             return null;  
24.         }  
25.         T t = data[i - 1];  
26.         return t;  
27.     }  
28.   
29.     // 插入元素  
30.     public boolean insertElem(int i, T t) {  
31.         if(length == MAXSIZE) { //线性表已经满了  
32.             System.out.println("该线性表已经满了");  
33.             return false;  
34.         }  
35.           
36.         if(i < 1 || i > MAXSIZE) {    //插入位置不在范围内  
37.             System.out.println("该位置不合法");  
38.             return false;  
39.         }  
40.           
41.         if(i < length) { //插入位置不在表尾  
42.               
43.             for(int j = length; j >= i; j--) {   //将要插入位置后数据元素向后移动一位  
44.                 data[j] = data[j - 1];  
45.             }  
46.         }  
47.         data[i - 1] = t;    //插入新元素  
48.         length++;   //线性表长度增加  
49.         return true;  
50.     }  
51.       
52.     //删除元素  
53.     public T deleteElem(int i) {  
54.           
55.         if(length == 0) {   //"线性表为空"  
56.             System.out.println("线性表为空");  
57.             return null;   
58.         }  
59.   
60.         if(i < 1 || i > length) { //删除位置不在范围内  
61.             System.out.println("该位置不合法");  
62.             return null;  
63.         }  
64.         T t = data[i -1];  
65.         for(int j = (i - 1); j <= (length - 1); j++) {  
66.             data[j] = data[j+1];  
67.         }  
68.         length--;//线性表长度减少  
69.         return t;  
70.           
71.     }  
72.       
73.     public T[] getData() {  
74.         return data;  
75.     }  
76.   
77.     public void setData(T[] data) {  
78.         this.data = data;  
79.     }  
80.   
81.     public int getLength() {  
82.         return length;  
83.     }  
84.   
85.     public void setLength(int length) {  
86.         if(length < 0 || length > MAXSIZE) {  //删除位置不在范围内  
87.             System.out.println("长度不合法");  
88.         }  
89.         this.length = length;  
90.     }  
91.       
92. }  

Java代码  

1. package com.stucture.sqlList;  
2.   
3. import java.util.Random;  
4.   
5. public class SeqListTest {  
6.     final int MAX = 25;  
7.     Random r = new Random();  
8.     SeqList<Integer> seqList;  
9.       
10.     public SeqListTest() {  
11.         initSeqList();  
12.     }  
13.       
14.     //创建一个线性表顺序存储结构  
15.     public void initSeqList() {  
16.   
17.         seqList = new SeqList<Integer>();  
18. //      int length = (int) Math.random();   //只能产生0.0 - 1.0之间的double随机数  
19.         int length = Math.abs(r.nextInt(MAX));  //使用Random随机产生一个25左右的值,使用Math.abs()函数来取绝对值    
20.         System.out.println("产生的数组长度为 ：" + length);  
21.           
22.         if(length > SeqList.MAXSIZE) {  
23.             System.out.println("该长度不合法");  
24.         }  
25.           
26.         for (int i = 1; i <= length; i++) {  //为生成的数组赋值，同时也测试了插入值的方法  
27.             int j =r.nextInt(MAX);  
28.             System.out.print(j + " ");  
29.               
30.             if(!seqList.insertElem(i, j)) {  
31.                 System.exit(0);   
32.             }  
33.         }  
34.         System.out.println("\n原始数组是 ：");  
35.         display(seqList);  
36.     }  
37.       
38.     //测试删除方法  
39.     public void deleteElem() {  
40.         int i = r.nextInt(MAX);  
41.         System.out.println("\n\n删除的位置是：" + i);  
42.         Integer deleteNumber = seqList.deleteElem(i);  
43.           
44.         if( deleteNumber == null) {  
45.             System.exit(0);  
46.         } else {  
47.             System.out.println("删除的元素是 ： " + deleteNumber);  
48.             System.out.println("删除元素后数组是 ：");  
49.             display(seqList);  
50.         }  
51.     }  
52.       
53.     //测试随机插入方法  
54.     public void insertByRandom() {  
55.         int i = r.nextInt(MAX);  
56.         System.out.println("\n\n随机插入位置是 ：" + i);  
57.         int elem = r.nextInt(MAX);  
58.         System.out.println("随机插入数据是 ：" + elem);  
59.         seqList.insertElem(i, elem);  
60.         System.out.println("随机插入数据后数组是 ：");  
61.         display(seqList);  
62.     }  
63.       
64.     //数据展示  
65.     public  void display(SeqList seqList) {  
66.         for (int i = 1; i < seqList.getData().length; i++) {  
67.               
68.             if(seqList.getElem(i) != null) {  
69.                 System.out.print(seqList.getElem(i) + " ");  
70.             }  
71.               
72.         }  
73.         System.out.println("数组的长度为 ：" + seqList.getLength());  
74.     }  
75.       
76.     //获取元素  
77.     public void getElem() {  
78.         int i = r.nextInt(MAX);  
79.         System.out.println("\n获取位置为 ：" + i);  
80.         System.out.println("获取到的元素为 : " + seqList.getElem(i));  
81.           
82.           
83.     }  
84.       
85.     public static void main(String[] args) {  
86.         SeqListTest s = new SeqListTest();  
87.         s.insertByRandom();  
88.         s.deleteElem();  
89.         s.getElem();  
90.     }  
91. }  

运行结果代码  

1. 产生的数组长度为 ：15  
2. 9 8 22 23 18 0 6 0 19 1 7 24 11 10 18   
3. 原始数组是 ：  
4. 9 8 22 23 18 0 6 0 19 1 7 24 11 10 18 数组的长度为 ：15  
5.   
6.   
7. 随机插入位置是 ：21  
8. 随机插入数据是 ：5  
9. 该位置不合法  
10. 随机插入数据后数组是 ：  
11. 9 8 22 23 18 0 6 0 19 1 7 24 11 10 18 数组的长度为 ：15  
12.   
13.   
14. 删除的位置是：1  
15. 删除的元素是 ： 9  
16. 删除元素后数组是 ：  
17. 8 22 23 18 0 6 0 19 1 7 24 11 10 18 数组的长度为 ：14  
18.   
19. 获取位置为 ：7  
20. 获取到的元素为 : 0  

 （C版之动态分配）

#include<string.h>
#include<ctype.h>
#include<malloc.h>//malloc()等
#include<limits.h>//INT_MAX等
#include<stdio.h>//EOF（=^Z或F6）,NULLL
#include<stdlib.h>//ato()
#include<math.h>//float(),ceil(),abs()
#include<io.h>//eof()
#include<process.h>//exit()
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
//#define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3 ，故去掉此行
typedef int Status;//Status是函数的类型，其值是函数结果状态代码，如OK等
typedef int Boolean;//Boolean是布尔类型，其值是TRUE或FALSE

//c2.h线性表的动态分配顺序储存结构
#define LIST_INIT_SIZE 100  //线性表储存空间的初始分配量
#define LISTINCREMENT  10   //线性表存储空间的分配增量
typedef struct{
 ElemType *elem;    //储存空间基址
 int      length;   //当前长度
 int      listsize; //当前分配的储存容量（以sizeof(ElemType)为单位）
}SqList;

//c3.h顺序表示的线性表的基本操作（12个）

//注：p19各个函数的实现

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
 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;
}

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

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

int LocateElem(SqList L,ElemType e,Status (*compare)(ElemType,ElemType)){ //算法2.6
//初始条件：顺序线性表L已存在，compare是数据元素判定函数，满足为1，不满足为0
//操作结果：返回L中第一个与e满足compare（）的数
 ElemType *p;
 int i=1;//i的初值为第一个元素的位序
 p=L.elem;//p的初值为第一个元素的存储位置
 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){
//初始条件：顺序线性表已存在
//操作结果：若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)//当前存储空间已满，增加分配
 {
  newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
  if(!newbase) 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的每个数据元素调用visit()函数，一旦visit()失败，则操作失败
 ElemType *p;
 int i;
 p=L.elem;
 for(i=1;i<=L.length;i++)
  vi(p++);
 printf("\n");
 return OK;
}

//main (检验基本操作的主程序）
#include "c1.h"
typedef int ElemType;
#include "c2.h"
#include "c3.h"
void main(){
 //定义试验用变量
 SqList L;
 ElemType e;
 Status i;
 int j,k;
 //初始化顺序线性表
 i=InitList(&L);
 printf("初始化L后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem ,L.length,L.listsize);

//在顺序线性表L中插入元素1~5
  for (j=1;j<=5;j++)
  {i=ListInsert(&L,1,j);}
  //输出顺序线性表
  printf("在L的表头依次插入1~5后：*L.elem=");
  for(j=1;j<=5;j++)
   printf("%d",*(L.elem +j-1));
  printf("\n");
   printf("L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
  //判断线性表是否为空
  i=ListEmpty(L);
  printf("L是否为空：L=%d(1:是 0否)\n",i);
  //清空顺序线性表，判断其是否为空
  i=ClearList(&L);
  printf("清空L后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
  i=ListEmpty(L);
  printf("L是否为空：L=%d（1：是 0：否）\n",i);
  //在顺序线性表L的尾端插入元素1~10
  for(j=1;j<=10;j++)
   ListInsert(&L,j,j);
  printf("在L的表尾依次插入1~10后：*L.elem=");
  //输出顺序线性表L
  for(j=1;j<=10;j++)
   printf("%d",*(L.elem+j-1));
  printf("\n");
  printf("L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
  //输出顺序线性表长度以外的值，顺序线性表最后一个值

  k=ListLength(L);//k为表长
  for(j=k+1;j>=k;j--){
   i=ListDelete(&L,j,&e);//删除第j个数据
   if(i==ERROR)
    printf("删除第j个元素失败\n");
  else
   printf("删除的元素的值为：%d\n",e);
  }

  //销毁顺序线性表
  DestroyList(&L);
  printf("销毁L后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
}

(c版之二)

#include "stdio.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int ElemType;   /* ElemType类型根据实际情况而定，这里假设为int */
typedef int Status;     /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef struct
{
  ElemType data[MAXSIZE]; /* 数组，存储数据元素 */
  int length;             /* 线性表当前长度 */
}SqList;

/* 初始化顺序线性表 */
Status InitList(SqList *L)
{
    L->length=0;
    return OK;
}

//顺序表的建立
SqList Create(SqList L)
{
    int i;
    srand((unsigned)time(NULL));
  for(i=0; i < 10; i++)
  {
    L.data[i] = rand()%100;
        L.length++;
  }
    return L;
}

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


/*初始条件：ListTraverse函数调用 */
/*操作结果：打印对应元素 */
Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(SqList L)
{
  int i;
    for(i=0;i < L.length;i++)
        visit(L.data[i]);
    printf("\n");
    return OK;
}

/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L,int i,ElemType e)
{
  int k;
  if (L->length==MAXSIZE)  /* 顺序线性表已经满 */
    return ERROR;
  if (i < 1 || i>L->length+1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
    return ERROR;
    
  if (i <= L->length)        /* 若插入数据位置不在表尾 */
  {
    for(k=L->length-1;k>=i-1;k--)  /* 将要插入位置之后的数据元素向后移动一位 */
      L->data[k+1]=L->data[k];
  }
  L->data[i-1]=e;          /* 将新元素插入 */
  L->length++;
    
  return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e)
{
    int k;
    if (L->length==0)               /* 线性表为空 */
    return ERROR;
    if (i < 1 || i>L->length)         /* 删除位置不正确 */
        return ERROR;
    *e=L->data[i-1];
    if (i < L->length)                /* 如果删除不是最后位置 */
    {
        for(k=i; k < L->length; k++)/* 将删除位置后继元素前移 */
      L->data[k-1]=L->data[k];
    }
    L->length--;
    return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L,int i,ElemType *e)
{
    if(L.length==0 || i < 1 || i>L.length)
        return ERROR;
    *e=L.data[i-1];
    
    return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L的长度。 */
int ListLength(SqList L)
{
    return L.length;
}

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

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqList L,ElemType e)
{
    int i;
    if (L.length==0)
        return 0;
    for(i=0;i < L.length;i++)
    {
        if (L.data[i]==e)
            break;
    }
    if(i>=L.length)
        return 0;
    
    return i+1;
}

int main()
{
    SqList L;
    ElemType e;
    Status i;
    int opp;
    int j,k;
    int pos;
    ElemType value;
    
    i=InitList(&L);
    printf("初始化成功，L.length=%d\n",L.length);
    printf("\n1.遍历线性表 \n2.线性表赋值 \n3.清空线性表 \n4.线性表插入 \n5.查找表中元素 \n6.判断元素是否在表中 \n7.删除某个元素 \n8.线性表长度\n9.线性表是否为空\n0.退出 \n请选择你的操作：\n");
    while(opp != 0){
        scanf("%d",&opp);
        switch(opp){
            case 1:
                ListTraverse(L);
                printf("\n");
                break;
                
            case 2:
                L = Create(L);
                printf("创建随机链表：L.data=");
                ListTraverse(L);
                printf("\n");
                break;
                
            case 3:
                i=ClearList(&L);
                printf("清空L后：L.length=%d\n",L.length);
                ListTraverse(L);
                printf("\n");
                break;
                
                
            case 4:
                printf("请输入插入元素位置：");
                scanf("%d",&pos);
                printf("请输入插入元素的值：");
                scanf("%d",&value);
                i = ListInsert(&L,pos,value);
                printf("插入完毕，现在线性表为：\n");
                ListTraverse(L);
                printf("\n");
                break;
                
            case 5:
                printf("你要查找第几个元素？ ");
                scanf("%d",&pos);
                GetElem(L,pos,&e);
                printf("第%d个元素的值为：%d\n",pos,e);
                break;
                
            case 6:
                printf("输入你想知道是否在表中的数值： ");
                scanf("%d",&e);
                k=LocateElem(L,e);
                // 这里假定随机数组中的元素互不重复
                if(k)
                    printf("值为%d是表中的第%d个元素\n",e,k);
                else
                    printf("没有值为%d的元素\n",e);
                break;
                
            case 7:
                printf("要删除第几个元素？");
                scanf("%d",&pos);
                ListDelete(&L,pos,&e);
                printf("删除完毕，现在线性表为：\n");
                ListTraverse(L);
                printf("\n");
                break;
                
            case 8:
                k = ListLength(L);
                printf("线性表的长度为: %d \n", k);
                break;
                
            case 9:
                i = ListEmpty(L);
                if (i)
                    printf("该线性表为空.\n");
                else
                    printf("该线性表非空\n");
                break;
                
            case 0:
                exit(0);
        }
    }
}

（C版之三）

1. #define MAXLENGTH 20  
2.   
3. struct sequencelist  
4. {  
5.     int data[MAXLENGTH];  
6.     int length;  
7. };  

其中data数组为这个线性表的主要部分，数据元素就存在于此数组中，而对这个线性表的操作都是基于这个数组。

length是这个线性表的一个属性，表示这个线性表包含元素的个数。

增：线性表的插入操作

对线性表的插入就是对data数组的插入，然后将其length增加。

删：线性表的删除操作

类似增的相反操作。

查：线性表的取元素操作

用索引值查找元素的值。

从程序中可以看出增删操作的时间复杂度都是0(n)，所以这两项操作都是不是它的强项。而查找操作的时间复杂度是O(1)，那么线性表的顺序存储结构的优势就是可以快速的取出任意位置的元素。

上面的3种操作作为较为基本的操作，是本人的学习笔记。如果大虾们发现哪里有不妥，请不吝赐教。

而线性表的其他操作如求前驱元素、求后驱元素、判断表中是否存在某元素值、清空操作等等有意思的操作还待空闲时去完成。

较为完整的调试例子：

(C++版)

#include<iostream>
using namespace std;
int const maxsize = 100; // 线性表的最大可容纳量
class sequentlist{   //建立线性表的类
public:
 int a[100];
 
 
 int len; //线性表的实际长度

//获取线性表中的元素

 void Get(sequentlist L)
 {
  
  for (int i = 0; i <= L.len - 1; i++)
  {
   cout  << "线性表第" << i+1<<"的元素是";
   cin >> a[i];
  }
  cout << endl;
 }
//输出线性表的元素
 void Getout(sequentlist L)
 {
  cout << "L = {" ;
 for (int i = 0; i <= L.len-1; i++)
  {
   cout << a[i] << "  ";
  }
 cout << "}";
 cout << endl;
 }

//查找元素x在线性表中的位置

 void Locate( sequentlist L,int x)
{
 
 int temp = -1;
 for(int i = 0;i <= L.len;i++)  //如果x在顺序表中就将序号记录在temp中
 { 
 if(a[i] == x)  {temp = i;
  cout << "元素" << x << "的位置是" << temp << endl;
  
 }
 }
 if(temp == -1) cout << x <<"元素不在表中" << endl; //如果元素不存在就输出错误
}
//将元素x插入到第i个位置
void Insert( sequentlist & L,int x,int i)
{
 if (L.len >= 100)  //判断插入是否合法
  cout << "顺序表已满！" << endl;
 else if((i < 1) || (i > L.len + 1))
 
  cout << "插入的位置不合理！" << endl;
 else   
 {
  for(int j = L.len; j >= i; j--)  //将i位置之后的元素后移一位
   L.a[j+1] = L.a[j];
   L.a[i] = x;  //将x插入到i位置
   L.len++;
 
 }
 
}
//删除元素
void sequentlist::Delete(sequentlist &L,int i)
{
 if((i<0) || (i >= L.len + 1))  cout << "删除位置不合法！"; 
 else
 {
  cout << "删除第" << i << "个位置元素" << endl;
  
  for(int j = i;j < L.len - 1; j++)  //将i位置之后的元素都前移一位
   a[j] = a[j+1];
  L.len--;
 
 }   
}

//求交集操作
void Intersection(sequentlist &LA,sequentlist &LB,sequentlist &LC)
{
 int temp = 0;
 LC.len = 0;
 //将a中的元素赋给c中
 for(int i = 0; i < LA.len; i++)
  LC.a[i] = LA.a[i];
  LC.len = i;
 //将b中的元素依次与c中的元素比较
 for(int j = 0; j < LB.len;j++)
 {
  for(int i = 0; i < LA.len;i++)
  {
   
   if(LC.a[i] == LB.a[j])
    temp++;
  }
  if(temp == 0) //如果b中的元素j不在c中则将b中的元素放在c中
  {
   
   LC.a[LC.len] =LB.a[j];
   LC.len = LC.len + 1;
  }
 }
}
//求并集
void sequentlist::Union(sequentlist &LA,sequentlist &LB,sequentlist &LC)
{
int i,j;
LC.len = 0;

//先将a中的元素赋到c中
for( i = 0; i < LA.len;i++)
{
 LC.a[i] = LA.a[i];

}
LC.len = i;
//将b中的元素插入到c的后面
for( j = 0;j < LB.len;j++)
{
 LC.a[LC.len + j] = LB.a[j];
 
}
LC.len = i + j;
//对c中的元素进行排序,升序排列
for(int t = LC.len -1; t > 0; t--)
{
 for( j = 0; j < t;j++)
  if( LC.a[j] > LC.a[j+1])
  {
   int temp;  //临时交换变量
   temp = LC.a[j+1];
   LC.a[j+1] = LC.a[j];
   LC.a[j] = temp;
  }
}
}

};

void main(){
 
    //定义线性表L
 sequentlist L;
 L.len = 10;  //定义L的实际表长
 L.Get(L); //控制台输入L的元素
 L.Getout(L);  //输出插入后的线性表L

 L.Locate(L,10); //查找元素10是否在线性表中
 L.Insert(L,3,5);  //将元素3查到第5个位置
 L.Getout(L);

 L.Delete(L,2); //删除L的第2个位置上的元素
 L.Getout(L);
 //定义线性表
 sequentlist LA , LB,LC;
 LA.len = 4;
 LA.Get(LA);
 LB.len = 7;
 LB.Get(LB);
 //求线性表的a与b并集，并逆序排列
 LC.Union(LA,LB,LC);
 LC.Getout(LC);
 //求 线性表a与b的交集
 LC.Intersection(LA,LB,LC);
 LC.Getout(LC);

}