顺序表

1. 什么是线性结构？ 

线性表是n个具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，常用的线性表包括顺序表、链表、栈、队列、字符串

2.什么是顺序表？顺序表的分类？

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删改查

3.动态顺序表的基本操作

Seqlist.h

#pragma once

//动态的顺序表（数组的元素不确定）

typedef int Datatype;   
typedef struct Seqlist
{
    Datatype* _array;
    int _capacity;//顺序表的总大小
    int _size;//顺序表中有效元素的个数
}Seqlist,* PSeq;//Seqlist和*PSeq为结构体类型

//typedef struct Seqlist Seqlist;
//typedef struct Seqlist* PSeqlist;

void Seqlistinit(PSeq ps,int capacity);//顺序表的初始化

void Seqlistpushback(PSeq ps,Datatype data);//顺序表存放元素（尾插）
void Seqlistpopback(PSeq ps);//尾删

void Seqlistpushfront(PSeq ps,Datatype data);//顺序表存放元素（头插）
void Seqlistpopfront(PSeq ps);//头删

void Seqlistinsert(PSeq ps,int pos,Datatype data);//中间插入元素
void Seqlisterase(PSeq ps,int pos);//中间删除元素

int Seqlistfind(PSeq ps,Datatype data);
int Seqlistsize(PSeq ps);
int Seqlistcapacity(PSeq ps);

int Seqlistempty(PSeq ps);//顺序表是否为空

void Seqlistdestory(PSeq ps);//顺序表的清除

void Seqlistremove(PSeq ps,Datatype data);//移除第一个值为data的元素

void Bubblesort(PSeq ps);//冒泡排序

int binarysearch(PSeq ps,Datatype data);//二分查找

//void Seqlistremoveall(PSeq ps,Datatype data);//移除所有值为data的元素

void Checkcapacity(PSeq ps);

void Seqlistclear(PSeq ps);

void Testseqlist();

 

 

test.c

#include<stdio.h>
#include<stdlib.h>
#include"Seqlist.h"
#include<malloc.h>
#include<assert.h>

void Seqlistinit(PSeq ps,int capacity)//顺序表的初始化
{
    ps->_array=(Datatype*)malloc(sizeof(Datatype)*capacity);
    if(NULL==ps->_array)
    {
        assert(0);
        return;
    }
    ps->_capacity=capacity;
    ps->_size=0;

}
void Seqlistdestory(PSeq ps)//顺序表的删除
{
    if(ps->_array)
    {
        free(ps->_array);
        ps->_array=NULL;
        ps->_capacity=0;
        ps->_size=0;
    }
}

void Seqlistpushback(PSeq ps,Datatype data)//顺序表存放元素（尾插）
{
    assert(ps);

    //顺序表满
    //Checkcapacity(ps);
    ps->_array[ps->_size]=data;
    ps->_size++;
}

void Seqlistpopback(PSeq ps)//尾删
{
    assert(ps);
    if(Seqlistempty(ps))
        return;
    ps->_size--;
}
void Seqlistpushfront(PSeq ps,Datatype data)//顺序表存放元素（头插）
{
    assert(ps);
    //Checkcapacity(ps);
    //将数据表中所有的元素同一向后搬移一个位置
    for(int i=ps->_size-1;i>=0;i--)
    {
        ps->_array[i+1]=ps->_array[i];
    }
    //插入元素
    ps->_array[0]=data;
    ps->_size++;
}

void Seqlistpopfront(PSeq ps)//头删
{
    if(Seqlistempty(ps))
    {
        return;
    }
    for(int i=1; i<ps->_size;++i)
    {
        ps->_array[i-1]=ps->_array[i];
    }

    ps->_size--;
}

void Seqlistinsert(PSeq ps,int pos,Datatype data)//中间插入元素
{
    assert(ps);
    if(pos<0||pos>ps->_size)
    {
        return;
    }
    //Checkcapacity(ps);
    for(int i=ps->_size-1;i>=pos;i--)
    {
        ps->_array[i+1]=ps->_array[i];
        ps->_array[pos]=data;
        ps->_size++;
    }

}

void Seqlisterase(PSeq ps,int pos)//中间删除元素
{
    assert(ps);
    if(pos<0||pos>=ps->_size)
    {
        return;
    }
    for(int i=pos+1;i<ps->_size;++i)
    {
        ps->_array[i-1]=ps->_array[i];
        ps->_size--;
    }
}

int Seqlistempty(PSeq ps)//清空
{
    assert(ps);
    return 0==ps->_size;
}

void Checkcapacity(PSeq ps)
{
    if(ps->_size==ps->_capacity)
    {
        //顺序表中已经没有空间
        int newcapacity=ps->_capacity*2;
        //申请新空间
        int * ptemp=(Datatype*)malloc(newcapacity*sizeof(Datatype));
        if (NULL==ptemp)
        {
            assert(0);
            return;
        }
        //拷贝元素
        for(int i=0;i<ps->_size;++i)
        {
            ptemp[i]=ps->_array[i];
        }
        //释放旧空间
        free(ps->_array);
        //更新参数
        ps->_array=ptemp;
        ps->_capacity=newcapacity;
    }
}

void Seqlistprint(PSeq ps)
{
    for(int i=0;i<ps->_size;++i)
    {
        printf("%d ",ps->_array[i]);
    }
    printf("\n");
}

int Seqlistfind(PSeq ps,Datatype data)
{
     assert(ps);
     for(int i=0; i<ps->_size;i++)
     {
         if(ps->_array[i]==data)
             return i;
     }
     return -1;
}

void Seqlistclear(PSeq ps)
{
    assert(ps);
    ps->_size=0;
}

int Seqlistsize(PSeq ps)
{
    assert(ps);
    return ps->_size;
}

int Seqlistcapacity(PSeq ps)
{
    assert(ps);
    return ps->_capacity;
}

void Seqlistremove(PSeq ps,Datatype data)//元素的移除
{
    Seqlisterase(ps,Seqlistfind(ps,data));
}

void Seqlistremoveall(PSeq ps,Datatype data)

{
    //int pos=-1;
    //while(-1!=(pos=Seqlistfind(ps,data)))
    //{
    //    Seqlisterase(ps,pos);
    //}

    assert(ps);
    int count=0;
    for(int i=0; i<ps->_size; ++i)
    {
        if(ps->_array[i]==data)
        {
            count++;
        }    
        else
        {
            ps->_array[i-count]=ps->_array[i];
        }
        ps->_size-=count;
    }
}

void Swap(int* pleft,int* pright)
{
    int temp=*pleft;
    *pleft=*pright;
    *pright=temp;
}

void Bubblesort(PSeq ps)//冒泡排序

{

    for(int i=0;i<ps->_size-1;++i)
    {
        int Ischange=0;
        for(int j=1;j<ps->_size-i;++j)
        {
            if(ps->_array[j-1]>ps->_array[j])
            {
                Ischange=1;
                Swap(&ps->_array[j-1],&ps->_array[j]);
            }

        }
    }
}

int binarysearch(PSeq ps,Datatype data);//二分查找

void Testseqlist()
{
    Seqlist s;
    int pos=-1;
    Seqlistinit(&s,10);
    Seqlistpushback(&s,1);
    Seqlistpushback(&s,2);
    Seqlistpushback(&s,3);
    Seqlistpushback(&s,2);
    Seqlistpushback(&s,5);
    printf("size=%d\n",Seqlistsize(&s));
    printf("capacity=%d\n",Seqlistcapacity(&s));
    Seqlistprint(&s);

    Seqlistpopback(&s);
    Seqlistprint(&s);

    Seqlistpushfront(&s,0);
    Seqlistprint(&s);

    Seqlistpopfront(&s);
    Seqlistprint(&s);

    Seqlistinsert(&s,1,5);
    Seqlistprint(&s);

    pos=Seqlistfind(&s,5);
    if(pos!=-1)
    {
        printf("5 is in %d\n",pos);

    }else
    {
        printf("5 is not in %d\n",pos);
    }

    Seqlisterase(&s,1);

    if(pos!=-1)
    {
        printf("5 is in %d\n",pos);

    }else
    {
        printf("5 is not in %d\n",pos);
    }
    Seqlistprint(&s);

    Seqlistremoveall(&s,2);
    Seqlistprint(&s);

    printf("size=%d\n",Seqlistsize(&s));
    printf("capacity=%d\n",Seqlistcapacity(&s));
    Seqlistdestory(&s);
}

int main()
{
    Testseqlist();

    system("pause");
    return 0;
}