数组&链表

线性表：在逻辑上一组具有前后对应关系的元素的集合

特征：

1. 必存在唯一的“第一元素”
2. 必存在唯一的“最后元素”
3. 除最后元素外，其他元素均存在后驱
4. 除第一元素外，其他元素均存在前驱
5. 逻辑形式为 a0a1a2a3a4.....an

数组：计算机底层表达线性表的一种存储方式，是用一组地址连续的存储单元依次存储线性表的数据组织方式

链表：计算机底层表达线性表的另一种存储方式，是用地址非连续的存储单元存储线性表的数据，数据元素的逻辑顺序由链表中的指针连接次序实现。

特点：

1. 链表由一系列结点组成,结点可以在运动时 动态生成,每个结点包含两个部分,一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。
2. 链表有多种变种，分别为单向链表,双向链表,循环链表,静态链表。 

各结构简单的实现如下：

// Author: Waihui Zheng
// 线性表：有序线性表、无序线性表
// 实现方式：数组，链表
// 链表：单向链表、双向链表、循环链表、静态链表

#include <iostream>

// 建立元素为int类型的数组
void show_array() {
    int int_array[10];
    for (int i = 0; i < 10; ++i) {
        int_array[i] = i;
    }

    std::cout << "数组: ";
    for (int i = 0; i < 10; ++i) {
        std::cout << int_array[i] << " ";
    }

    std::cout << std::endl;
}


// 建立单向链表
struct SinglyLinkedNode {
    int value;
    SinglyLinkedNode* next;

    SinglyLinkedNode(int v = 0) : value(v), next(NULL) {}
};

void show_singly_list() {
    SinglyLinkedNode* head = new SinglyLinkedNode(3);
    SinglyLinkedNode* current = head;

    current->next = new SinglyLinkedNode(1);
    current = current->next;

    current->next = new SinglyLinkedNode(5);
    current = current->next;

    std::cout << "单向链表: ";
    for (current = head; current != NULL; current = current->next) {
        std::cout << current->value << " ";
    }
    std::cout << std::endl;

    current = head;
    while (current != NULL) {
        SinglyLinkedNode* p = current;
        current = current->next;
        delete p;
    }
}

// 建立双向链表
struct DoubleLinkedNode {
    int value;
    DoubleLinkedNode* pre;
    DoubleLinkedNode* next;

    DoubleLinkedNode(int v = 0) : value(v), pre(NULL), next(NULL) {}
};

void show_double_linked_list() {
    DoubleLinkedNode* head = new DoubleLinkedNode(7);
    DoubleLinkedNode* current = head;

    current->next = new DoubleLinkedNode(2);
    current->next->pre = current;
    current = current->next;

    current->next = new DoubleLinkedNode(10);
    current->next->pre = current;
    current = current->next;

    std::cout << "双向链表: ";
    for (; current != NULL; current = current->pre) {
        std::cout << current->value << " ";
    }
    std::cout << std::endl;

    current = head;
    while (current != NULL) {
        DoubleLinkedNode* p = current;
        current = current->next;
        delete p;
    }
}

// 单向循环链表
struct CycleSinglyLinkedNode {
    int value;
    CycleSinglyLinkedNode* next;

    CycleSinglyLinkedNode(int v = 0) : value(v), next(NULL) {}
};

void show_cycle_singly_linked_list() {
    CycleSinglyLinkedNode* head = new CycleSinglyLinkedNode(3);
    CycleSinglyLinkedNode* last = new CycleSinglyLinkedNode(5);
    head->next = last;
    last->next = head;

    last->next = new CycleSinglyLinkedNode(1);
    last = last->next;
    last->next = head;

    std::cout << "单向循环链表: ";
    CycleSinglyLinkedNode* cur = head;
    do {
        std::cout << cur->value << " ";
        cur = cur->next;
    } while (cur != head);
    std::cout << std::endl;

    cur = head;
    do {
        CycleSinglyLinkedNode* p = cur;
        cur = cur->next;
        delete p;
    } while (cur != head);
}

// 静态链表
#define MAXN 100

struct StaticNode {
    int value;
    int next;
};

StaticNode s_static_linked_list[MAXN];

void show_static_linked_list() {
    for (int i = 0; i < MAXN; ++i) {
        s_static_linked_list[i].value = 0;
        s_static_linked_list[i].next = -1;
    }

    s_static_linked_list[0].value = 7;
    s_static_linked_list[0].next = 5;
    s_static_linked_list[5].value = 3;
    s_static_linked_list[5].next = 3;
    s_static_linked_list[3].value = 10;

    std::cout << "静态链表: ";
    for (int i = 0; i != -1; i = s_static_linked_list[i].next) {
        std::cout << s_static_linked_list[i].value << " ";
    }
    std::cout << std::endl;
}

int main() {
    show_array();
    show_singly_list();
    show_double_linked_list();
    show_cycle_singly_linked_list();
    show_static_linked_list();
    return 0;
}