第三周项目1——顺序表的基本运算

问题及代码：

1. /* 
2.  
3. copyright （t） 2016，烟台大学计算机学院 
4.  
5. *All rights reserved. 
6.  
7. *文件名称：wu.cpp 
8.  
9. *作者：武昊 
10.  
11. *完成日期：2016年9月18日 
12.  
13. *版本号：v1.0 
14.  
15. *问题描述：用函数实现顺序表的10个基本运算（见下），并用main函数完成调试工作 
16.  
17. *输入描述：无 
18.  
19. *程序输出：无 
20.  
21. */  
22. 1. #include <iostream>  
    2. #include <malloc.h>  
    3. #include <cstdio>  
    4. #define Maxsize 100  
    5. using namespace std;  
    6. typedef int Elemtype;          //自定义数据类型  
    7. typedef struct list  
    8. {  
    9.     Elemtype data[Maxsize];    //存顺序表元素  
    10.     int length;                //存顺序表长度  
    11. } Sqlist;  
    12.   
    13. //实现算法的自定义函数以及其他必要的自定义函数  
    14. void CreateList(Sqlist *&l,Elemtype a[],int n)    //由a中的n个元素建立顺序表  
    15. {  
    16.     int i;  
    17.     l=(Sqlist *)malloc(sizeof(Sqlist));           //分配存储空间  
    18.     for(i=0;i<n;i++)  
    19.         l->data[i]=a[i];                          //存放元素  
    20.     l->length=n;                                  //设置长度  
    21. }  
    22. void DispList(Sqlist *l)                          //输出线性表  
    23. {  
    24.     int i;  
    25.    // if(ListEmpty(l))  
    26.     //    return;  
    27.     for(i=0;i<l->length;i++)  
    28.         printf("%d ",l->data[i]);  
    29.     printf("\n");  
    30. }  
    31. bool ListEmpty(Sqlist *l)                        //布尔型函数判断顺序表是否为空表  
    32. {  
    33.     return (l->length==0);                       //空返回0 非空返回1  
    34. }  
    35. int ListLength(Sqlist *l)                        //求顺序表长度  
    36. {  
    37.     return (l->length);  
    38. }  
    39. bool GetElem(Sqlist *l,int i,Elemtype &e)        //求顺序表中某个数据元素值  
    40. {  
    41.     if(i<1 || i>l->length)                       //i为逻辑序号，注意参数错误的情况  
    42.         return false;                            //参数错误返回false  
    43.     e=l->data[i-1];  
    44.     return true;                                 //找到指定下标元素返回true  
    45. }  
    46. int LocateElem(Sqlist *l,Elemtype e)             //按元素值查找顺序表中元素  
    47. {  
    48.     int i=0;  
    49.     while(i<l->length && l->data[i]!=e)          //e不是要查找的元素，继续往下遍历  
    50.         i++;  
    51.     if(i>=l->length)  
    52.         return 0;                                //遍历一遍未找到返回false  
    53.     else  
    54.         return i+1;                              //否则找到返回true  
    55. }  
    56. bool ListInsert(Sqlist *&l,int i,Elemtype e)     //插入数据元素  
    57. {  
    58.     int j;  
    59.     if(i<1 || i>l->length+1 || l->length>=Maxsize)//i为逻辑序号，注意参数错误的情况  
    60.         return false;                             //参数错误返回false  
    61.     i--;                                          //顺序表逻辑序号转化为物理序号  
    62.     for(j=l->length-1;j>i;j--)  
    63.         l->data[j]=l->data[j-1];                  //"后者覆盖前者"  
    64.     l->data[i]=e;                                 //找到插入位置插入  
    65.     l->length++;  
    66.     return true;  
    67. }  
    68. bool ListDelete(Sqlist *&l,int i,Elemtype &e)     //删除数据元素  
    69. {  
    70.     int j;  
    71.     if(i<1 || i>l->length+1)                      //i为逻辑序号，注意参数错误的情况  
    72.         return false;                             //参数错误返回false  
    73.     i--;                                          //顺序表逻辑序号转化为物理序号  
    74.     e=l->data[i];                                 //被删除元素  
    75.     for(j=i;j<l->length-1;j++)  
    76.         l->data[j]=l->data[j+1];                  //"后者覆盖前者"  
    77.     l->length--;  
    78.     return true;  
    79. }  
    80. void InitList(Sqlist *&l)                        //初始化线性表  
    81. {  
    82.     l=(Sqlist *)malloc(sizeof(Sqlist));          //分配存储空间  
    83.     l->length=0;                                 //置空线性表，其长度为0  
    84. }  
    85. void DestroyList(Sqlist *&l)                     //销毁顺序表  
    86. {  
    87.     free(l);  
    88. }  
    89.   
    90. //定义用于驱动测试的main函数  
    91. int main()  
    92. {  
    93.     Sqlist *l;  
    94.     Elemtype a[10]={1,2,3,4,5,6,7,8,9,10};  
    95.     Elemtype b[5]={5,8,7,4,6};  
    96.     Elemtype e;  
    97.     int loc;  
    98.     CreateList(l,a,10);  
    99.     cout<<"建立的顺序表中各元素为："<<endl;  
    100.     DispList(l);  
    101.     cout<<"此线性表长度为："<<ListLength(l)<<endl;  
    102.     if(GetElem(l,3,e))                             //测试在范围内的情形  
    103.         printf("找到了第3个元素值为：%d\n", e);  
    104.     else  
    105.         printf("第3个元素超出范围！\n");  
    106.   
    107.     if(GetElem(l,15,e))                            //测试不在范围内的情形  
    108.         printf("找到了第15个元素值为：%d\n",e);  
    109.     else  
    110.         printf("第15个元素超出范围！\n");  
    111.   
    112.     if((loc=LocateElem(l,8))>0)                    //测试能找到的情形  
    113.         printf("找到了，值为8的元素是第 %d 个\n",loc);  
    114.     else  
    115.         printf("值为8的元素木有找到！\n");  
    116.   
    117.     if((loc=LocateElem(l,17))>0)                 //测试不能找到的情形  
    118.         printf("找到了，值为17的元素是第 %d 个\n",loc);  
    119.     else  
    120.         printf("值为17的元素木有找到！\n");  
    121.     DestroyList(l);  
    122.     cout<<"此顺序表被销毁"<<endl;  
    123.     cout<<endl;  
    124.   
    125.     CreateList(l,b,5);  
    126.     cout<<"建立的顺序表中各元素为："<<endl;  
    127.     DispList(l);  
    128.     cout<<"此线性表长度为："<<ListLength(l)<<endl<<endl;  
    129.   
    130.     ListInsert(l,4,2);  
    131.     cout<<"在4位置插入元素2后的顺序表为："<<endl;  
    132.     DispList(l);  
    133.   
    134.     ListDelete(l,2,e);  
    135.     cout<<"在2位置删除元素8后的顺序表为："<<endl;  
    136.     DispList(l);  
    137.       
    138.     DestroyList(l);  
    139.     cout<<"此顺序表被销毁"<<endl;  
    140.     cout<<endl;  
    141.       
    142.     return 0;  
    143. }  
    144. 运行结果：
    145. 

    146. 知识点总结：

            算法库的应用可以帮助我们节省时间，使我们更好的运用数据。

    147. 学习心得：

           算法库直接调用，我们应在数据结构的学习过程中不断积累巩固。