数据结构-----线性表的顺序表示与实现

废话不多说，直接粘代码，一切尽在代码中。

LIST.h当中代码：

/* 
* Copyright (c) 2014,个人所有
* All rights reserved. 
* 
* 文件名称：LIST.h
* 文件标识：见配置管理计划书
* 摘  要：线性表的顺序存储
* 
* 当前版本：1.1
* 作  者：zhuxuekui3
* 完成日期：2014年5月4日
* 
* 取代版本：1.0 
* 原作者  ：zhuxuekui3
* 完成日期：2014年5月3日
*/
#ifndef LIST_H
#define  LIST_H
#include <iostream>
using namespace std;
//定义函数结果状态代码  
#define TRUE        1  
#define FALSE       0  
#define OK          1  
#define ERROR       0  
#define OVERFLOW    -1  
#define UNDERFLOW   -2  

/********线性表的动态分配顺序存储结构******/
const int LIST_INIT_SIZE = 100;
const int LISTINCREMENT = 10;

typedef int ElemType;
typedef int Status;
typedef bool (* comparePtr)(ElemType,ElemType);
//comparePtr compare; //用comparePtr来申明全局compare变量
typedef struct SqList
{
    ElemType *elem; //存储空间基址 , 数组指针elem指示线性表的基地址。数组首地址
    int length;    //当前长度，记录数组的长度
    int listsize; //当前分配的存储容量（以sizeof（ElemType）为单位）
} SqList;

//初始化顺序表
Status InitList_Sq(SqList &L);
//在顺序表L中第i个位置之前插入新的元素e
Status ListInsert_Sq(SqList &L,int i,ElemType e);
//在顺序表L中第i个位置删除元素e，并用e返回其值
Status ListDelete_Sq(SqList &L,int i,ElemType &e); //改.C文件的同时必须改声明
//将顺序表中的元素输出
Status ListPrint_Sq(SqList &L);
//对无序的两个顺序表求并集
void union1(SqList &La, SqList &Lb);

void union2(SqList &La, SqList &Lb);

bool equal(ElemType a, ElemType b);

//在顺序表中查找与e相同的元素，并返回e所在的位置
//int LocateElem_Sq(SqList &L,ElemType e,bool (* compare)(ElemType,ElemType));

int LocateElem_Sq(SqList &L,ElemType e,comparePtr compare);

//取顺序表中第i个元素赋给e
Status GetElem(SqList &L,int i,ElemType &e);
//好像对不需要传回来的数据，并不需要用引用，用形参就可以了
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc);

#endif 

 LIST.cpp代码：

/* 
* Copyright (c) 2014,个人所有
* All rights reserved. 
* 
* 文件名称：LIST.cpp
* 文件标识：见配置管理计划书
* 摘  要：线性表的顺序存储
* 
* 当前版本：1.1
* 作  者：zhuxuekui3
* 完成日期：2014年5月4日
* 
* 取代版本：1.0 
* 原作者  ：zhuxuekui3
* 完成日期：2014年5月3日
*/
#include "stdafx.h"
#include "LIST.h"
int main()
{
    ElemType e;
    SqList L;
    SqList L1;
    SqList L2;//无需要初始化，会在函数当中初始化
    InitList_Sq(L);
    InitList_Sq(L1);
    //InitList_Sq(L2);
    ListInsert_Sq(L,1,9);
    ListInsert_Sq(L,2,7);
    ListInsert_Sq(L,3,4);
    ListInsert_Sq(L,4,2);
    ListPrint_Sq(L);

    ListInsert_Sq(L1,1,8);
    ListInsert_Sq(L1,2,6);
    ListInsert_Sq(L1,3,5);
    ListInsert_Sq(L1,4,3);

    ListPrint_Sq(L1);

    MergeList_Sq(L,L1,L2);
    //union2(L,L1);
    //ListDelete_Sq(L,1,e);
    //cout << e << endl;
    ListPrint_Sq(L2);
    return 0;
}

//初始化线性表
Status InitList_Sq(SqList &L)
{
   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;
}

//在顺序表L中第i个位置之前插入新的元素e
Status ListInsert_Sq(SqList &L,int i,ElemType e)
{
    //  1<=i<=L.length + 1; 有效范围
   if(i<1 || i>L.length + 1) return ERROR;
   if (L.length > L.listsize)//当前分配的内存已满，已int为一个单位，需要重新开辟内存空间
   {
       ElemType* newbase = (ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
       if (!newbase)//分配未成功
       {
           exit(OVERFLOW);
       }
       L.elem = newbase;//new address
       L.listsize += LISTINCREMENT;// add store memery
   }

   ElemType * q = &(L.elem[i-1]);
   ElemType * p = &(L.elem[L.length - 1]);  //这里可以改为 = L.elem + L.length - 1;
   for (p; p >= q; --p)    //一直循环到p = q为止
   {
       *(p+1) = *p;      //小下标的数，返回给大下标的数
   }
   *q = e;               //插入e；
   ++L.length;           //表长加1；
   return OK;
}


Status ListDelete_Sq(SqList &L,int i,ElemType &e)
{
    if(i<1 || i>L.length + 1) return ERROR;
    ElemType *q = &(L.elem[i-1]);
    ElemType *p = &(L.elem[L.length-1]);
    e = *q;
    for (q;q<=p;++q)   //将下标大的数赋值给下标小的数
    {
       *q = *(q+1);
    }
   --L.length;
   return OK;
}

Status ListPrint_Sq(SqList &L)
{
   ElemType *p = &(L.elem[0]);
   ElemType *q = &(L.elem[L.length-1]);
   for (p;p<=q;++p)
   {
       cout << *p << "  ";
   }
   cout << endl;
   return OK;
}

//对无序的两个顺序表求并集
/*
   有两种思路，要么重新开辟一个Lc，然后将两者插入进去，不允许重复。但操作这种方法时候，
   要求我们先排序。这样操作才方便些。时间复杂度Length(La)+Length(Lb).
   或者，我们用控制变量法，这种方法时间复杂度Length(La)*Length(Lb).
   说白了，就是以空间换时间，或者以时间换空间，别无其他。
*/
//时间复杂度Length(La)*Length(Lb)，节省了空间。
//下面语句是提取相同的元素到La中去，不是求并集，切记。
void union1(SqList &La, SqList &Lb)
{
   ElemType *q1 = &(La.elem[0]);
   ElemType *p1 = &(La.elem[La.length-1]);
   
   ElemType *q2 = &(Lb.elem[0]);
   ElemType *p2 = &(Lb.elem[Lb.length-1]);
   ElemType *temp = q2; //这里面是用的常量在初始化，并不是用变量在初始化指针。

   int count = 1;
   /*下面的语句，用&(La.elem[La.length-1])，不可用p1,p1是不变的，而我们插入的话
     La是在变动的，所以不可以用一个不变的东西去代替。但p2是不变的，无所谓。
   */
   for(q1; q1<= &(La.elem[La.length-1]); ++q1)
   {       
       for (q2;q2<=p2;++q2)
       {
           if (*q1==*q2)
           {
              ListInsert_Sq(La,count,*q1);
              ++q1;     //注意：La是在变动的。
              ++count; //严格控制插入的位置，La在变，指针位置相对的移动一个位置，所以
                      //与La相关的count也是需要变动的。
           }
       }
       q2 = temp;
       ++count;
   }
}
//将所有在Lb中但不在La中的数据元素插入到La中去
void union2(SqList &La, SqList &Lb)
{
   int La_Len = La.length;
   int Lb_Len = Lb.length;
   ElemType e = 0;
   for (int i = 1; i <= Lb_Len; ++i)
   {
       GetElem(Lb,i,e);//取Lb中的第i个数据元素赋给e
       if (!LocateElem_Sq(La,e,equal))//La中不存在和e相同的元素，则插入
       {
          ListInsert_Sq(La,++La_Len,e);
       }
   }
}

//在顺序表中查找与e相同的元素，并返回e所在的位置 comparePtr compare
//int LocateElem_Sq(SqList &L,ElemType e,bool (* compare)(ElemType,ElemType))
int LocateElem_Sq(SqList &L,ElemType e,comparePtr compare)
{
    //若找到，则返回其在L中的位置，否则返回0；
    int i = 1;
    ElemType *p = L.elem;//第一个元素的位置
    while(i <= L.length && !(compare(*p++,e))) ++i; //这里通过compare指针来执行传递过来的函数
    if (i <= L.length)                 //注意：compare所指的函数是有一个参数的。
    {
        return i;
    }
    else
    {
        return 0;
    }
}

Status GetElem(SqList &L,int i,ElemType &e)
{
    if(i<1 || i>L.length + 1) 
    return ERROR;
    e = L.elem[i-1];
    return OK;
}

bool equal(ElemType a, ElemType b)
{
    if (a == b)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//已知顺序表中La与Lb有序，归并
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc)
{
   ElemType *pa = La.elem;
   ElemType *pa_last = La.elem + La.length - 1;

   ElemType *pb = Lb.elem;
   ElemType *pb_last = Lb.elem + Lb.length - 1;

   Lc.length = La.length + Lb.length;
   Lc.listsize = Lc.length;//数组的长度
   Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType));//数组的容量
   if (!Lc.elem) //内存分配失败 ，即返回0，！之后就变成真了。
   {
       exit(OVERFLOW);
   }
   ElemType *pc = Lc.elem;

   while(pa <= pa_last && pb <= pb_last)  //降序排列
   {
       if (*pa < *pb)
       {
           *pc++ = *pb++;  //pc是需要移动的
       }
       else if (*pa == *pb)
       {
           *pc++ = *pa++;
           pb++;
       }
       else
       {
           *pc++ = *pa++;
       }

   }
   while(pa <= pa_last)  *pc++ = *pa++;
   while(pb <= pb_last)  *pc++ = *pa++;
   
}