第一天--------顺序表的基本操作（付源码）

这是代码，源码在下方

一、 实验目的

    1．掌握顺序存储结构的特点。

    2．掌握顺序存储结构的常见算法。

二、实验内容

1、实验内容

编写一个完整的程序，实现顺序表的生成、插入、删除、输出等基本运算。

（1）    建立一个顺序表，含有n个数据元素。

（2）    输出顺序表。

（3）    在顺序表中删除值为x的结点或者删除给定位置i的结点。

（4）    实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数。

（5）    输入整型元素序列，利用有序表插入算法建立一个有序表。

（6）    *利用算法5建立两个非递减有序表A和B，并把它们合并成一个非递减有序表C。

（7）    在主函数中设计一个简单的菜单，分别测试上述算法。

（8）    *综合训练：

    利用顺序表实现一个班级学生信息管理（数据录入、插入、删除、排序、查找等）。

 

2、主要数据类型与变量

#define MAXSIZE 100 //表中元素的最大个数

         typedef int ElemType;  //元素类型

         typedef struct

         {

            ElemType *elem;  //线性表

            int length;   //表的实际长度

            int listsize;   //当前分配的存储容量

         }SqList;   //顺序表的类型名

 

3、算法思想描述

将顺序存储结构的各个头信息和框架搭好后，可以通过在主菜单页面的各个选项进入对应功能区完成任务，如建立顺序表，遍历顺序表，删除第i个元素，删除值为x的元素，奇数排在偶数之前，插入法生成递增有序表，两个非递减有序表La和Lb合并成非递减有序表Lc，等的一系列功能，如建立顺序表时，是先申请一部分的内存，将表的长度置0，判断是否申请内存成功，然后返回，如删除值为x的元素，需要对表结构进行遍历，判断那个值与所需要删除的值是相同的，然后删除，并且表的长度减一，不然会出现下标越界的可能。

 

三、系统测试

2、测试结果

完成第一二项，建立顺序表和遍历顺序表

删除第i个元素

删除值为X的元素

奇数排在偶数前

插 入 法 生 成 递 增 有 序 表

两个非递减有序表La和Lb合并成非递减有序表Lc

附：程序源代码

DS.h

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

 

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

 

typedef int Status;

 

SqList.h

#ifndef SQLIST_H_INCLUDED

#define SQLIST_H_INCLUDED

 

#include "DS.h"

 

typedef int ElemType;

#define LIST_INIT_SIZE 50

typedef struct

{

   ElemType *elem;

   int length;

   int listsize;

}SqList;

 

void menu();

Status InitList_Sq(SqList &L);/*初始化顺序表*/

Status CreateList_Sq(SqList &L);/*建立顺序表*/

void PrintList_Sq(SqList L);/*输出顺序表*/

Status DeleteList_Sq(SqList &L,inti,ElemType &e);/*删除第i个元素*/

Status DeleteListX_Sq(SqList&L,ElemType x);/*删除值为x的元素*/

Status AdjustList_Sq(SqList &L);/*奇数排在偶数之前*/

Status OrderList_sq(SqList &L, intn);/*插入法生成递增有序表*/

void MergeList_Sq(SqList La, SqList Lb,SqList &Lc );/*两个非递减有序表A和B，并把它们合并成一个非递减有序表C*/

 

#endif // SQLIST_H_INCLUDED

 

SqList.cpp

#include "SqList.h"

 

void menu()

{

   printf("\t\t\t   顺序表基本操作\n\n");

   printf("\t\t\t1.建  立 顺  序  表\n");

   printf("\t\t\t2.遍  历 顺  序  表\n");

   printf("\t\t\t3.删 除 第 i 个 元素\n");

   printf("\t\t\t4.删 除 值 为 x 的元 素\n");

   printf("\t\t\t5.奇 数 排 在 偶 数 之 前\n");

   printf("\t\t\t6.插 入 法 生 成 递 增 有 序 表\n");

   printf("\t\t\t7.两个非递减有序表La和Lb合并成非递减有序表Lc\n");

   printf("\t\t\t0.退          出\n\n");

}

 

/*初始化顺序表*/

Status InitList_Sq(SqList &L)

{

   L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));

   if(!L.elem) exit(OVERFLOW);

   L.length=0;

   L.listsize=LIST_INIT_SIZE;

   return OK;

}

 

/*建立顺序表*/

Status CreateList_Sq(SqList &L)

{

   int n, i;

   printf("请输入顺序表长度：");

   scanf("%d", &n);

   if(n < LIST_INIT_SIZE && InitList_Sq(L))

    {

       printf("请输入%d个元素：",n);

       for(i = 0; i < n; i++)

       {

           scanf("%d", &L.elem[i]);

       }

       L.length = n;

       return OK;

    }

   else

       return ERROR;

}

 

/*输出顺序表*/

void PrintList_Sq(SqList L)

{

   int i;

    printf("顺序表中元素为：\n");

   for(i = 0; i < L.length; i++)

    {

       printf("%d ", L.elem[i]);

    }

   printf("\n");

}

 

/*删除第i个元素*/

Status DeleteList_Sq(SqList &L,inti,ElemType &e)

{

       ElemType*p, *q;

       if((i<1) || (i>L.length) ) return ERROR;

       p= &(L.elem[i-1]);

       e= *p;

     q = L.elem+L.length-1;

       for(++p;p <= q; ++p) *(p-1) = *p;

       --L.length;

       returnOK;

}

 

/*删除值为x的元素*/

Status DeleteListX_Sq(SqList&L,ElemType x)

{

   int i,j=0,k=1;

   int n=L.length;

   for(i=0;i<n;i++){

       if(L.elem[i] != x){

           L.elem[j++] = L.elem[i];

       }else{

           k=0;

           L.length--;

       }

    }

   if(k==1){

       printf("查无此值。");

       return ERROR;

    }

   return OK;

}

 

/*奇数排在偶数之前*/

Status AdjustList_Sq(SqList &L)

{

/*

   int i,j,t;

   for(i=0;i<L.length;i++){

       if((L.elem[i]%2)==0){

           for(j=i+1;j<L.length;j++){

                if((L.elem[j]%2)==1){

                    t=L.elem[i];

                    L.elem[i]=L.elem[j];

                    L.elem[j]=t;

                }

           }

       }

    }

*/

 

/*奇数排在偶数之前*/

   ElemType *p,*q;

   int t=0;

   int len=L.length;

   p=L.elem;

   q=L.elem+L.length-1;

   //printf("%d %d",*p,*q);

 

  while(p<q){

       if(!(*p&1)){//从头开始遇到偶数为真

          if((*q&1)){//从尾开始遇到奇数为真

                t=*p;

                *p=*q;

                *q=t;

          }else{

           q--;

          }

       }else{

           p++;

       }

   }

 

/*

   ElemType *p,*q,*j;

   int i = L.length-1;

   p=L.elem;

 

   int i;

   while(p < q){

       while(p<L.length && (*p&1==0))

           p++;

       while(q>=0 && *q&1==1)

           q++;

       if(p < q){

           j = p;

           p=q;

           q=j;

       }

    }

*/

}

 

/*插入法生成递增有序表*/

Status OrderList_sq(SqList &L, int n)

{

 

   L.elem = (ElemType*)malloc(2*n*sizeof(ElemType));

   L.length=0;

   L.listsize=2*n;

 

   int i,j,k,x;

   printf("请输入%d个数:",n);

   for(i=0;i<n;i++){

       scanf("%d",&x);

       ElemType *p,len=L.length;

       p=L.elem;

 

       for(j=0;j<len;j++){

           if(x>p[j]) continue;

           for(k=len;k>j;k--){

                p[k] = p[k-1];

           }

           p[j] = x;

           break;

       }

       if(j>=len){

           p[len] = x;

       }

       L.length++;

    }

 

   return OK;

}

 

/*两个非递减有序表A和B，并把它们合并成一个非递减有序表C*/

void MergeList_Sq(SqList La, SqList Lb,SqList &Lc )

{

   ElemType *pa, *pb, *pc, *pa_last, *pb_last;

   pa = La.elem; pb = Lb.elem;

   Lc.listsize = Lc.length = La.length+Lb.length;

   pc = Lc.elem = (ElemType *)malloc(Lc.listsize * sizeof(ElemType));

   if (!Lc.elem) exit (OVERFLOW);

   pa_last = La.elem + La.length - 1;

   pb_last = Lb.elem + Lb.length - 1;

   while (pa <= pa_last && pb <= pb_last)

    {

       if (*pa <= *pb) *pc++ = *pa++;

       else *pc++ = *pb++;

    }

   while(pa <= pa_last) *pc++ = *pa++;

   while(pb <= pb_last) *pc++ = *pb++;

}

 

Main.cpp

#include "SqList.h"

 

int main()

{

   int choice, n, i, x;

   SqList L, La, Lb, Lc;

   while(1)

    {

       menu();

       printf("选择你的操作：");

       scanf("%d",&choice);

       switch(choice)

       {

           case 1:

                if(CreateList_Sq(L))   //形参为引用型参数，实参只需要传送变量名即可，以下函数调用均是如此

                    printf("顺序表创建成功\n");

                else

                    printf("顺序表创建失败\n");

                break;

           case 2:

                PrintList_Sq(L);

                break;

           case 3:

                printf("请输入删除元素的位置：");

                scanf("%d", &i);

                if(DeleteList_Sq(L, i, x))

                    printf("被删除元素值为：%d\n",x);

                else

                    printf("删除失败\n");

                break;

           case 4:

                printf("请输入删除元素值：");

                scanf("%d", &x);

                if(DeleteListX_Sq(L, x))

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

                else

                    printf("删除失败\n");

                PrintList_Sq(L);

                break;

           case 5:

                AdjustList_Sq(L);

                printf("新链表为：\n");

                PrintList_Sq(L);

                break;

           case 6:

                printf("请输入顺序表长度：");

                scanf("%d", &n);

                if(OrderList_sq(L, n))

                {

                    printf("值有序顺序表为：\n");

                    PrintList_Sq(L);

                }

                else

                    printf("顺序表创建失败\n");

                break;

           case 7:

                printf("请输入顺序表La的长度：");

                scanf("%d", &n);

                OrderList_sq(La, n);

                printf("请输入顺序表Lb的长度：");

                scanf("%d", &n);

                OrderList_sq(Lb, n);

                MergeList_Sq(La, Lb, Lc);

                printf("合并后的顺序表为：\n");

                PrintList_Sq(Lc);

                break;

           case 0:

                return 0;

           default:

                printf("输入错误，请重新输入\n");

       }

    }

}