小白表示看数据结构的书亚历山大，现在看到线性表的顺序表示和实现，但书里面老是一堆不知所以然的公式。。。。。跪求大神指点一二

对了，忘了说了，我学的是C语言版的

#include <iostream>
#define OK 1
#define ERROR 0
using namespace std;
typedef int ElemType;
typedef struct LNode//链表节点类型
{
    int data;
    struct LNode *next;
}LNode,*LinkList;//链表节点指针类型




int CreateList_L(LinkList &L,int n)//创建一个长度为n的线性表L
    {
        int i;
        LNode *p;
        L=(LinkList )malloc(sizeof(LNode));
        L->next=NULL;
        if(! L) exit(0);
        for(i=0;i<n;i++)
        {
            p=(LinkList)malloc(sizeof(LNode));
            
            cin>>p->data;
            p->next=L->next;
             L->next=p;
        }
        return OK;
    }







int GetElem_L(LinkList L,int i,ElemType &e)//定位
{
        LNode *p;
        int j=1;
        p=L->next;
        while(p&&j<i)
        {
            p=p->next;++j;
        }
        if(!p||j>i)return ERROR;
        e=p->data;
        return e;
        }








int  ListInsert_L(LinkList &L,int i,ElemType e)//插入
{
            LNode *p,*s ;
            int j=0;
//                int s;
            //    LinkList p;
            p=L;
            while(p&&j<i-1)
            {
                p=p->next;++j;
            }
            if(!p||j>i-1) return ERROR;
            s=(LinkList)malloc(sizeof( LNode));
            s->data=e;s->next=p->next;
            p->next=s;
            

        return OK;
    }









int ListDelete_L(LinkList &L,int i,ElemType &e)//删除
    {
        LNode *p ,*q;
        int j=0;
        p=L;
    //    int q;
        while(p->next&&j<i-1)
        {
            p=p->next;++j;
        }
        if(!(p->next)||j>i-1) return ERROR;
        q=p->next;p->next=q->next;
        e=q->data; free(q);
    //    return ERROR;
return OK;
    }







int ShowList_L(LinkList &L)
    {
        LinkList p;
        p=L->next;
        while(p)
        {
            cout<<p->data<<"  "<<endl;
            p=p->next;
        }
            
    //    cout<<endl;
        return 0;
    }






int main()
{
  int i,n;
  LNode *p;
  LinkList L;
  cout<<"请输入元素个数:"<<endl;
  cin>>n;
  CreateList_L(L,n);
 ShowList_L(L);
  
 

 for(;;)
  {
      cout<<"请输入操作选择:0,定位；1，插入；2，删除；\n 请输入你的选择："<<endl;
      cin>>i;
      while(i<0||i>3)
      {
         cout<<"输入错误，请重新输入。"<<endl;
      }
      switch(i)
      {
      case 0:
          {
              int i,e;
              cout<<"输入你想定位的数的位置："<<endl;
              cin>>i;
              
             GetElem_L( L, i,e);
             cout<<e<<endl;
            
             break;
          }
      case 1:
          {
           int  i,e;
           cout<<"输入插入的位置："<<endl;
           cin>>i;
          cout<<"输入插入的数："<<endl;
           cin>>e;
           ListInsert_L(L, i, e);
           ShowList_L(L);
           break;
          }
      case 2:
          {
            int i,e;
            cout<<"输入删除的数的位置："<<endl;
            cin>>i;
             ListDelete_L(L, i, e) ;
             ShowList_L(L);
             break;
          }
     
      }
  }
return 0;
}

555

要思考

我也是新手，说错勿怪

谢拉，阿里嘎多国山马斯

#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 50
typedef char elemtype;
typedef struct
{   
    elemtype data[MAXSIZE];
    int length;
}sqlist;


void initlist(sqlist  * &l)//顺序表的初始化
{
    l = (sqlist *)malloc(sizeof(sqlist));//动态分配内存空间
    l->length = 0;  //置空顺序表长度为0
}
void destroylist(sqlist  * &l)//销毁顺序表
{
    free(l);
}
int listempty(sqlist  *l)  //判断顺序表是否为空
{
    return (l->length==0);
}
int listlength(sqlist *l)//求顺序表的长度
{
    return (l->length);
}
void displist(sqlist *l)//输出顺序表
{
    int i;
    if(listempty(l)) return;
    for(i=0;i<l->length;i++)
        printf("%c",l->data[i]);
    printf("\n");
}
int 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)//查找元素e
        i++;
    if(i>=l->length)
        return 0;                      //未找到时返回0
    else
        return i+1;                     //找到后返回其逻辑序号
}
int listinsert(sqlist * &l,int i,elemtype e)  //插入数据元素
{   
    int j;
    if(i<1||i>l->length+1)
        return false;                  //参数错误时返回false
    i--;                               //将顺序表逻辑序号转化为物理序号
    for(j=l->length;j>i;j--)
        l->data[j] = l->data[j-1];      //通过循环将data[i]及后面元素后移一个位置
    l->data[i]=e;                       //插入元素e
    l->length++;                        //顺序表长度加1
    return true;                        //成功插入返回true
}                 
int listdelete(sqlist * &l,int i,elemtype &e)   //删除数据元素
{
    int j;
    if(i<1||i>l->length)                  //参数错误时返回false
        return false;
    i--;                                   //将顺序表逻辑序号转化为物理序号
    e=l->data[i];
    for(j=i;j<l->length-1;j++)              //通过循环将data[i]之后的元素前移一个位置
        l->data[j] = l->data[j+1];
    l->length--;                            //顺序表长度减1
    return true;
}
int priorelem (sqlist *l,elemtype cur_e,elemtype &pre_e)//前驱节点
{
    int i;
    i=locateelem(l,cur_e);
    if(i==1)
    {
        printf("第一个节点无前驱！\n");
        return 0;
    }
    else if(i>1 && i<=listlength(l))
    {
            pre_e=l->data[i-2];
            return 1;
    }
    else
    {
        printf("不存在此元素\n");
        return 0;
    }
}

int nextelem (sqlist *l,elemtype cur_e,elemtype &nex_e)//后继结点
{
    int i;
    i=locateelem(l,cur_e);
    if(i==listlength(l))
    {
        printf("最后一个节点无后继！\n");
        return 0;
    }
    else if(i>=1 && i<listlength(l))
    {
        nex_e=l->data[i];
        return 1;
    }
    else
    {
        printf("不存在此元素\n");
        return 0;
    }     
}
void main()
{
    sqlist *l;
    elemtype e,s;
    printf("（1）初始化顺序表L\n");
    initlist(l);
    printf("（2）采用尾插入法插入a,b,c,d,e,f元素\n");
    listinsert(l,1,'a');
    listinsert(l,2,'b');
    listinsert(l,3,'c');
    listinsert(l,4,'d');
    listinsert(l,5,'e');
    listinsert(l,6,'f');
    printf("（3）输出顺序表L\n");
    displist(l);
    printf("（4）顺序表L长度=%d\n",listlength(l));
    printf("（5）顺序表L为=%s\n",(listempty(l)?"空":"非空"));
    getelem(l,3,e);
    printf("（6）顺序表L的第3个元素=%c\n",e);
    printf("（7）元素a的位置=%d\n",locateelem(l,'a'));
    printf("（8）在第4个元素位置上插入g元素\n");
    listinsert(l,4,'g');
    printf("(9)输出顺序表L:\n");
    displist(l);
    printf("(10)删除L的第3个元素\n");
    listdelete(l,3,e);
    printf("(11)输出顺序表L\n");
    displist(l);
    //printf("查找节点的后继节点\n");
    printf("请输入节点\n");
    scanf("%c",&s);
    if(!nextelem(l,s,e))
        printf("该节点没有后继节点\n");
    else
        printf("该节点的后继节点为: %c\n",e);
                           //（输入节点，完成主函数部分该节点的前驱节点的显示）
    //printf("查找节点的前驱节点\n");
    //printf("请输入节点\n");
   // scanf("%c",&s);
    if(!priorelem(l,s,e))
        printf("该节点没有前驱节点\n");
    else
        printf("该节点的前驱节点为: %c\n",e);
    displist(l);
    printf("(14)释放顺序表L\n");
    destroylist(l);
   

}
这是顺序表的

#include<stdio.h>
#include<malloc.h>
#include<math.h>
#include<time.h>//用来计算程序运行时间
#define CLOCKS_PER_SEC ((clock_t)10000)//这句可有可无
typedef char elemtype;
typedef struct lnode//单链表的结构
{   
    elemtype data;
    struct lnode *next;
}linklist;


void initlist(linklist  * &l)//初始化单链表
{
    l = (linklist *)malloc(sizeof(linklist));//动态分配节点空间
    l->next = 0;//创建头节点，其next域置为空
}
void destroylist(linklist  * &l)//销毁单链表
{
    linklist *pre = l,*p = p->next;
    while(p!=NULL)//扫描整个单链表L
    {
        free(pre);
        pre=p;
        p = pre->next;
    }
    free(pre);
}
bool listempty(linklist  *l)//判断单链表是否为空
{
    return (l->next==NULL);
}
int listlength(linklist *l)//单链表的长度
{
    int n=0;
    linklist *p=l;//P指向头结点，n置为0，即头结点的序号为0
    while(p->next!=NULL)
    {
        n++;
        p=p->next;
    }
    return(n);//循环结束，P指向尾节点，起序号n为节点个数
}
void displist(linklist *l)//输出单链表
{
    linklist *p=l->next;//P指向开始节点
    while(p!=NULL)
    {
        printf(" %c ",p->data);//P不为空，输出*P节点的data域
        p=p->next;//P指向下一个节点
    }
    printf("\n");
}
int getelem(linklist *l,int i,elemtype &e)//求单链表中某个数据元素值
{
    int j=0;
    linklist *p=l;
    while(j<i && p!=NULL)//找第i 个节点，即我们所要找的数据元素
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        e=p->data;//P的数据域赋给e，就会返回我们所要的数据元素
        return true;
    }
}
int locateelem(linklist *l,elemtype e)//按元素值查找
{
    int i=1;
    linklist *p=l->next;
    while(p!=NULL && p->data!=e)
    {
        p=p->next;
        i++;
    }
    if(p==NULL)
        return(0);
    else
        return (i);//返回逻辑序号i
}
int listinsert(linklist * &l,int i,elemtype e)//插入数据元素
{   
    int j=0;
    linklist *p=l,*s;
    while(j<i-1 && p!=NULL)//查找i-1个节点
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        s=(linklist *)malloc(sizeof(linklist));//动态分配节点空间
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}
int listdelete(linklist * &l,int i,elemtype &e)//删除数据元素
{
    int j=0;
    linklist *p=l,*q;
    while(j<i-1 && p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;//没找到i-1个节点，返回false
    else
    {
        q=p->next;
        if(q==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
    }
}
int priorelem (linklist *l,elemtype cur_e,elemtype &pre_e)//单链表元素的前驱
{
     linklist *p=l->next;//p指向开始节点
     linklist *q;
     int i=1;
    while(p!=NULL && p->data!=cur_e)
    {
        i++;
        q=p;//用q来保存p的前驱
        p=p->next;
    }

    if(i == 1)
        {
             printf("第一个节点无前驱\n");
             return false;
        }
    else if(i>1 && i<=listlength(l))
    {
            pre_e=q->data;//返回P的前驱q的数据域
            return true;
    }
   
    else
        {
            printf("不存在此元素\n");
            return false;
        }
}

int nextelem (linklist *l,elemtype cur_e,elemtype &nex_e)//单链表元素的后继
{
     linklist *p;
      p = l->next;//p指向开始节点
      int i = 1;
    while(p!=NULL && p->data!=cur_e)
       {
            i++;
             p=p->next;
    }

        if(i==listlength(l))
            {
                 printf("最后一个节点无后继\n");
                 return false;
            }
        else if(i>=1 && i<listlength(l))
        {
            nex_e = p->next->data;
            return true;
       }
       else
       {
           printf("不存在此元素\n");
               return false;
       }
}
void reverse(linklist *&l)//单链表的逆置
{
    linklist *p = l->next,*q;
    l->next=NULL;//先把头结点断开，L 置空
    while(p!=NULL)
    {
        q=p->next;      //用q来保存P的后继节点
        p->next=l->next;//把P节点断开
        l->next=p;      //放在L节点的后面
        p=q;            //P节点向后移，直到P为空
    }
}
void main()
{
    double duration; //这几句是用来计算运行时间的
    clock_t start;
    int n,i,j=0;
    n=1000;
    start=clock();

    linklist *l,*p;     
    elemtype e,s;
    printf("（1）初始化单链表L\n");
    initlist(l);
    printf("（2）采用尾插入法插入a,b,c,d,e,f元素\n");
    listinsert(l,1,'a');
    listinsert(l,2,'b');
    listinsert(l,3,'c');
    listinsert(l,4,'d');
    listinsert(l,5,'e');
    listinsert(l,6,'f');
    printf("（3）输出单链表L\n");
    displist(l);
    printf("（4）单链表L长度=%d\n",listlength(l));
    printf("（5）单链表L为=%s\n",(listempty(l)?"空":"非空"));
    getelem(l,3,e);
    printf("（6）单链表L的第3个元素=%c\n",e);
    printf("（7）元素a的位置=%d\n",locateelem(l,'a'));
    printf("（8）在第4个元素位置上插入g元素\n");
    listinsert(l,4,'g');
    printf("(9)输出单链表L:\n");
    displist(l);
    printf("(10)删除L的第3个元素\n");
    listdelete(l,3,e);
    printf("(11)输出单链表L\n");
    displist(l);
    reverse(l);
    printf("单链表逆置后为:\n");
    displist(l);
    //printf("查找节点的前驱节点\n");
    printf("请输入节点\n");
    scanf("%c",&s);
    if(!priorelem(l,s,e))
        printf("该节点没有前驱节点\n");
    else
        printf("该节点的前驱节点为: %c\n",e);

                       //（输入节点，完成主函数部分该节点的前驱节点的显示）
   // printf("查找节点的后继节点\n");
   if(!nextelem(l,s,e))
        printf("该节点没有后继节点\n");
    else
        printf("该节点的后继节点为: %c\n",e);
    displist(l);

   // printf("(14)释放单链表L\n");
   // destroylist(l);
    printf("\n");
    duration=((double)(clock()-start))/CLOCKS_PER_SEC;
    printf(" %f\n",duration);

}这是单链表的