線性表：

• 順序表（Vector）
• 連結串列（LinkList）

時間複雜度比較：

• 順序表：
  1. 適合隨機訪問 O(1)。
  2. 插入、刪除節點 O(N)。
• 連結串列：
  1. 不適合隨機訪問 O(N)。
  2. 插入、刪除節點 O(1)。

連結串列：

1. 單向連結串列
2. 雙向連結串列
3. 迴圈連結串列

迴圈連結串列：

1. 插入刪除過程要注意，初始指標應指向連結串列尾節點（若當插入到頭前時，找不到前驅節點）
2. 當在更新尾節點時需要更新頭指標
3. 連結串列排序使用氣泡排序最為適合

資料結構 = 結構定義 + 結構操作

演示程式碼：

 線性表

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define malloc2 my_malloc(size, __FILE__, __func__, __LINE__) 

void* my_malloc(int size, const char* file, const char* func, int line) {
    void *data = malloc(size);
    if (data == NULL) {
        fprintf(stderr,"[%s : %s : %s] malloc error\n", file, func, line);
        fflush(stderr);
        abort();
    }
    return data;
}

typedef struct Vector { 
    int *data;
    int size, length;
    
}Vector;

Vector* init(int n) {
    Vector *p = (Vector*)malloc(sizeof(Vector));
    p->data = (int*)malloc(sizeof(int) * n);
    p->size = n;
    p->length = 0;
    return p;
}

int expand(Vector* v){
    int new_size = v->size;
    while (new_size){
        int *data = (int *)realloc(v->data, sizeof(int) * (v->size + new_size));
        if (data == NULL) {
            new_size /= 2;
            continue;
        }
        break;
    }
    printf("%d\n");
    return 1;
}
int insert(Vector* v, int x, int ind) {
    if (v->length >= v->size) {
        if (!expand(v)) {
            return 0;
        }
        return 0;
    }
    if (ind < 0 || ind > v->length) {
        return 0;
    }
    for (int i = v->length - 1; i >= ind ; --i) {
        v->data[i + 1] = v->data[i];
    }
    v->data[ind] = x;
    v->length += 1;
    return 1;
}

int delete_element(Vector *v, int ind){
    if (ind >= v->length || ind < 0) {
        return 0;
    }
    for (int i = ind + 1; i < v->length; ++i) {
        v->data[i - 1] = v->data[i];
    }
    v->length -= 1;
    return 1;
}

void output(Vector* v) {
    printf("[ ");
    for (int i = 0; i < v->length; ++i) {
        printf(" %d", v->data[i]);
    }
    printf(" ]");
    printf("\n");
}

void clear(Vector* v) {
    if (v == NULL) return;
    free(v->data);
    free(v);
    return;
}

int main() {
    srand(time(0));
    Vector *v = NULL;
    v = init(100);
    for (int i = 0; i < 10; ++i) {
        int x = rand() % 100, ind = rand() % (i + 1);
        printf("insert(%d, %d)", x, ind);
        insert(v, x, ind);
        output(v);
    }
    printf("\n");
    for (int i = 0; i < 10; ++i) {
        int ind = rand() % (v->length + 2) - 1;
        printf("delete_element(%d) = ", ind);
        int ret = delete_element(v, ind);
        printf("%d : ", ret);
        output(v);
    }
    return 0;
}
 

 連結串列

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct LinkNode {
    int data;
    struct LinkNode *next;
} LinkNode;

typedef struct LinkList {
    LinkNode *head;
    int n;
} LinkList;

LinkList* init() {
    LinkList *p = (LinkList*)malloc(sizeof(LinkList));
    p->head = NULL;
    p->n = 0;
    return p;
} 


LinkNode* getNewNode(int data) {
    LinkNode* p = (LinkNode*)malloc(sizeof(LinkNode));
    p->data = data;
    p->next = NULL;
    return p;
}
void clear(LinkList* l) {
    LinkNode* head = l->head;
    while (head) {
        LinkNode *next = head->next;
        free(head);
        head = next;
    }
    free(l);
    return;
}
int insert(LinkList* l, int data, int ind) {
    if (ind < 0) return 0;
    LinkNode ret, *p;
    ret.next = l->head;
    p = &ret;
    while (p && ind--) {
        p = p->next;
    }
    if (p == NULL) return 0;
    LinkNode* new_node = getNewNode(data);
    new_node->next = p->next;
    p->next = new_node;
    l->head = ret.next;
    l->n += 1;
    return 1;
}
void output(LinkList* l) {
    LinkNode* head = l->head;
    while (head) {
        printf("%d ->", head->data);
        head = head->next;
    }
    printf("null\n");
}
int main(){
    LinkList* l = init();
    srand(time(0));
    for (int i = 0; i < 10; ++i) {
        int data = rand() % 100, ind = rand() % (i + 1);
        printf("%d : insert(%d, %d) = ", i, data, ind);
        fflush(stdout);
        insert(l, data, ind);
        output(l);
    }
    clear(l);
    return 0;
}