1-线性表 顺序存储

仅供学习记录参考

如果有人觉得我的代码能帮到的话也很好

有问题可以随时提问！

2017/7/11

1、顺序存储线性表基本功能的实现

#include<iostream>
#include<cstdlib>
using namespace std;
#define ture 1
#define false 0
#define maxsize 50
#define listincreament 10
#define ok 1
#define error -3
#define overflow -2
typedef int Status;
typedef int ElemType;

typedef struct{
ElemType *data;
int length;
int listsize;
}SqList;

Status initList_Sq(SqList &L)
{
    L.data=(ElemType *)malloc(maxsize*sizeof(ElemType));
    L.length=0;
    L.listsize=maxsize;
    return ok;
}
Status ListInsert_Sq(SqList &L,int i,ElemType e)
{
    ElemType *newbase,*p,*q;
    //顺序线性表L中第i个位置插入新的元素e
    if(i<1||i>L.length)return error;
    if(L.length>=L.listsize)
    {
        //存储空间满，增加分配。
        newbase=(ElemType *)realloc(L.data,(L.listsize+listincreament)*sizeof(ElemType));
        if(!newbase) exit(overflow);
        L.data=newbase;
        L.listsize+=listincreament;
    }

    for(int j=L.length;j>=i;j--)
    {
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;
    L.length++;
    return ok;
}
void showList(SqList &L)
{
    ElemType *p;
    int i=0;
    for(int i=0;i<L.length;i++)
    {
        cout<<L.data[i];
        if(i!=L.length-1) cout<<' ';
        else cout<<endl;
    }
}
Status DeleteList_Elem(SqList &L,int i)
{
    if(i<0||i>=L.length) return error;
    for(int j=i;j<L.length-1;j++)
    {
        L.data[j]=L.data[j+1];
    }
    L.length--;
    return ok;
}
int LocateElem(SqList &L,ElemType e)
{
    int pos=-1;
    for(int j=0;j<L.length;j++)
    {
        if(L.data[j]==e)
            {pos=j;break;}
    }
    return pos+1;
}
//细节：返回值要+1
int mergeList(SqList &a,SqList &b,SqList &c)
{
    ElemType *x,*y,*z;
    int ia=0,ib=0,ic=0;
    while(ia<a.length-1&&ib<b.length-1)
    {
        if(a.data[ia]<b.data[ib])
        {
            c.data[ic++]=a.data[ia++];
        }
        else {c.data[ic++]=b.data[ib++];}
    }
    while(ia<a.length-1)
        c.data[ic++]=a.data[ia++];
    while(ib<b.length-1)
        c.data[ic++]=b.data[ib++];
    c.length=ic;
    return ok;
}

int main()
{
    int w;
    SqList L1,L2,L3;
    w=initList_Sq(L1);
    for(int i=0;i<10;i++)
    {L1.data[i]=i+1;L1.length++;}
    L1.length=10;

    initList_Sq(L2);
    initList_Sq(L3);

    for(int i=0;i<7;i++)
    {L2.data[i]=(i+1)*3;}
    L2.length=7;

    //cout<<w;
    showList(L1);
    ListInsert_Sq(L1,4,33);
    DeleteList_Elem(L1,7);
    showList(L1);
    int a=LocateElem(L1,33);
    cout<<a<<endl;
    mergeList(L1,L2,L3);
    showList(L3);
    return 0;
}

 2、基于顺序表实现的一些算法：描述见代码注释（实在是太懒了，就不逐个分开来粘代码了）

/*删除最小元素,返回元素值，空位由末尾元素填补*/
int Delete_minelem(SqList &L)
{
    int e=32767,pos;
    for(int i=0; i<L.length; i++)
    {
        if(L.data[i]<e)
        {
            e=L.data[i];
            pos=i;
        }
    }
    if(pos!=L.length-1)
    {
        L.data[pos]=L.data[L.length-1];
        L.length--;
    }
    else L.length--;
    return e;
}
/*空间复杂度O(1)的逆置顺序表*/
void reverse_List(SqList &L,int op,int ed)
{
    int mid=(ed+1-op)/2;
    for(int i=0; i<mid; i++)
    {
        int t=L.data[ed-i];
        L.data[ed-i]=L.data[op+i];
        L.data[op+i]=t;
    }
}
/*删除所有值为x的数据元素*/
//用k记录顺序表l中不等于x的元素个数，一边扫描一边统计k，不等于x的元素向前放置到k位置上，最后修改L的长度。
void delete_x(SqList &L,ElemType x)
{
    int k=0;
    for(int i=0; i<L.length; i++)
    {
        if(L.data[i]!=x)
        {

            L.data[k]=L.data[i];
            k++;
        }
    }
    L.length=k;
}
/*删除值在指定的s、t之间的元素，若s、t不合法或者顺序表为空显示出错信息并且退出*/
int delete_fstt(SqList &L,int s,int t)
{
    int k=0;
    if(L.length==0||s>t) return 0;
    for(int i=0; i<L.length; i++)
    {
        if(L.data[i]>t||L.data[i]<s)
        {
            L.data[k]=L.data[i];
            k++;
        }
    }
    L.length=k;
}
/*删除有序表中所有值重复的元素*/
int delete_same(SqList &L)
{
    int k=0,i=0;
    while(i<L.length)
    {
        if(L.data[i]==L.data[k])
            i++;
        else
        {
            k++;
            L.data[k]=L.data[i];
        }
    }
    L.length=k+1;
}
//注意，此处k最后要加1才为正确所求。因为k在函数中起一个下标处理的作用，而数组是从0开始的，故最后要加一。
/*互换指定一个线性表中两个子表的位置*/
/*如A(a,b)->A(b,a) a:(0~a),b:(a+1~A.length-1)*/
void reverse_sonofList(SqList &L,int a)
{
    reverse_List(L,0,a);
    reverse_List(L,a+1,L.length-1);
    reverse_List(L,0,L.length-1);
}
//这个方法很奇妙，可以在空间复杂度为1的情况下解决数组位数循环的问题

/*有序递增顺序表，在最少时间内于表中查找数值为x的元素，若找到使之与后继元素交换，找不到插入x于表中使得表元素仍然递增有序。*/
/*因为要求是用最短时间查找，应该选择折半查找法*/
void exchange(SqList &L,int x)
{
    int low=0,high=L.length-1,mid;
    while(low<=high)
    {
        mid=(high+low)/2;
        if(L.data[mid]==x) break;
        else if(L.data[mid]>x)high=mid-1;//缩小上界
        else low=mid+1;//缩小下界
    }
    if(L.data[mid]==x)
        swap(L.data[mid],L.data[mid+1]);
    else
    {
        int i;
        for(i=L.length-1; i>high; i--)
        {
            L.data[i+1]=L.data[i];
        }
        L.data[i+1]=x;//插入的位置应为A[i+1]而不是i，若是手写代码的，这里应模拟一下保证正确度
        L.length++;
    }
}
/*给出两个等长升序数列，寻找共同的中位数*/
/*时间复杂度为O(n),空间复杂度为O（1）*/
int findmid(SqList &L1,SqList &L2)
{
    int a1=0,a2=0,ans;
    int cut=L1.length;

    while(cut--)
    {

        if(L1.data[a1]<L2.data[a2])
        {
            ans=L1.data[a1];
            a1++;

        }
        else
        {
            ans=L2.data[a2];
            a2++;
        }
    }

    return ans;
}
/*给出两个等长升序数列，寻找共同的中位数*/
/*解法二，时间复杂度为O(log2n)，空间复杂度为O(1)*/
int M_search(int A[],int B[],int n)
{
    int s1=0,d1=n-1,m1,s2=0,d2=n-1,m2;
    //分别表示了A、B序列的首位数、末尾数、中位数
    while(s1!=d1||s2!=d2)//重复到两个序列只剩一个元素为止，比较小的为所求。
    {
        m1=(s1+d1)/2;
        m2=(s2+d2)/2;
        if(A[m1]==B[m2]) return A[m1];//a=b，a或者b为所求的中位数，算法结束
        if(A[m1]<B[m2])//若a<b，舍弃A中较小的一半，同时舍去序列b中较大的一半，要求两次舍弃长度相等。
        {
            if((s1+d1)%2==0)//元素个数为奇数
            {
                s1=m1;//舍弃A中间点以前的部分并且保留中间点
                d2=m2;//舍弃B中间点以后的部分并且保留中间点
            }
            else
            {
                s1=m1+1;//舍弃A中间点以及中间点以前的部分
                d2=m2;//舍弃B中间点以后的部分，保留中间点
            }

        }
        else//若a>b，舍弃A中较大的一半，同时舍去序列b中较小的一半，要求两次舍弃长度相等。
        {

            if((s1+d1)%2==0)//元素个数为奇数
            {
                d1=m1;//舍弃A中间点以前的部分并且保留中间点
                s2=m2;//舍弃B中间点以后的部分并且保留中间点
            }
            else
            {
                d1=m1;//舍弃A中间点以及中间点以前的部分
                s2=m2+1;//舍弃B中间点以后的部分，保留中间点
            }
        }
    }
    return A[s1]<B[s2]?A[s1]:B[s2];
}
//一般人怕是想不到orz

/*寻找主元素：出现次数大于长度一般的元素，存在输出，不存在输出-1*/
int findmainelem(SqList &L)
{
    int k=0,num;
    num=L.data[0];//设置第一个为候选主元素
    k++;
    for(int i=0; i<L.length; i++)
    {
        if(L.data[i]!=num)
        {
            if(k>0)
                k--;
            else
            {
                num=L.data[i];
                k=1;
            }
        }
        else k++;
    }
    int flag=1,countt=0;
    for(int i=0; i<L.length; i++)
    {
        if(L.data[i]==num)
            countt++;
    }
    if(countt>L.length/2)flag=!flag;
    if(flag) return -1;
    else return num;
}