线性表的顺序存储结构——顺序表

2019-05-20 20:52:57 阅读：391 来源： 互联网

标签：顺序线性表 int while ++ length SqList data 顺序存储

一.基本运算的实现

1.建立顺序表

void CreateList(SqList * & L,ElemType a[],int n)  //由a中的n个元素建立顺序表
{
    int i = 0,k = 0;  //k表示L中的元素个数，初始值为0
    L = （SqList *）malloc(sizeof(SqList));  //分配线性表的空间
    while(i < n)
    {
        L->data[k] = a[i];  //将元素a[i]存放到L中
        k++;
        i++;
    }
    L->length = k;  //设置L的长度K
}

/* malloc(sizeof(数据类型))
   功能：分配存储空间
   返回值：所分配的内存区地址 */

2.初始化线性表

void InitList(SqList * & L)
{
    L = (SqList * )mallc(sizeof(SqList);  //分配存放线性表的空间
    L -> lenght = 0;
}

/* 1.&代表引用型指针，类似于地址共享。需要对主函数的值进行修改时，就要用&引用。
   2.（SqList *）为强制转换，强制malloc分配为SqList的空间大小。 */

3.销毁线性表

void DestroyList(SqList * & L)
{
    free(L);  //释放L所指的顺序表空间
}

// 若不进行销毁，尽管系统会自动释放顺序表指针变量L，但不会自动释放L所指向的存储空间，如此可能会造成内存泄漏。

4.判断线性表是否为空表

bool ListEmpty(SqList * L)
{
    return(L -> length == 0);
}
// 这里的“空”指空闲，不等于空白。只要L -> length == 0即为空表，不管表中是否有数据。

5.求线性表的长度

int ListLength(SqList * L)
{
    return(L -> length);
}

6.输出线性表

void DispList(SqList * L)
{
    int i = 0;
    for(i=0;i<L -> length;i++)
        printf("%d ",L -> data[i]);
    printf("\n");
}

7.求线性表中的第i个元素的值

bool GetElem(SqList * L,int i,ElemType &e)
{
    if(i<1 || i>L -> length)
        return false;
    e = L -> data[i-1];
    return true;
}

8.查找第一个与e相等的元素

int LocateElem(SqList * L,ElemType e)
{
    int i = 0;
    while(i<L -> length && L -> data[i]!=e)
        i++;
    if(i>=L -> length)
        return 0;
    else
        return i+1;
}

9.在第i个位置上插入新数据

void ListInsert(SqList * & L,int i,ElemType e)
{
    int j;
    if(i<1 || i>L -> length+1)
        return false;
    i--;
    for(j=L -> length;j>i;j--)
        L -> data[j] = L ->data[j-1];
    L -> data[i] = e;
    L -> length++;
    return true;
}

10.删除第i个数据元素

bool ListDelete(SqList * & L,int i,ElemType &e)
{
    int j;
    if(i<1 || i>L -> length)
        return false;
    i--;
    e = L -> data[i];
    for(j=i;j<L -> length-1;j++
        L -> data[j] = L -> data[j+1];
    L -> length--;
    return true;
}

二.应用示例

1.假设一个线性表采用顺序表表示，设计一个算法，删除其中所有制等于x的元素。要求算法的时间复杂度为O(n),空间复杂度为O(1).

//解法一
void delnode1(SqList * & L,ElemType x)
{
    int k=0,i;  //k记录不等于x的元素个数，即要插入到L中的元素个数
    for(i=0;i<L -> length;i++)
        if(L -> data[i] != x)  //若当前元素不为x，将其插入到L中
        {
             L -> data[k] = L -> data[i];
             k++;
        }
    L -> length = k;
}

//解法二
void delnode2(SqList * & L,ElemType x)
{
    int k=0,i=0;  //k记录等于x的元素个数
    while(i<L -> length)
    {
         if(L -> data[i]==x)  //当前元素为x时k增1
             k++;
         else  //当前元素不为x时将其前移k个位置
             L -> data[i-k] = L-> data[i];
         i++;
    }
    L -> length -= k;
}

2.有一个顺序表L，假设元素类型ElemType为整型，设计一个尽可能高效的算法，以第一个元素为分界线（基准），将所有小于等于它的元素一道该基准的前面，将所有大于它的元素移到该基准的后面。

//解法一
int partiton1(SqList * & L)
{
    int i=0,j=L->length-1;  //以data[0]为基准
    ElemType pivot = L->data[0];
    while(i < j)  //从区间两端交替向中间扫描，直到i=j为止
    {
        while(i<j && L->data[j]>pivot)  //从右向左扫描，找一个小于等于pivot的元素
            j--;
        while(i<j && L->data[i]<=pivot)  //从左向右扫描，找一个大于pivot的元素
            i++;
        if(i < j)
            swap(L->data[i],L->data[j]);
    }
    swap(L->data[0],L->data[i]);
}

//解法二
void partition2(SqList * & L)
{
    int i=0,j=L->length-1;
    ElemType pivot = L->data[0];  //以data[0]为基准
    while(i < j)  //从区间两端交替向中间扫描，直到i=j为止
    { 
        while(i<j && L->data[j]>pivot)
             j--;   //从右向左扫描，找一个小于等于pivot的data[j]
        L->data[i] = L->data[j];   //找到这样的data[j],放入data[i]处
        while(i<j && L->data[i]<=pivot)
             i++;   //从左向右扫描，找一个大于pivot的data[i]
        L->data[j] = L->data[i];   //找到这样的data[i],放入data[j]处
    }
     L->data[i] = pivot; 
}

3.有一个顺序表L，假设元素类型ElemType为整型，设计一个尽可能高效的算法，将所有奇数移动到偶数的前面。

//解法一
void move1(SqList * & L)
{
    int i=0,j=L->length-1;
    while(i < j)
    {
        while(i<j && L->data[j]%2==0)
            j--;  //从右向左扫描，找一个奇数元素
        while(i<j && L->data[i]%2==1)
            i++;  //从左向右扫描，找一个偶数
        if(i < j) 
            swap(L->data[i],L->data[j]);
    }
}

//解法二
void move2(SqList * & L)
{
    int i=-1,j;
    for(j=0;j<=L->length-1;j++)
        if(L->data[j]%2 == 1)  
        {
            i++;  //奇数区间个数增1
            if(i != j)
                swap(L->data[i],L->data[j]);
        }
}

标签：顺序,线性表,int,while,++,length,SqList,data,顺序存储
来源： https://www.cnblogs.com/ljlzl/p/10896311.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

线性表的顺序存储结构——顺序表