用Java实现线性表中的顺序存储的学习和源码（合并两个线性表）

线性表的优点：

无须为表示表中元素之间的逻辑关系而额外的增加存储空间

可以快速的存取表中任一位置的元素

线性表的缺点：

插入和删除操作需要移动大量的元素

当线性表的长度变化太大时，难以确定存储空间的容量

造成存储空间的碎片

public class ShunXu {



final int MAXSIZE = 20;
final int OK = 1;
final int ERORR = 0;
final int TRUE = 1;
final int FALSE = 0;


public static void main(String[] args) {
// TODO Auto-generated method stub


ShunXu shunxu = new ShunXu();
SqList La = new SqList();
SqList Lb = new SqList();
int e,j,k;
int i=shunxu.InitList(La);
System.out.println("初始化La后 ,La.length="+La.length);
   for(j=1;j<=5;j++)
           i=shunxu.ListInsert(La,1,j);
   System.out.printf("在La的表头依次插入1～5后：La.data=");
   shunxu.ListShow(La); 


   System.out.printf("La.length=%d \n",La.length);
   i=shunxu.ListEmpty(La);
   System.out.printf("La是否空：i=%d(1:是 0:否)\n",i);


   i=shunxu.ClearList(La);
   System.out.printf("清空La后：La.length=%d\n",La.length);
   i=shunxu.ListEmpty(La);
   System.out.printf("La是否空：i=%d(1:是 0:否)\n",i);


   for(j=1;j<=10;j++)
    shunxu.ListInsert(La,j,j);
   System.out.printf("在La的表尾依次插入1～10后：La.data=");
   shunxu.ListShow(La); 


   System.out.printf("La.length=%d \n",La.length);


   shunxu.ListInsert(La,1,0);
   System.out.printf("在La的表头插入0后：La.data=");
   shunxu.ListShow(La); 
   System.out.printf("La.length=%d \n",La.length);


   e=shunxu.GetElem(La,5);
   System.out.printf("第5个元素的值为：%d\n",e);
   for(j=3;j<=4;j++)
   {
           k=shunxu.LocalElem(La,j);
           if(k!=0)
             System.out.printf("第%d个元素的值为%d\n",k,j);
           else
             System.out.printf("没有值为%d的元素\n",j);
   }
   


   k=shunxu.ListLength(La); /* k为表长 */
   for(j=k+1;j>=k;j--)
   {
           i=shunxu.ListDelet(La,j); /* 删除第j个数据 */
           if(i==shunxu.ERORR)
             System.out.printf("删除第%d个数据失败\n",j);
           else
             System.out.printf("删除第%d个的元素值为：%d\n",j,i);
   }
   System.out.printf("依次输出La的元素：");
   shunxu.ListShow(La); 


   j=5;
   shunxu.ListDelet(La,j); /* 删除第5个数据 */
   System.out.printf("删除第%d个的元素值为：%d\n",j,e);


   System.out.printf("依次输出La的元素：");
   shunxu.ListShow(La); 


//构造一个有10个数的Lb
i=shunxu.InitList(Lb);
   for(j=6;j<=15;j++)
           i=shunxu.ListInsert(Lb,1,j);


   System.out.printf("依次输出Lb的元素：");
   shunxu.ListShow(Lb);
   shunxu.UnionL(La,Lb);


System.out.printf("依次输出合并了Lb的La的元素：");
shunxu.ListShow(La);
}
//初始化顺序线性表
public int InitList(SqList L)
{
L.data = new int[MAXSIZE];
L.length=0;
return OK;
}
//初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
public int ListEmpty(SqList L)
{
if(L.length==0)
return TRUE;
else
return FALSE;
}
//初始条件：顺序线性表L已存在。操作结果：将L重置为空表
public int ClearList(SqList L)
{
L.length=0;
return OK;
}
//初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数
public int ListLength(SqList L)
{
return L.length;
}
// 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
//操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
public int GetElem(SqList L,int i)
{
if(L.length==0||i<1||i>L.length)
return ERORR;
else
   return (Integer) L.data[i-1];

}
/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
public int LocalElem(SqList L,int 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;
}
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
public int ListInsert(SqList L,int i,int e)
{
int k;
if (L.length==MAXSIZE)  /* 顺序线性表已经满 */
return ERORR;
if (i<1 || i>L.length+1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
return ERORR;


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 */
public int ListDelet(SqList L,int i)
{
int k;
   if (L.length==0)               /* 线性表为空 */
return ERORR;
   if (i<1 || i>L.length)         /* 删除位置不正确 */
       return ERORR;
   int temp = 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 temp;
}


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

public int visit(int c)
{
System.out.print(c+" ");
return OK;
}

public void UnionL(SqList La,SqList Lb)
{
int La_len,Lb_len,i;
int e;
La_len=ListLength(La);
Lb_len=ListLength(Lb);
for (i=1;i<=Lb_len;i++)
{
e=GetElem(Lb,i);
if (LocalElem(La,e)==0)
ListInsert(La,++La_len,e);
}
}
}


class SqList
{
int data[] ;
int length;
}