顺序表详解

定长顺序表定义：

#pragma once
#define SIZE 10

typedef struct SeqList
{
 int elem[SIZE];  //顺序表表示数组，总大小SIZE
 int length;  //有效数据的个数
}SeqList,*PSeqList;

操作：

//初始化  长度置0即可

void InitSeqList(PSeqList ps)

{
    assert(ps != NULL);
    if(ps == NULL)
        return;

    ps->length=0;
}


//插入：在pos位置上插入元素val（从pos开始，后面的数据都后移一位，pos位置值置成val,长度加1）
bool InsertSeqList(PSeqList ps,int pos,int val)

{
    if(pos<0 || pos >ps->length || IsFull(ps))
        return false;
    for(int i=ps->length-1;i>=pos;i--)
    {
        ps->elem[i+1]=ps->elem[i];
    }
    ps->elem[pos]=val;
    ps->length++;
    return true;
}


//查找：遍历ps,在ps上查找key,返回其下标，没找到返回-1（顺序表是用数组实现的，数组内没有为-1的下标）
int SearchSeqList(PSeqList ps,int key)

{
    for(int i=0;i< ps->length;i++)
    {
        if(ps->elem[i]==key)
            return i;
    }
    return -1;//该函数返回元素下标，用-1标志没有找到，因为没有元素下标是-1
}


//删除：遍历ps，删除值为key的结点，长度减一，找到返回true，没找到返回false

bool DeleteVal(PSeqList ps,int key)

{
int index=SearchSeqList(ps,key);
if(index<0)
    return false;

/*for(int i=index;i< ps->length;i++)
{
    ps->elem[i]=ps->elem[i+1];
}

ps->length--;
return true;*/
return DeletePos(ps,index);
}



//删除：删除ps中下标为pos的结点，长度减一，如果下标不合法，返回false

bool DeletePos(PSeqList ps,int pos)

{
    if(pos<0 || pos>= ps->length)//包含数组为空的情况
        return false;

    for(int i=pos;i< ps->length;i++)
{
    ps->elem[i]=ps->elem[i+1];
}

ps->length--;
return true;
}



//返回有效数据个数length
int GetLength(PSeqList ps)

{
    return ps->length;
}

//判空，判断有效数据个数是否为0
bool IsEmpty(PSeqList ps)

{
    return ps->length==0;
}

//调Destory（）

void Clear(PSeqList ps)

{
    ps->length=0; //(*ps).length=0;[],->自带解引用
}

//销毁，有效数据个数置0

void Destory(PSeqList ps)

{
    Clear(ps);
}

//输出函数，遍历顺序表，一个一个打印
void Show(PSeqList ps)

{
    for(int i=0;i<ps->length;i++)
    {
        printf("%d ",ps->elem[i]);
    }
    printf("\n");
}

//返回下标为pos的值，下标不合法，返回false，用rtval带出要得到的值
bool GetElem(PSeqList ps,int pos,int *rtval)

{
    if(pos<0 || pos >ps->length)
        return false;
     *rtval=ps->elem[pos];
     return true;
}

//有序顺序表中插入val，顺序表人有序

//（在ps中找第一个比val大的结点，这就是val要插入的位置，从该点起，后面数据都后移一位，长度加1）

void Insert(PSeqList ps,int val)

{
    if(ps->length==SIZE)
        return;

    int i=0;
    //在ps中找第一个比val大的结点，这就是val要插入的位置，从该点起，后面数据都后移一位，长度加1
    for(;i<ps->length;i++)
    {
        if(ps->elem[i]>val)
            break;
    }
    ps->length++;
    for(int j=ps->length-1;j>=i;j--)
    {
        ps->elem[j]=ps->elem[j-1];
    }
    ps->elem[i]=val;
}


//顺序表比较（跟字符串比较相似），先判断有空顺序表的情况，在判断都不为空的情况

int CompareSeqList(PSeqList ps1,PSeqList ps2)

{
    if(ps1->length==0 && ps2->length!=0)  //ps1空，ps2非空
        return -1;
    if(ps2->length==0 && ps1->length!=0)  //ps2空，ps1非空
        return 1;
    if(ps2->length==0 && ps1->length==0)  //ps1空，ps2空
        return 0;
    int len=ps1->length>ps2->length?ps2->length:ps1->length;
    if(ps2->length!=0 && ps1->length!=0)   //ps1非空，ps2非空
    {
        for(int i=0;i<len;i++)
        {
        if(ps1->elem[i]>ps2->elem[i])
            return 1;
        else if(ps1->elem[i]<ps2->elem[i])
            return -1;
        else
            ;
        }
        if(ps1->length>len)
        {
            return 1;
        }
        else if(ps2->length>len)
        {
            return -1;
        }
        else
        return 0;
    }
        
}

//逆置，（跟字符串逆置相似）

//顺序表表头结点值与顺序表表尾结点值进行交换，然后第二个节点值与倒数第二个结点值交换，依次

void Rev(PSeqList ps)

{
    int tmp;
    for(int i=0;i<(ps->length)/2;i++)
    {
        tmp=ps->elem[i];
        ps->elem[i]=ps->elem[ps->length-i-1];
        ps->elem[ps->length-i-1]=tmp;
    }
}

//删除ps1中ps2ps3都有的元素

//先找到ps2和ps3共有的元素，遍历ps1,若有，删掉

void Dele(PSeqList ps1,PSeqList ps2,PSeqList ps3)

{
    int i,j;

    for(i=0;i<ps2->length;i++)
    {
        for(j=0;j<ps3->length;j++)
        {
            if(ps2->elem[i]==ps3->elem[j])
                DeleteVal(ps1,ps2->elem[i]);
        }
    }

}

//合并ps1，ps2（将ps2中数据一个一个插入ps1）

void Bing(PSeqList ps1,PSeqList ps2)

{
    for(int i=0;i<ps2->length;i++)
    {
        int index=SearchSeqList(ps1,ps2->elem[i]);
        if(index<0)
        {
            InsertSeqList(ps1,ps1->length,ps2->elem[i]);
        }
    }
}

 

****************************************************************************************

不定长顺序表定义：

typedef struct DSeqList
{
 int *elem;//指向动态数组的首地址
 int length;//有效数据长度
 int listsize;//总长度
}DSeqList,*PDSeqList;

与定常顺序表的区别在于，当顺序表满了会自动二倍的扩容