2、顺序表

|   版权声明：本文为博主原创文章，未经博主允许不得转载。

   

　　从这节开始，以后的每一篇博文均会只描述一种结构。这节要解决的是有关顺序表的问题，下面就是一些顺序表的基本的知识点：

        1. 顺序表其实就是线性表的一种，它除开始节点和结束节点之外的其他节点，均有且只有一个直接前趋和一个直接后继，开始

节点只有一个后继节点，结束节点只有一个前趋节点。

        2. 用顺序存储方法存储的线性表就称为顺序表。

        3. 顺序存储方法就是将表的节点按逻辑上的次序依次的存放在一组连续的内存单元中，这里是指在逻辑上连续排列，在物理的

存储单元上也连续的排列。

        4. 在顺序表中，因为顺序表的每一个单元均是同种类型的数据，因此它们的每一个的节点的内存单元的空间是一样大的，我们

可以根据下面的公式，来求得某个节点的存储地址：

                                      

>>.分步代码

　　1>.  顺序表的结构体定义(代码如下)：

         

             在结构体中，有顺序表的当前容量，有顺序表的首地址listData，还要有顺序表的总大小listSize。

　　2>.  顺序表的初始化(代码如下)：

         

     3>.  顺序表的表长(代码如下)：

          

     4>.  插入元素

         

　  5>.  追加空间

         

     

     6>.  判断顺序表是否为空

         

　  7>.  判断顺序表是否已满

        

    8>.  查找某个元素

         

    9>.  打印顺序表

         

    10>. 查找某个元素的前趋

         

   

   11>. 查找某个元素的后继

         

   12>. 在pos位置插入元素

         

   13>. 在pos位置删除元素

         

   14>. 销毁整个顺序表

         

   15>. 将当前表长至为0

         

>>.完整代码

/******************************************************
*                   数据结构-顺序表                     *
*                                                     *
*                      2016/7/25                      *
*                                         by Lipei    *
******************************************************/

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

#define OK                1
#define ERROR            0
#define OVERFLOW        -1
//顺序表初次分配空间的大小
#define INIT_SIZE        100
//顺序表追加空间的大小
#define APPEND_SIZE        10

typedef int STATUS;
typedef int ELEMTYPE;

//顺序表的结构体定义
typedef struct
{
    //顺序表中的元素
    ELEMTYPE* listData;
    //顺序表的当前的长度
    int length;
    //顺序表的分配的总大小
    int listSize;
}orderList;

//追加空间(在空间不足的情况之下)
void appendListSpace(orderList& list)
{
    ELEMTYPE* newList;
    newList = (ELEMTYPE *) realloc(list.listData, (list.listSize+APPEND_SIZE)*sizeof(ELEMTYPE));
    if(!newList)
    {
        exit(OVERFLOW);
    }
    else
    {
        list.listData = newList;
        list.listSize = list.listSize + APPEND_SIZE;
    }
}

//初始化顺序表
//'*'号改成'&'号也行，将指针改成引用，下面对应的'->'则要变成'.'
STATUS initOrderList(orderList* list)        
{
    //其实在这里也可以使用C++中的动态内存的分配new关键字。此处个人习惯喜欢使用malloc
    list->listData = (ELEMTYPE *) malloc(INIT_SIZE * sizeof(ELEMTYPE));
    //判断空间分配是否成功
    if(!list->listData)
    {
        //分配失败
        cout << "空间分配失败！！！" << endl;
        exit(OVERFLOW);
    }
    else
    {
        //初始化当前的表长
        list->length = 0;
        //初始化表的总大小
        list->listSize = INIT_SIZE;
    }
    return OK;
}

//判断顺序表是否为空
bool isEmpty(orderList& list)
{
    //如果顺序表的当前长度为0，则说明顺序表为空
    if(list.length == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//判断顺序表是否已满
bool isFull(orderList& list)
{
    //如果顺序表的当前长度已经等于了顺序表的大小，则表明顺序表已满
    if(list.length >= list.listSize)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//表头元素
void insertList(orderList* list, ELEMTYPE elem)
{
    //在插入元素之前，首先应该判断顺序表是否已满
    if(isFull(*list))
        appendListSpace(*list);
    list->listData[list->length] = elem;
    list->length++;
    return;
}

//取得当前顺序表的容量（及在当前的情况下，顺序表中有几个元素）
STATUS getListLength(orderList* list)
{
    return list->length;
}

//遍历整个顺序表(使用对象来实现)
void visitList(orderList list)
{
    int i = 0;
    cout << "List Data:  ";
    for(; i < list.length; i++)
    {
        cout << list.listData[i] << ", ";
    }
    cout << endl;
}

//查找某个元素是否存在
STATUS findElem(orderList* list, ELEMTYPE elem)
{
    //在查找元素之前，判断顺序表是否为空
    if(isEmpty(*list))
    {
        cout << "orderList is empty!" << endl;
    }
    int i;
    for(i=0; i<list->length; i++)
    {
        if(list->listData[i]==elem)
        {
            cout << "The orderList of elems exist in table " << list->listData[i] << " !" << endl;
            return OK;
        }
    }
    cout << "The orderList is not "  << elem << " elem!" << endl;
    return ERROR;
}

//查找某个元素的前趋
STATUS getFrontElem(orderList list, ELEMTYPE elem)
{
    //查找元素前判断顺序表是否为空
    if(isEmpty(list))
        return OVERFLOW;
    for(int i=0; i<list.length; i++)
    {
        if(elem==list.listData[i])
        {
            //注意是否为开始节点，开始节点是没有前趋的。
            if(i == 0)
            {
                cout << "开始节点不存在前趋!" << endl;
                return OVERFLOW;
            }
            else
                return list.listData[i-1];
        }
    }
    return ERROR;
}

//查找某个元素的后继
STATUS getRearElem(orderList list, ELEMTYPE elem)
{
    //查找元素前判断顺序表是否为空
    if(isEmpty(list))
        return OVERFLOW;
    for(int i=0; i<list.length; i++)
    {
        if(elem==list.listData[i])
        {
            //在判断后继的过程中，要注意查找的元素是否为结束节点
            if(i >= list.listSize)
            {
                cout << "已到达表的末尾!结束节点不存在后继!" << endl;
                return OVERFLOW;
            }
            else
                return list.listData[i+1];
        }
    }
    return ERROR;
}

//删除 pos 位置的那个元素(在删除这个元素之后，此元素之后的所有的元素要前移)
STATUS deletePosElem(orderList& list, int pos, ELEMTYPE *elem)
{
    //首先判断当前的顺序表是否为空，空表的话删了没必要
    if(isEmpty(list))
    {
        cout << "The orderList is Empty!" << endl;
        return ERROR;
    }
    //判断pos位置是否超出了表的当前容量
    if(pos >= list.length)
    {
        return ERROR;
    }
    *elem = list.listData[pos];
    for(int i=pos; i<=list.length-1; i++)
        list.listData[i] = list.listData[i+1];
    //因为删除表中的一个元素，表的当前长度减1
    list.length--;
    return OK;
}

//pos 位置插入元素(在pos元素之后插入元素后，pos位置之后的所有的元素要后移)
STATUS addPosElem(orderList& list, int pos, ELEMTYPE elem)
{
    //在插入元素之前，判断表是否已满，满了就追加空间
    if(isFull(list))
        appendListSpace(list);
    //判断pos位置是否合理，如果pos位置大于表的当前的容量的话，
    //是不能向表中插入的（因为这样就不是顺序表了）!
    if(pos >= list.length)
        return ERROR;
    //在插入元素前，首先要将pos位置后的元素全部后移一位。将pos位置腾空出来.
    for(int i=list.length-1; i>=pos; i--)
        list.listData[i+1] = list.listData[i];
    list.listData[pos] = elem;
    list.length++;
    return OK;
}

//销毁整个顺序表
void destoryList(orderList* list)
{
    //首先将顺序表的当前容量设为0
    list->length = 0;
    free(list->listData);
}

//将表的当前容量设为0
void toZeroLength(orderList* list)
{
    list->length = 0;
}

void DisplayFunc()
{
    cout << "0  --> 退出程序" << endl;
    cout << "1  --> 初始化空表" << endl;
    cout << "2  --> 插入元素" << endl;
    cout << "3  --> 判断顺序表是否为空" << endl;
    cout << "4  --> 判断顺序表是否已满" << endl;
    cout << "5  --> 查找某个元素是否存在" << endl;
    cout << "6  --> 打印整个顺序表" << endl;
    cout << "7  --> 查找某个元素的前趋" << endl;
    cout << "8  --> 查找某个元素的后继" << endl;
    cout << "9  --> 在某个位置插入元素" << endl;
    cout << "10 --> 在某个位置删除元素" << endl;
    cout << "11 --> 当前的表长" << endl;
    cout << "12 --> 销毁整个顺序表" << endl;
    cout << "13 --> 将当前的表容量至为0" << endl << endl << endl;
}

int main(void)
{    
    DisplayFunc();
    int n;
    int time = 0;
    int i = 0;
    int elem;
    int flag;
    int pos;
    int length;
    orderList list;
    while(1)
    {
        cout << "Please enter your select : ";
        cin >> n;

        switch(n)
        {
        case 1:
            initOrderList(&list);
            cout << endl;
            break;
        case 2:
            cout << "Please enter times: ";
            cin >> time;
            for(i=0; i<time; i++)
            {
                cin >> elem;
                insertList(&list, elem);
            }
            cout << endl;
            break;
        case 3:
            if(isEmpty(list))
                cout << "orderList is empty!" << endl;
            else
                cout << "orderList is have elems!" << endl;
            cout << endl;
            break;
        case 4:
            if(isFull(list))
                cout << "orderList is full!" << endl;
            else
                cout << "orderList is not full!" << endl;
            cout << endl;
            break;
        case 5:
            cout << "Enter you find number: ";
            cin >> elem;
            findElem(&list, elem);
            cout << endl;
            break;
        case 6:
            cout << "Print the list: " << endl;
            visitList(list);
            cout << endl;
            break;
        case 7:
            cout << "Enter find elem: ";
            cin >> elem;
            flag = getFrontElem(list, elem);
            if(flag==OVERFLOW || flag==ERROR)
                cout << "Is not find, error!" << endl;
            else
                cout << "The top " << elem << " chemotactic elements is " << flag << " !" << endl;
            cout << endl;
            break;
        case 8:
            cout << "Enter find elem: ";
            cin >> elem;
            flag = getRearElem(list, elem);
            if(flag==OVERFLOW || flag==ERROR)
                cout << "Is not find, error!" << endl;
            else
                cout << "The elem " << elem << " subsequent element of " << flag << " !" << endl;
            cout << endl;
            break;
        case 9:
            cout << "Please enter Location: ";
            cin >> pos;
            cout << "Please enter add elem: ";
            cin >> elem;
            flag = addPosElem(list, pos, elem);
            if(flag==OK)
            {
                //delect success
                cout << pos << " location is add successful! The add orderList elem is " << elem << " ." << endl;
                cout << "Print the list: " << endl;
                visitList(list);
            }
            else
            {
                cout << "Error! add failure." << endl;
            }
            cout << endl;
            break;
        case 10:
            cout << "Please enter Location: ";
            cin >> pos;
            flag = deletePosElem(list, pos, &elem);
            if(flag==OK)
            {
                //delect success
                cout << pos << " location is delete successful! The delete orderList elem is " << elem << " ." << endl;
                cout << "Print the list: " << endl;
                visitList(list);
            }
            else
            {
                cout << "Error! delete failure." << endl;
            }
            cout << endl;
            break;
        case 11:
            length = getListLength(&list);
            cout << "The orderList length is " << length << " ." << endl;
            cout << endl;
            break;
        case 12:
            destoryList(&list);
            cout << "The orderList destory is successful!" << endl;
            cout << endl;
            break;
        case 13:
            toZeroLength(&list);
            cout << "The orderList to list size of zero is successful!" << endl;
            cout << endl;
            break;
        case 0:
            cout << "Progarm is exit, enter any key shout black windows!" << endl;
            exit(0);
            cout << endl;
            break;
        }
    }

    return 0;
}

程序运行截图：