顺序表+单链表

代码如下；
//顺序表基本运算算法

#include <iostream>
#include <algorithm>
#include <malloc.h>
#define Maxsize 100
using namespace std;
typedef int Elemtype;
typedef struct
{
    Elemtype  data[Maxsize];
    int length;
} SqList;
void CreateList(SqList *&L,Elemtype a[],int n)//由a中的n个元素建立顺序表
{
    int i=0,k=0;
    L=(SqList *)malloc(sizeof(SqList));//memory allocate  内存分配
    while(i<n)
    {
        L->data[k]=a[i];
        k++;
        i++;

    }
    L->length=k;
}
void InitList(SqList *&L)//初始化线性表
{
    L=(SqList *)malloc(sizeof(SqList));
    L->length=0;//置空线性表的长度为0
}
void DestroyList(SqList *&L)//销毁线性表
{
    free(L);
}
bool ListEmpty(SqList *&L)//判断线性表是否为空表
{
    return(L->length==0);

}
int ListLength(SqList *&L)//求出线性表的长度
{
    return (L->length);

}
void DispList(SqList *&L)//输出线性表
{
    for(int i=0; i<L->length; i++)
    {
        cout<<L->data[i]<<" ";
    }
    cout<<endl;
}
bool GetElem(SqList *&L,int i,Elemtype &e)//求出线性表的某个元素的值
{
    if(i<1||i>L->length)
        return false;
    e=L->data[i-1];
    return true;
}
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 1+i;
}
bool 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[i]=L->data[j-1];
           L->data[i]=e;
           L->length++;
           return true;
       }
}
bool ListDelete(SqList *&L,int i,Elemtype &e)//删除数据元素
{
    int j;
    if(i<1||i>L->length+1)

        return false;
       i--;
       e=L->data[i];
       for(j=i;j<L->length-1;j++)
       {
           L->data[i]=L->data[j+1];
           L->length--;
           return true;
       }
}
int main()
{
    SqList *p;
    int n;
    InitList(p);
    Elemtype a[4]={1,2,3,4};
    CreateList(p,a,4);//创建顺序表
    //
    //DestroyList(p);
    //char o[5]=ListEmpty(p);
    //cout<<o<<endl;
    int length=ListLength(p);//求出顺序表的长度
    cout<<length<<endl;
    DispList(p);
    int y=locateElem(p,2);//查找元素
    cout<<y<<endl;
   //bool o=ListInsert(p,2,5);
   //cout<<o<<endl;
    //DispList(p);
}/*
//单链表基本运算算法
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
using namespace std;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;		//指向后继结点
} LinkNode;					//声明单链表结点类型
void CreateListF(LinkNode *&L,ElemType a[],int n)
//头插法建立单链表
{
    LinkNode *s;
    L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
    L->next=NULL;
    for (int i=0; i<n; i++)
    {
        s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点s
        s->data=a[i];
        s->next=L->next;			//将结点s插在原开始结点之前,头结点之后
        L->next=s;
    }
}
void CreateListR(LinkNode *&L,ElemType a[],int n)
//尾插法建立单链表
{
    LinkNode *s,*r;
    L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
    L->next=NULL;
    r=L;					//r始终指向终端结点,开始时指向头结点
    for (int i=0; i<n; i++)
    {
        s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点s
        s->data=a[i];
        r->next=s;			//将结点s插入结点r之后
        r=s;
    }
    r->next=NULL;			//终端结点next域置为NULL
}
void InitList(LinkNode *&L)
{
    L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点
    L->next=NULL;
}
void DestroyList(LinkNode *&L)//销毁单链表
{
    LinkNode *pre=L,*p=pre->next;
    while (p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);	//此时p为NULL,pre指向尾结点,释放它
}
bool ListEmpty(LinkNode *L)//判断单链表是否为空
{
    return(L->next==NULL);
}
int ListLength(LinkNode *L)//求出长度
{
    LinkNode *p=L;
    int i=0;
    while (p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(LinkNode *L)//输出链表
{
    LinkNode *p=L->next;
    while (p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(LinkNode *L,int i,ElemType &e)
{
    int j=0;
    LinkNode *p=L;
    if (i<=0) return false;		//i错误返回假
    while (j<i && p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)				//不存在第i个数据结点
        return false;
    else						//存在第i个数据结点
    {
        e=p->data;
        return true;
    }
}
int LocateElem(LinkNode *L,ElemType e)//查找
{
    LinkNode *p=L->next;
    int n=1;
    while (p!=NULL && p->data!=e)
    {
        p=p->next;
        n++;
    }
    if (p==NULL)
        return(0);
    else
        return(n);
}
bool ListInsert(LinkNode *&L,int i,ElemType e)
{
    int j=0;
    LinkNode *p=L,*s;
    if (i<=0) return false;			//i错误返回假
    while (j<i-1 && p!=NULL)		//查找第i-1个结点p
    {
        j++;
        p=p->next;
    }
    if (p==NULL)					//未找到位序为i-1的结点
        return false;
    else							//找到位序为i-1的结点*p
    {
        s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点*s
        s->data=e;
        s->next=p->next;			//将s结点插入到结点p之后
        p->next=s;
        return true;
    }
}
bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
    int j=0;
    LinkNode *p=L,*q;
    if (i<=0) return false;		//i错误返回假
    while (j<i-1 && p!=NULL)	//查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)				//未找到位序为i-1的结点
        return false;
    else						//找到位序为i-1的结点p
    {
        q=p->next;				//q指向要删除的结点
        if (q==NULL)
            return false;		//若不存在第i个结点,返回false
        e=q->data;
        p->next=q->next;		//从单链表中删除q结点
        free(q);				//释放q结点
        return true;
    }
}
int main()
{


    LinkNode *p,*q,*s,*head;
    head=(LinkNode*)malloc(sizeof(LinkNode));//要在主函数中动态分配存储空间，才能使用单链表。
    p=head;
    ElemType a[4]= {1,2,3,4};
    CreateListF(p,a,4);//头插法创建单链表
    DestroyList(p);//销毁单链表
    DispList(p);

    CreateListR(p,a,4);//尾插法创建单链表
    DispList(p);
    int length1=ListLength(p);//求出单链表的长度
    cout<<length1<<endl;
    int o=LocateElem(p,3);
    cout<<o<<endl;


}*/