精华内容
下载资源
问答
  • 顺序表的基本操作实现

    千次阅读 2017-09-19 18:49:39
    内容简介:该文章包含建立数据实现数据插入、查找、删除、遍历等功能的程序以及编写过程遇到问题和心得。 在开始编写程序前,需要明确程序要执行功能,然后进行分析并抽象出具体数据模型,形成基本的...

    内容简介:该文章包含建立数据表,实现数据插入、查找、删除、遍历等功能的程序以及编写过程遇到的问题和心得。

     

    在开始编写程序前,需要明确程序要执行的功能,然后进行分析并抽象出具体的数据模型,形成基本的思路。有了想法,接下来就是通过数据表示和数据处理得出算法进而转换为程序设计语言。

     

    由于线性表的数据元素类型不确定,所以采用C++的模板机制,首先定义一个模板类

    #include
    using namespace std;
    
    const int Max=100;
    template
    class LinkList
    {
    public:
    	LinkList(){Length=0;}   /*无参构造函数*/
    	LinkList(T a[],int n);  /*建立有n个元素的顺序表*/
    	~LinkList(){};  /*析构函数*/
    	void Insert(int i,T x);   /*在第i个位置中插入元素值为X的元素*/
    	int Length(){return length;}  /*求顺序表的长度*/
    	T Get(int i);   /*按位查找,在顺序表中查找第i个结点的元素值*/
    	int Locate(T x);    /*按值查找*/
    	T Delete(int i);   /*删除顺序表中第i个结点*/
    	void PrintList();   /*依次输出各元素*/
    
    private:
    	int length;  //线性表的长度
    	T data[Max];  //存放数据的数组
    };
    
    

    然后根据每个函数需要实现的功能进行定义

     

    
    //顺序表有参构造函数
    template<class T>
    LinkList<T>::LinkList(T a[],int n)
    {
        if(n>Max)
            throw "参数非法";
        for(int i=0;i<n;i++)
        {
          data[i]=a[i];
          length=n;
        }
    }//在顺序表中插入元素
    template<class T>
    void LinkList<T>::Insert(int i,T x)
    {
        if(i<1||i>length+1)
            throw "参数非法";
        else
        {
         for(int j=length;j>=i;j--)
            {
              data[j]=data[j-1];
            }
            data[i-1]=x;
            length++;
        }
    }
    
    //顺序表按位查找
    template
    T LinkList::Get(int i)
    {
       if(i<1||i>length)
    	   throw "位置非法";
       else
       {
         return data[i-1];
       }
    }
    
    //顺序表中按值查找
    template<class T>
    int LinkList<T>::Locate(T x)
    {
      for(int i=0;i<length;i++)
      {
         if(data[i]==x)
             return i+1;
      }
      return 0; 
    }
    
    //按位删除顺序表中的数据
    template<class T>
    T LinkList<T>::Delete(int i)
    {
      if(i<1||i>length)
          throw "位置非法";
      else
      {
         T x=data[i-1];
         for(int j=i;j<length;j++)
            {
              data[j-1]=data[j];
            }
         length--;
         return x;
      }
    }
    
    //遍历顺序表中的元素
    template<class T>
    void LinkList<T>::PrintList()
    {
       for(int i=0;i<length;i++)
       {
         cout<<data[i]<<'\t';
       }
    }
    
    接下来就是编写主函数了,因为线性表的数据类型是不确定的,所以可以设置一个简单的菜单栏让用户进行选择输入的数据类型
    int main()
    {
           int n;int w; 
           cout<<'\n'<<"请选择您要输入的数据类型:"<<endl;
           cout<<"1.int类型"<<'\t'<<"2.char类型"<<'\n'<<endl;
           cin>>w;
           switch(w)
           {
               
           case 1:
               {
                   int a[100];int i;
                   cout<<"请输入数组的大小"<<endl;
                   cin>>n;
                   cout<<"请输入数组元素:"<<endl;   //头插法插入数据
                   for(i=0;i<n;i++)
                   {
                       cin>>a[i];
                   }
                   LinkList<int>one(a,n);    //带参构造函数
                   cout<<'\n'<<"线性表的长"<<one.Length()<<endl; 
                   cout<<'\n'<<"线性表中的内容:"<<endl;    
                   one.PrintList();  //输出线性表的数据
    
                    //按位查找
                   int s;
                   cout<<'\n'<<"请输入要查找数据的序号:";
                   cin>>s;
                   cout<<"您所查询的数据为:";
                   cout<<one.Get(s)<<endl;
    
                   //按值查找
                    int x;
                    cout<<'\n'<<"请输入要查找的数据:";
                    cin>>x;
                    cout<<"你所查找的值所在的位置为:"<<one.Locate(x)<<endl;
    
                    //按序号删除数据
                   int k;
                   cout<<'\n'<<"请输入需要删除的数据序号:";
                   cin>>k;
                   cout<<"删除成功!你所删除的数据为:"<<one.Delete(k)<<endl;
                   cout<<'\n'<<"线性表的内容为:"<<endl;
                   one.PrintList();  //输出线性表的数据
               }
               break;
           case 2:
               {
                   char a[100];int i;
                   cout<<"请输入数组的大小"<<endl;
                   cin>>n;
                   cout<<"请输入数组元素:"<<endl;   //头插法插入数据
                   for(i=0;i<n;i++)
                   {
                       cin>>a[i];
                   }
                   LinkList<char>one(a,n);    //带参构造函数
                   cout<<'\n'<<"线性表的长"<<one.Length()<<endl; 
                   cout<<'\n'<<"线性表中的内容:"<<endl;    
                   one.PrintList();  //输出线性表的数据
    
                    //按位查找
                   int s;
                   cout<<'\n'<<"请输入要查找数据的序号:";
                   cin>>s; 
                   cout<<"您所查询的数据为:";
                   cout<<one.Get(s)<<endl;
    
                    //按值查找
                   char x;
                   cout<<'\n'<<"请输入要查找的数据:";
                   cin>>x;
                   cout<< "你所查找的值所在的位置为:"<<one.Locate(x)<<endl;
    
                   //按序号删除数据
                   int k;
                   cout<<'\n'<<"请输入需要删除的数据序号:";
                   cin>>k;
                   cout<<"删除成功!你所删除的数据为:"<<one.Delete(k)<<endl;
                   cout<<'\n'<<"线性表的内容为:"<<endl;
                   one.PrintList();  //输出线性表的数据
                   cout<<endl;
               }
               break;
           }
          
       return 0;
    }
    

     

     

    输入元素后调用Length和PrintList函数,输出顺序表的长度和内容,然后依次执行查询、删除的功能,为了让用户观察到是否删除成功,可在最后调用PrintList遍历出数组元素。

     

     

    遇到的问题:

            1.在插入函数的定义时没有意识到第“j”个元素存在数组下标为”j-1”处,在输入i后才发现序号不对。

             2.在插入函数以及其他函数定义时忽略了对‘i’的判断,没有考虑到输入数据非法的问题。

     

    心得:

            通过编写程序对线性表有了初步的认识,同时对模板的使用更加熟练。更重要的是,通过自己调试程序更容易意识到程序的不足之处,可以更好的优化程序,给用户更好的体验。而且可以根据自己的需求让程序变得更多样化。最后通过自己动手定义类型,能够更深刻地体会到模板机制的优势,更能体会到顺序表随机存取的特点。

     

     

    展开全文
  • 实现顺序表的各种基本运算 一实验目的 了解顺序表的结构特点及有关概念掌握顺序表的各种基本操作 算法思想及其实现 二实验内容 编写一个程序实现顺序表的各种基本运算 1初始化顺序表 2 顺序表的插入 3顺序表的输出 4...
  • 编写程序实现顺序创建、进栈和出栈等基本操作算法。 (1) 创建包含任意个元素顺序栈。 (2) 进栈一个任意元素。 (3) 出栈一个任意元素。 (4) 取栈顶元素并输出。 *(5) 删除栈中值为给定值元素。 ...

     

    编写程序,实现顺序栈的创建、进栈和出栈等基本操作算法。
    (1) 创建包含任意个元素的顺序栈。
    (2) 进栈一个任意元素。
    (3) 出栈一个任意元素。
    (4) 取栈顶元素并输出。
    *(5) 删除栈中值为给定值的元素。
    *(6) 利用顺序表实现顺序栈元素的逆置。

     

          #include<stdio.h>

        #include<malloc.h>

        #include<ctype.h>

        #include <time.h>

        typedef int ElemType;

        typedef struct

        {

          ElemType *base;

          ElemType *top;

          ElemType stacksize;

        }SqStack;

        SqStack initiallist();

        SqStack insert(SqStack,int);

        SqStack insert1(SqStack);

        void rever(SqStack,int);

        void deletely(SqStack);

        int main()

        {

            int i=0;

            int j=0;

            int n;

            printf("\n请输入一个大于0的值使得在这个范围内随机产生栈中元素个数");

            scanf("%d",&n);

            srand((int)time(NULL));

            int m1=rand()%n+1;

            int a[n];

            SqStack q;

            SqStack q1;

            SqStack q2;

            SqStack q3;

            q=initiallist();

            q2=insert1(q);

            q1=insert(q,m1);

            q3=q1;

            printf("输出栈顶元素为");

            printf("%d",*--(q1.top));

            *++(q1.top);

            printf("\n输出栈的所有元素:");

            printf("\n");

            while(q1.top!=q1.base)

            a[i++]=*--(q1.top),printf("%d\n",*(q1.top)),j++;

             srand((int)time(NULL));

             int m2=rand()%(j);

             printf("出栈的随机元素为");

             printf("%d",a[m2]);

             printf("\n");

             rever(q3,m1);

             deletely(q3);

        }

        SqStack initiallist()

        {

        SqStack S;

        int MAXSIZE;

        printf("请输入栈中最大储存的元素个数");

        scanf("%d",&MAXSIZE);

        S.base=new int[MAXSIZE];

        if(!*S.base)

          exit(-1);

          S.top=S.base;

          S.stacksize=MAXSIZE;

          return S;

        }

     

     

       SqStack insert(SqStack q,int m1)

        {

            int k;

            int m[m1];

            printf("栈中元素个数为:");

            printf("%d",m1);

            printf("\n请输入一个大于等于0的值使得在0到这个范围内随机产生栈中元素");

            scanf("%d",&k);

            for(int j=0;j<m1;j++)

            m[j]=rand()%k;

            printf("请输出产生的随机元素\n");

            for(int k1=0;k1<m1;k1++)

            printf("%d\n",m[k1]);

            if(q.top-q.base==q.stacksize)

            printf("栈已经满");

            for(int i=0;i<m1;i++)

           {

            *(q.top)=m[i];

             q.top++;

           }

            return q;

        }

     

     

        SqStack insert1(SqStack q)

        {

            int k;

            printf("\n任意输入一个数");

            scanf("%d",&k);

            if(q.top-q.base==q.stacksize)

            printf("栈已经满");

            *(q.top)=k;

            q.top++;

            printf("\n任意入栈的一个元素是");

            printf("%d",*--(q.top));

            printf("\n");

        }

       void deletely(SqStack q1)

        {

            int t;

            int m1=0;

            int j=0;

            int a[10];

            printf("\n请输入你要删除的元素");

            scanf("%d",&t);

            *(--q1.top);

            while(*q1.top!=t)

            a[m1++]=(*q1.top)--;

            if(*(q1.top)==NULL)

            exit(-1);

            printf("\n删除成功");

            printf("\n输出第一个找到的想要删除的数是");

            printf("%d",*(q1.top));

            for(int i=0;i<=m1;i++)

            ++(*q1.top)=a[i];

             while(q1.top!=q1.base)

             {

             printf("\n%d",*(q1.top));

             *--(q1.top);

             }

        }

       void rever(SqStack q1,int m1)

    {

         int t;

         int b[m1];

         int p=m1-1;

         int j=0;

         printf("把栈中的元素弹出放在一个数组中,数组元素分别为\n");

         for(int i=0;i<m1;i++)

         {

        --q1.top;

         b[i]=*(q1.top);

         printf("%d\n",b[i]);

         }

         if(m1%2!=0)

       {

         while(j!=p)

         {

         t=b[j];

         b[j]=b[p];

         b[p]=t;

         ++j;

         --p;

         }

     

         printf("逆置后的数组元素为\n");

        for(int i1=0;i1<m1;i1++)

         printf("%d\n",b[i1]);

     

          while(q1.top!=q1.base)

          --(q1.top);

     

         for(int k=m1-1;k>=0;k--)

          {

            ++(q1.top);

           *(q1.top)=b[k];

          }

         printf("输出逆置后的栈元素\n");

         while(q1.top!=q1.base)

         {

          printf("%d\n",*(q1.top));

          --(q1.top);

          }

       }

     

         else

            {

                for(int v=1;v<=m1/2;v++)

             {

             t=b[j];

             b[j]=b[p];

             b[p]=t;

             ++j;

             --p;

             }

     

        printf("逆置后的数组元素为\n");

        for(int i1=0;i1<m1;i1++)

         printf("%d\n",b[i1]);

     

        while(q1.top!=q1.base)

          --(q1.top);

         for(int k=m1-1;k>=0;k--)

         {

          ++(q1.top);

          *(q1.top)=b[k];

          }

         printf("输出逆置后的栈元素\n");

         while(q1.top!=q1.base)

         {

          printf("%d\n",*(q1.top));

          --(q1.top);

          }

            }

     

    }

     

    展开全文
  • 顺序表的基本操作

    2019-01-23 14:35:43
    实验名称&nbsp; 顺序表的基本操作 一、实验目的: ...编写实现顺序表的基本算法(初始化、查找、插入、删除等)的函数,并在此基础上设计一个程序完成如下功能: ⑴初始化字符型顺序表L; ...

    实验名称  顺序表的基本操作

    一、实验目的:

    1、复习C语言程序设计中的知识。

    2、掌握线性表的顺序存储结构的表示和实现方法。

    3、掌握顺序表基本操作的算法实现。

    二、实验内容:

    1.建立顺序表。

    2.在顺序表上实现插入、删除和查找等操作。

    三、实验要求:

    编写实现顺序表的基本算法(初始化、查找、插入、删除等)的函数,并在此基础上设计一个主程序完成如下功能:

    ⑴初始化字符型顺序表L;

    ⑵建立顺序表L,如(a,b,c,d,c);

    ⑶输出顺序表L的长度;

    ⑷输出顺序表L的第i个元素,如第3个元素;

    ⑸输出给定元素的位置,如输出元素a的位置;

    ⑹在第i个元素前插入给定元素,如在第4个元素前插入元素f;

    ⑺删除顺序表L的第i个元素,如删除顺序表L的第3个元素。

    四、实验步骤:

    #include<stdio.h>

    #include<stdlib.h>

    #include<string.h>

    #define maxsize 1024

    typedef int elemtype;

    typedef struct sequlist

    {

    elemtype data[maxsize]; //定义顺序表为一维数组

    int last; //last为最后一个数据元素的下标位置

    }SequenList;

    //1 初始化字符型顺序表L

    SequenList * lnit_SequenList()

    {

    SequenList *L;

    L = (SequenList
    *)malloc(sizeof(SequenList));/申请分配内存空间/

    if (L != NULL) /申请分配内存空间成功/

    {

      L->last = -1;      /*顺序表为空*/
    
      printf("初始化成功!\n");
    

    }

    return L; //返回顺序表的首地址

    }

    /*2 建立顺序表L */

    SequenList *indata_SeqList(SequenList *L)

    {

    elemtype x;

    scanf("%d", &x);

    while (x != 0)

    {

      L->last += 1;
    
      L->data[L->last] = x;
    
      scanf("%d", &x);
    

    }

    printf(“顺序表建立成功!\n”);

    return L;

    }

    /3 输出顺序表L的长度/

    int SequenList_Length(SequenList *L)

    {

    return (L->last + 1);

    }

    /* 4 输出顺序表L的第i个元素*/

    int input_SequenList(SequenList *L, elemtype key)

    {

    int i;

    for (i = 0; i <= L->last;
    i++)

    {

      if (i + 1 == key)
    
      {
    
         printf("顺序表L的第i个元素为:%d\n", L->data[i]);
    
         //printf("%d",
    

    L->data[i]);

         //return L->data[i];
    
      }
    

    }

    if (key<=0 || key>(L->last))

    {

      printf("查找失败");
    

    }

    printf(“顺序表的所有元素为:\n”);

    Print_SequenList(L);

    return 0;

    }

    /* 5 输出给定元素的位置 */

    int Search_SequenList(SequenList *L, elemtype pos)

    {

    int i;

    for (i = 0; i <= L->last;
    i++)

    {

      if (L->data[i] == pos)
    
      {
    
         printf("给定元素的位置为%d:\n", i + 1);
    
         //return (i +1);
    
      }
    

    // if
    (pos!=L->data[i] && i = L->last)

      //{
    

    // printf(“查找失败”);

    // }

    }

    Print_SequenList(L);

    /* i–;

    if (i = L->last
    &&(i+1)!=pos)

    {

    printf(“查找失败”);

    }*/

    return 0;

    }

    /* 6 在第i个元素前插入给定元素*/

    int lnsert_SequenList(SequenList *L, int i, elemtype x)

    /*在顺序表L中第i个数据元素之前插入一个元素e,插入前表长n=L->last+1,

    i的合法取值范围是 1<=i<=L->last+2*/

    {

    int j;

    if (L->last >= maxsize - 1)

    {

      printf("表已满无法插入");
    
      return 0;
    

    }

    if ((i<1) || (i>L->last +
    2))

    {

      printf("插入位置i值不合法");
    
      return -1;
    

    }

    /为插入元素而移动位置/

    for (j = L->last; j >= i -
    1; j–)

    {

      L->data[j + 1] =
    

    L->data[j];

    }

    L->data[i - 1] = x; /第i个元素下标为i-1/

    L->last = L->last + 1;

    printf(“新数组为:”);

    Print_SequenList(L);

    return 1;

    }

    /7 删除顺序表的第i个元素/

    int Delete_SequenList(SequenList *L, int i, elemtype *e)

    /*在顺序表中删除第i个元素,并用指针参数e返回其值,

    i的合法取值范围为1<=i<=L.last+1*/

    {

    int k;

    if ((i<1) || (i>L->last +
    1))

    {

      printf("删除位置不合法");
    
      return 0;
    

    }

    *e = L->data[i - 1]; /将删除的元素存放到e所指向的变量中/

    for (k = i-1; k < L->last;
    k++)

    {

      L->data[k] = L->data[k +
    

    1];

      //L->last--;
    
      //Print_SequenList(L);
    

    }

    L->last–;

    Print_SequenList(L);

    return 1;

    }

    int Print_SequenList(SequenList *L)

    {

    int i;

    if (L->last == -1) /顺序表为空,返回值为0/

    {

      return 0;
    

    }

    for (i = 0; i <= L->last;
    i++)

    {

      //printf("顺序表的元素分别为:\n");
    
      printf("a[%2d]=%3d\t",
    

    i , L->data[i]);

    }

    return 1;

    }

    void main()

    {

    int i;

    SequenList *L;

    int menu;

    int len;

    int key;

    int pos;

    int x;

    printf("\n************ 欢迎使用顺序表的基本操作系统 ************\n");

    printf("\n************ 1 初始化字符型顺序表L ************\n");

    printf("\n************ 2 建立顺序表L ************\n");

    printf("\n************ 3 输出顺序表L的长度 ************\n");

    printf("\n************ 4 输出顺序表L的第i个元素 ************\n");

    printf("\n************ 5 输出给定元素的位置 ************\n");

    printf("\n************ 6 在第i个元素前插入给定元素 ************\n");

    printf("\n************ 7 删除顺序表的第i个元素 ************\n");

    printf("\n************ 8 输出顺序表的所有元素 ************\n");

    printf("\n************ 9 退出系统 ************\n");

    printf(“请选择1-9:”);

    while (1)

    {

      scanf("%d",
    

    &menu);

      switch (menu)
    
      {
    
      case 1:
    
      {
    
              L = lnit_SequenList();
    
              break;
    
      } ;
    
      case 2:
    
      {
    
              printf("请输入元素(终止输入请输入0即可):");
    
               indata_SeqList(L);
    
              break;
    
      };
    
      case 3:
    
      {
    
              len = SequenList_Length(L);
    
              printf("顺序表的长度为:%d\n", len);
    
              break;
    
      };
    
      case 4:
    
      {
    
              printf("输出顺序表L的第i个元素  :");
    
              scanf("%d", &key);
    
              input_SequenList(L, key);
    
              break;
    
      };
    
      case 5:
    
      {
    
              printf("输出给定元素的位置  :");
    
              scanf("%d", &pos);
    
              Search_SequenList(L, pos);
    
              break;
    
      };
    
      case 6:
    
      {
    
              printf("在哪个元素前插入元素?\n");
    
              scanf("%d", &i);
    
              printf("插入的元素为:");
    
              scanf("%d", &x);
    
              lnsert_SequenList(L, i, x);
    
              break;
    
      };
    
      case 7:
    
      {
    
              printf("请输入所需删除的元素编号:");
    
              scanf("%d", &i);
    
              Delete_SequenList(L, i,&i);
    
              break;
    
      };
    
      case 8:
    
      {
    
              Print_SequenList(L);
    
              break;
    
      };
    
      case 9:
    
      {
    
              printf("按任意键返回主菜单!\n");
    
              break;
    
      };
    
      default:printf("\n 没有此功能,重新输入\n");
    
         break;
    
      }
    

    }

    }

    五、实验结果:

    一、实验目的:

    1、复习C语言程序设计中的知识。

    2、掌握线性表的顺序存储结构的表示和实现方法。

    3、掌握顺序表基本操作的算法实现。

    二、实验内容:

    1.建立顺序表。

    2.在顺序表上实现插入、删除和查找等操作。

    三、实验要求:

    编写实现顺序表的基本算法(初始化、查找、插入、删除等)的函数,并在此基础上设计一个主程序完成如下功能:

    ⑴初始化字符型顺序表L;

    ⑵建立顺序表L,如(a,b,c,d,c);

    ⑶输出顺序表L的长度;

    ⑷输出顺序表L的第i个元素,如第3个元素;

    ⑸输出给定元素的位置,如输出元素a的位置;

    ⑹在第i个元素前插入给定元素,如在第4个元素前插入元素f;

    ⑺删除顺序表L的第i个元素,如删除顺序表L的第3个元素。

    四、实验步骤:

    #include<stdio.h>

    #include<stdlib.h>

    #include<string.h>

    #define maxsize 1024

    typedef int elemtype;

    typedef struct sequlist

    {

    elemtype data[maxsize]; //定义顺序表为一维数组

    int last; //last为最后一个数据元素的下标位置

    }SequenList;

    //1 初始化字符型顺序表L

    SequenList * lnit_SequenList()

    {

    SequenList *L;

    L = (SequenList
    *)malloc(sizeof(SequenList));/申请分配内存空间/

    if (L != NULL) /申请分配内存空间成功/

    {

      L->last = -1;      /*顺序表为空*/
    
      printf("初始化成功!\n");
    

    }

    return L; //返回顺序表的首地址

    }

    /*2 建立顺序表L */

    SequenList *indata_SeqList(SequenList *L)

    {

    elemtype x;

    scanf("%d", &x);

    while (x != 0)

    {

      L->last += 1;
    
      L->data[L->last] = x;
    
      scanf("%d", &x);
    

    }

    printf(“顺序表建立成功!\n”);

    return L;

    }

    /3 输出顺序表L的长度/

    int SequenList_Length(SequenList *L)

    {

    return (L->last + 1);

    }

    /* 4 输出顺序表L的第i个元素*/

    int input_SequenList(SequenList *L, elemtype key)

    {

    int i;

    for (i = 0; i <= L->last;
    i++)

    {

      if (i + 1 == key)
    
      {
    
         printf("顺序表L的第i个元素为:%d\n", L->data[i]);
    
         //printf("%d",
    

    L->data[i]);

         //return L->data[i];
    
      }
    

    }

    if (key<=0 || key>(L->last))

    {

      printf("查找失败");
    

    }

    printf(“顺序表的所有元素为:\n”);

    Print_SequenList(L);

    return 0;

    }

    /* 5 输出给定元素的位置 */

    int Search_SequenList(SequenList *L, elemtype pos)

    {

    int i;

    for (i = 0; i <= L->last;
    i++)

    {

      if (L->data[i] == pos)
    
      {
    
         printf("给定元素的位置为%d:\n", i + 1);
    
         //return (i +1);
    
      }
    

    // if
    (pos!=L->data[i] && i = L->last)

      //{
    

    // printf(“查找失败”);

    // }

    }

    Print_SequenList(L);

    /* i–;

    if (i = L->last
    &&(i+1)!=pos)

    {

    printf(“查找失败”);

    }*/

    return 0;

    }

    /* 6 在第i个元素前插入给定元素*/

    int lnsert_SequenList(SequenList *L, int i, elemtype x)

    /*在顺序表L中第i个数据元素之前插入一个元素e,插入前表长n=L->last+1,

    i的合法取值范围是 1<=i<=L->last+2*/

    {

    int j;

    if (L->last >= maxsize - 1)

    {

      printf("表已满无法插入");
    
      return 0;
    

    }

    if ((i<1) || (i>L->last +
    2))

    {

      printf("插入位置i值不合法");
    
      return -1;
    

    }

    /为插入元素而移动位置/

    for (j = L->last; j >= i -
    1; j–)

    {

      L->data[j + 1] =
    

    L->data[j];

    }

    L->data[i - 1] = x; /第i个元素下标为i-1/

    L->last = L->last + 1;

    printf(“新数组为:”);

    Print_SequenList(L);

    return 1;

    }

    /7 删除顺序表的第i个元素/

    int Delete_SequenList(SequenList *L, int i, elemtype *e)

    /*在顺序表中删除第i个元素,并用指针参数e返回其值,

    i的合法取值范围为1<=i<=L.last+1*/

    {

    int k;

    if ((i<1) || (i>L->last +
    1))

    {

      printf("删除位置不合法");
    
      return 0;
    

    }

    *e = L->data[i - 1]; /将删除的元素存放到e所指向的变量中/

    for (k = i-1; k < L->last;
    k++)

    {

      L->data[k] = L->data[k +
    

    1];

      //L->last--;
    
      //Print_SequenList(L);
    

    }

    L->last–;

    Print_SequenList(L);

    return 1;

    }

    int Print_SequenList(SequenList *L)

    {

    int i;

    if (L->last == -1) /顺序表为空,返回值为0/

    {

      return 0;
    

    }

    for (i = 0; i <= L->last;
    i++)

    {

      //printf("顺序表的元素分别为:\n");
    
      printf("a[%2d]=%3d\t",
    

    i , L->data[i]);

    }

    return 1;

    }

    void main()

    {

    int i;

    SequenList *L;

    int menu;

    int len;

    int key;

    int pos;

    int x;

    printf("\n************ 欢迎使用顺序表的基本操作系统 ************\n");

    printf("\n************ 1 初始化字符型顺序表L ************\n");

    printf("\n************ 2 建立顺序表L ************\n");

    printf("\n************ 3 输出顺序表L的长度 ************\n");

    printf("\n************ 4 输出顺序表L的第i个元素 ************\n");

    printf("\n************ 5 输出给定元素的位置 ************\n");

    printf("\n************ 6 在第i个元素前插入给定元素 ************\n");

    printf("\n************ 7 删除顺序表的第i个元素 ************\n");

    printf("\n************ 8 输出顺序表的所有元素 ************\n");

    printf("\n************ 9 退出系统 ************\n");

    printf(“请选择1-9:”);

    while (1)

    {

      scanf("%d",
    

    &menu);

      switch (menu)
    
      {
    
      case 1:
    
      {
    
              L = lnit_SequenList();
    
              break;
    
      } ;
    
      case 2:
    
      {
    
              printf("请输入元素(终止输入请输入0即可):");
    
               indata_SeqList(L);
    
              break;
    
      };
    
      case 3:
    
      {
    
              len = SequenList_Length(L);
    
              printf("顺序表的长度为:%d\n", len);
    
              break;
    
      };
    
      case 4:
    
      {
    
              printf("输出顺序表L的第i个元素  :");
    
              scanf("%d", &key);
    
              input_SequenList(L, key);
    
              break;
    
      };
    
      case 5:
    
      {
    
              printf("输出给定元素的位置  :");
    
              scanf("%d", &pos);
    
              Search_SequenList(L, pos);
    
              break;
    
      };
    
      case 6:
    
      {
    
              printf("在哪个元素前插入元素?\n");
    
              scanf("%d", &i);
    
              printf("插入的元素为:");
    
              scanf("%d", &x);
    
              lnsert_SequenList(L, i, x);
    
              break;
    
      };
    
      case 7:
    
      {
    
              printf("请输入所需删除的元素编号:");
    
              scanf("%d", &i);
    
              Delete_SequenList(L, i,&i);
    
              break;
    
      };
    
      case 8:
    
      {
    
              Print_SequenList(L);
    
              break;
    
      };
    
      case 9:
    
      {
    
              printf("按任意键返回主菜单!\n");
    
              break;
    
      };
    
      default:printf("\n 没有此功能,重新输入\n");
    
         break;
    
      }
    

    }

    }

    五、实验结果:

    在这里插入图片描述
    在这里插入图片描述

    六、实验总结:

    顺序表存储位置是相邻连续的,可以随机访问的一种数据结构,一个顺序表在使用前必须指定其长度,一旦分配内存,则在使用中不可以动态的更改。它的优点是访问数据时比较方便,缺点是定义的长度不可更改造成存储空间的浪费。

    展开全文
  • 数据结构(实验C语言版) 实验 一 顺序表的基本操作 一、实验目的 1.掌握线性表的顺序存储结构的表示...编写一个程序实现顺序表的各种基本运算(假设顺序表的元素类型为 char), 并在此基础上设计一个主程序...

    数据结构(实验C语言版)

    实验 一 顺序表的基本操作

    一、实验目的

    1.掌握线性表的顺序存储结构的表示和实现方法。
    2.掌握顺序表基本操作的算法实现。
    3.了解顺序表的应用。

    二、实验环境

    硬件环境要求: PC 机(单机) 使用的软件名称、版本号以及模块: VS2010 等。

    三、实验内容

    编写一个程序,实现顺序表的各种基本运算(假设顺序表的元素类型为 char), 并在此基础上设计一个主程序完成如下功能:
    (1)初始化顺序表 L;
    (2)依次采用尾插法插入 a、b、c、d、e 元素;
    (3)输出顺序表 L;
    (4)输出顺序表 L 的长度;
    (5)判断顺序表 L 是否为空;
    (6)输出顺序表 L 的第 3 个元素;
    (7)输出元素 a 的位置
    (8)在第 4 个元素位置上插入 f 元素
    (9)输出顺序表 L;
    (10)删除 L 的第 3 个元素;
    (11)输出顺序表 L;
    (12)释放顺序表 L。
    四、实验要求
    1、用 VS2010 工具创建文件或程序,输入代码后,进行编译运行或在控制台 执行。
    2、观看程序运行结果,并根据结果进行思考,对程序进行修改和总结。
    【核心算法提示】
    1.顺序表插入操作的基本步骤:要在顺序表中第 i 个数据元素之前插入一 个数据元素 x,首先要判断插入位置 i 是否合法,假设线性表的长为 n,则 i 的 合法值范围: 1≤i≤n+1,若是合法位置,就再判断顺序表否满,如果满,则增 加空间或结束操作,如果不满,则将第 i 个数据元素及其之后的所有数据元素都 后移一个位置,此时第 i 个位置已经腾空,再将待插入的数据元素 x 插入到该位 置上,最后将线性表的长增加 1。
    2.顺序表删除操作的基本步骤:要删除顺序表中第 i 个数据元素,首先仍然 要判断 i 的合法性, i 的合法范围是 1≤i≤n,若是合法位置,则将第 i 个数据 元素之后的所有数据都前移一个位置,最将线性表长减 1。
    3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素 则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行 比较,若相等则返回该数据元素在顺序表中的位置,否则返回 0 值。
    【核心算法描述】
    线性表的动态分配顺序存储结构—C语言实现

    #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 
    }
    

    线性表的插入:

    status Sqlist_insert(Sqlist &L,int i,Elemtype x) 
       /*在顺序表L中第i个元素前插入新元素x*/ 
    { if (i<1||i>L.length+1)  return ERROR;    /*插入位置不正确则出错*/ 
      if (L.length>=MAXLEN)return OVERFLOW; 
      /*顺序表L中已放满元素,再做插入操作则溢出*/ 
     for(j=L.length-1;j>=i-1;j--) 
        L.elem[j+1]=L.elem[j];      /*将第i个元素及后续元素位置向后移一位*/ 
     L.elem[i-1]=x;               /*在第i个元素位置处插入新元素x*/ 
     L.length++;                 /*顺序表L的长度加1*/ 
     return OK; 
    } 
    

    线性表的删除:

    status Sqlist_delete(Sqlist &L,int i,Elemtype &e) 
       /*在顺序表L中删除第i个元素* 
    { if (i<1||i>L.length) return  ERROR;      /*删除位置不正确则出错*/ 
       for(j=i;j<=L.length-1;j++) 
           L.elem[j-1]=L.elem[j];    /*将第i+1个元素及后继元素位置向前移一位*/ 
       L.length--;/*顺序表L的长度减1*/ 
       return OK}
    

    线性表元素的查找:

    int LocateElem(SqList *L, ElemType e)    //按元素值查找 
    { 
       int i=0; 
       while (i<L->length && L->data[i]!=e) 
           i++;     //查找元素e 
       if (i>=L->length)   //未找到时返回0 
         return 0; 
       else 
       return i+1;      //找到后返回其逻辑序号 
    } 
    

    输出线性表:

    void DispList(SqList *L)        //输出线性表 
    { 
        int i; 
        if (ListEmpty(L))  return; 
       for (i=0;i<L->length;i++) 
          printf("%c ",L->data[i]); 
       printf("\n"); 
    } 
    

    输出线性表第i个元素的值:

    bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值 
    { 
      if (i<1 || i>L->length) 
        return false;     //参数错误时返回false 
        e=L->data[i-1];  //取元素值 
        return true;     //成功找到元素时返回true 
    } 
    

    在这里插入图片描述

    **源代码**
    ```javascript
    #include <stdio.h> 
    #include <malloc.h> 
    #define MaxSize 50 
    typedef char ElemType; 
    typedef struct  
    { 
     ElemType data[MaxSize]; 
        int length; 
    } SqList; 
    void InitList(SqList *&L); 
    void DestroyList(SqList *L); 
    bool ListEmpty(SqList *L); 
    int ListLength(SqList *L); 
    void DispList(SqList *L); 
    bool GetElem(SqList *L,int i,ElemType &e); 
    int LocateElem(SqList *L, ElemType e); 
    bool ListInsert(SqList *&L,int i,ElemType e); 
    bool ListDelete(SqList *&L,int i,ElemType &e); 
    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) //输出线性表 
    { 
     int i; 
     if (ListEmpty(L)) return; 
     for (i=0;i<L->length;i++) 
      printf("%c ",L->data[i]); 
     printf("\n"); 
    } 
    bool GetElem(SqList *L,int i,ElemType &e) //求线性表中某个数据元素值 
    { 
     if (i<1 || i>L->length) 
      return false;   //参数错误时返回 false 
     e=L->data[i-1];    //取元素值 
     return true;    //成功找到元素时返回 true 
    } 
    int LocateElem(SqList *L, ElemType e) //按元素值查找 
    { 
     int i=0; 
     while (i<L->length && L->data[i]!=e) 
      i++;     //查找元素 e 
     if (i>=L->length)   //未找到时返回 0 
      return 0; 
     else 
      return i+1;    //找到后返回其逻辑序号 
    } 
     
    bool 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--) //将 data[i]及后面元素后移一个位置 
      L->data[j]=L->data[j-1]; 
     L->data[i]=e;    //插入元素 e 
     L->length++;    //顺序表长度增 1 
     return true;    //成功插入返回 true 
    } 
    bool 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;    //成功删除返回 true 
    } 
    void main() 
    { 
     SqList *L; 
     ElemType e; 
     printf("顺序表的基本运算如下:\n"); 
     printf("  (1)初始化顺序表 L\n"); 
     InitList(L); 
     printf("  (2)依次采用尾插法插入 a,b,c,d,e 元素\n"); 
     ListInsert(L,1,'a'); 
     ListInsert(L,2,'b'); 
     ListInsert(L,3,'c'); 
     ListInsert(L,4,'d'); 
     ListInsert(L,5,'e'); 
     printf("  (3)输出顺序表 L:"); 
     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 个元素位置上插入 f 元素\n"); 
     ListInsert(L,4,'f'); 
     printf("  (9)输出顺序表 L:"); 
     DispList(L); 
     printf("  (10)删除 L 的第 3 个元素\n"); 
         ListDelete(L,3,e); 
     printf("  (11)输出顺序表 L:"); 
     DispList(L); 
     printf("  (12)释放顺序表 L\n"); 
     DestroyList(L); 
    } 
    
    展开全文
  • 编写一个完整的程序实现顺序表的生成、插入、删除、输出等基本运算。
  • 实现顺序表的各种基本运算 一实验目的 了解顺序表的结构特点及有关概念掌握顺序表的各种基本操作 算法思想及其实现 二 实验内容 三 编写一个程序实现顺序表的各种基本运算 四 1初始化顺序表 2顺序表的插入 3顺序表的...
  • 实现顺序表各种基本运算算法

    千次阅读 多人点赞 2018-10-17 20:41:07
    编写一个头文件SqList.h,实现顺序表的各种基本操作,并在此基础上设计一个主程序(exp2_1.cpp)完成如下功能: 初始化顺序表L 依次采用尾插法插入a,b,c,d,e元素 输出顺序表L 输出顺序表L的长度 判断顺序表L...
  • 1.编写程序实现顺序表的下列基本操作: (1)初始化顺序表La。 (2)将La置为空表。 (3)销毁La。 (4)在La中插入一个新的元素。 (5)删除La中的某一元素。 (6)在La中查找某元素,若找到,则返回它在La中第一次出现...
  • 数据结构-顺序表的基本操作

    千次阅读 2017-11-01 14:59:09
    编写一个程序sqlist.cpp,实现以下顺序表的基本操作(假设顺序表的最大长度为50,元素类型ElemType为char) (1)初始化顺序表L (2)依次插入a,b,c,d,e五个元素 (3)输出顺序表L (4) 输出顺序表L的长度 (5)判断顺序...
  • 编程实现顺序表的以下基本操作:建立顺序表,修改顺序表,插入顺序表,删除顺序表。 采用顺序表结构编程实现:两集合的运算:交集/并集/差集。 2. 实验目的 通过该实验,深入理解顺序表的逻辑结构、物理结构等...
  • 顺序表基本操作

    2017-01-18 17:09:43
    编写程序实现顺序表的各种基本运算,并在此基础上设计一个主程序完成如下功能: • (1)初始化顺序表L; • (2)依次在L尾部插入元素-1,21,13,24,8; • (3)输出顺序表L; • (4)输出顺序表L长度; •...
  • 编程实现顺序表下教材第二章定义的线性表的基本操作,最好用菜单形式对应各个操作,使其编成一个完整的小软件。 (3)参考界面 注:销毁是指free(L.elem); L.elem=NULL; L.length=0; L.listsize=0; return TRUE
  • 二、实验内容1、实验内容编写一个完整的程序实现顺序表的生成、插入、删除、输出等基本运算。(1) 建立一个顺序表,含有n个数据元素。(2) 输出顺序表。(3) 在顺序表中删除值为x的结点或者删除给定位置i的...
  •  熟练掌握线性表的结构特点,掌握顺序表的基本操作,巩固c++相关的程序设计方法与技术 (2) 实验内容  建立若干元素的顺序表 实现相关的操作,输出、插入、删除、查找等功能,编写完整程序实现 (3) ...
  • 编写一个完整的程序实现顺序表的生成、插入、删除、输出等基本运算。 (1) 建立一个顺序表,含有 n 个数据元素。 (2) 输出顺序表。 (3) 在顺序表中删除值为 x 的结点或者删除给定位置 i 的结点。 (4) 实现...
  • 实验 顺序表的操作(数据结构实验)

    千次阅读 多人点赞 2019-03-20 18:22:49
    编程实现顺序表的以下基本操作:建立顺序表,修改顺序表,插入顺序表,删除顺序表。 采用顺序表结构编程实现:两集合的运算:交集/并集/差集。 3.实验目的 通过该实验,深入理解顺序表的逻辑结构、物理结构等...
  • 编程实现顺序表下教材第二章定义的线性表的基本操作,并根据已经实现的基本操作,实现两个非递减有序的线性表的合并,注意,合并时,如果有重复的元素,请保留一个。 (3)实验要求 (a)求前驱是指,输入一个元素值...
  • 1、编写程序实现顺序表的各种基本运算:初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。在此基础上设计一个主程序完成如下功能: (1)初始化顺序表L; (2)依次在表尾插入a,b...
  • 熟练掌握线性表的结构特点, 掌握顺序表的基本操作。 巩固 C++相关的程序设计方法与技术。 学会使用顺序表解决实际问题。 实验内容 顺序表的建立与操作实现 建立 n 元素的顺序表( n 的大小和表里数据自己确定) ...
  • 1、熟练掌握线性表的结构特点,掌握顺序表的基本操作。 2、巩固 C++相关的程序设计方法与技术。 3、学会使用顺序表解决实际问题。 二、实验内容 1、顺序表的建立与操作实现 建立 n 元素的顺序表(n 的...
  • 顺序表的实现和应用

    2019-06-07 22:37:57
    编写一个程序对所实现的线性表进行测试; ⑷线性表应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B并集C,并用线性表L3代表集合C;②(选做)设线性表L1和L2中数据元素为整数,且均已按值非...
  • 1、熟练掌握线性表的结构特点,掌握顺序表的基本操作。 2、巩固 C++相关的程序设计方法与技术。 3、学会使用顺序表解决实际问题。 三.实验内容 建立 n 元素的顺序表(n 的大小和表里数据自己...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 333
精华内容 133
关键字:

编写一个程序实现顺序表的基本操作