數據結構與算法（二）簡單數據結構

1. 線性表

由n個相同類型的元素組成的有限序列
有且僅有一個第一個節點（頭節點）和最後一個節點（末節點），第一個元素無前趨，最後一個元素無後繼，其餘元素只有一個前趨一個後繼

1.1 順序表(sequence list)

    內存連續，連續存儲，相鄰元素在內存中的位置也相鄰
    優點：
        1. 無需爲表示數據元素之間的關係而增加額外的存儲空間
        2. 可以隨機存取表中的任一數據元素，元素存儲位置可以用一個簡單、直觀的公式表示（sizeof(elemtype)*index）
    缺點：
        1. 插入和刪除運算必須移動（操作位置之後的所有數據）大量數據，效率低
        2. 必須預先分配內存空間，造成空間利用率低，且容量難以擴充

1.2 鏈表(link list)

    鏈式存儲，不要求相鄰元素在內存中的位置也相鄰
    優點：
        1. 無順序表的缺點（插入和刪除非常高效，不需要移動元素內存；不需要預分配內存空間，可以很方便的擴容）
    缺點：
        1. 無順序表的優點（需要添加額外的存儲空間表示後繼元素的地址，不可以隨機存取）

    3.1.2.1 循環鏈表
        末結點的後繼爲頭結點，形成環
    3.1.2.2 雙向鏈表
        添加存儲單元存儲元素的前驅

1.3 棧(stack)

    棧是操作受限的線性表；限定對元素的插入和刪除只能在表的一端進行；通常把進行插入和刪除操作的這一端稱作棧頂（Top），另一端稱做棧低（Bottom）；
    最後進棧的元素最先出棧，棧也被稱爲後進先出表（LIFO）
    棧的運算：
        置空棧setnull
        判棧空empty
        進棧push
        出棧pop
        讀取棧頂元素gettop(只讀取，不出棧)

1.4 隊列

    隊列(queue)也是一種操作受限制的線性表；限定所有的插入只能在表的一端進行；所有的刪除只能在表的另一端進行；允許插入的一端叫做隊尾（rear），允許刪除的一端叫做隊頭（front）；
    隊列的操作是按先進先出的原則進行的，因此隊列也稱作先進先出的線性表（FIFO）
    隊列的運算：
        初始化隊列iniqueue
        入隊列addqueue
        出隊列outqueue
        讀隊頭元素gethead
        判斷隊空empty

    假溢出：在刪除元素後沒有移動順序表中的元素，導致順序表未填滿但是rear已經是順序表的最後位置了
        解決方式：
            每次刪除數據後移動元素，並修改rear值
            或在發生假溢出時，所有數據向前移動
        兩種解決方式都會引起大量的元素移動，最常用的方法是使用循環隊列（假想順序表的首尾相連，則不需要移動數據，也不存在假溢出）

1.4.1 循環隊列

1.4.2 鏈隊列

1.5 廣義表

    廣義表是線性表的一個推廣，廣義表的元素可以是一個記錄，也可以是一個結構或者廣義表
    廣義表的運算：
        求長度
        求深度

#include <stdio.h>

struct elemtype
{
    int id;
    char name[20];
};

// 順序表
#define MAX_SIZE 500
struct sequencelist
{
    elemtype data[MAX_SIZE];
    int last;
};

// 鏈表
struct node
{
    elemtype data;
    node *next;
} linklist;

//棧
struct seqstack
{
    elemtype data[MAX_SIZE];
    int top; //棧頂位置
};

//隊列（循環隊列）
struct sequeue
{
    elemtype queue[MAX_SIZE];
    int front, rear;
};

//鏈隊列
struct linknode
{
    elemtype data;
    linknode *next; //後繼
};

struct linkqueue
{
    linknode *front, *rear;
};

//廣義表
struct glistnode
{
    int atom; // atom = 0 時爲子表
              // atom = 1 時爲元素
    union {
        glistnode *snext;
        elemtype data;
    } elementdata;

    glistnode *next;
} glist;

//操作

//置空
void setnull(const sequencelist &)
{
}

//求長度
int length(const sequencelist &list)
{
    return list.last + 1;
}

//取元素
elemtype *get(const sequencelist &list, int index)
{
    if (index <= list.last)
        return (elemtype *)&(list.data[index]);
    return nullptr;
}

//取前趨
elemtype *prior(const sequencelist &, const elemtype &);
//取後繼
elemtype *next(const sequencelist &, const elemtype &);
//定位序
int locate(const sequencelist &list, const elemtype &item);
//插入
void insert(sequencelist &list, const elemtype &item, int index);
//刪除
void del(sequencelist &list, int index);

int main()
{
    sequencelist list;

    return 0;
}