顺序表与链表

顺序表

主要代码：

typedef struct vector {
    int *data;
    int size,length;
} Vec;

Vec *init(int n) {
    Vec *v = (Vec *)malloc(sizeof(Vec));
    v->data = (int *)malloc(sizeof(int) * n);
    v->size = n;
    v->length = 0;
    return v;
}
int expand(Vec *v) {
    //顺序表扩容
    int extr_size = v->size;
    int *p;
    while(extr_size) {
        p = (int *)realloc(v->data, sizeof(v->size + extr_size));
        if (p != NULL) break;
        extr_size >>= 1;
    }
    if (p == NULL) return 0;
    v->size += extr_size;
    v->data = p;
    return 1;
}
int insert(Vec *v, int ind, int val) {
    
    if (v == NULL) return 0;
    if (ind < 0 || ind > v->length) return 0;
    if (v->length == v->size) {
        if (!expand(v)) {
            printf (RED("fail to expand\n"));
        } else {
            printf(GREEN("success expand, size = %d\n"), v->size);
        }
    } 
    for (int i = v->length; i > ind; i--) {
        v->data[i] = v->data[i - 1];
    }
    v->data[ind] = val;
    v->length += 1;

    return 1;
}

int erase(Vec *v, int ind) {
    if (v == NULL) return 0;
    if (ind < 0 || ind > v->length) 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(Vec *v) {
    if (v == NULL) return ;
    printf ("[");
    for (int i = 0; i < v->length; i++) {
        i && printf(",");
        printf("%d", v->data[i]);
    }
    printf("]\n");
    printf("\n");
    return ;
}
void clear(Vec *v) {
    if (v == NULL) return ;
    free(v->data);
    free(v);
    return ;
}

链表

主要代码：

typedef struct Node {
    int data;
    struct Node *next; //后继，下一个节点的地址
} Node;

typedef struct List {
    Node head;//虚拟头节点
    int length; // 节点个数    
} List;
Node *getNewNode(int);
List *init_list();
int insert(List *, int, int);
int erase(List *, int);
void output(List *);
void clear_node(Node *);
void clear_l(List *);

//初始化，分别创建节点，链表头部
Node *getNewNode(int val) {
    Node *node = (Node *)malloc(sizeof(Node));
    node->data = val;
    node->next = NULL;
    return node;
}
List *init_list() {
    List *l = (List *)malloc(sizeof(List));
    l->head.next = NULL;
    l->length = 0;
    return l;
}

int insert(List *l, int ind, int val) {
    if (l == NULL) return 0;
    if (ind < 0 || ind > l->length) return 0;
    Node *p = &(l->head), *node = getNewNode(val);
    while(ind--) {
        p = p->next; // 遍历到ind - 1指向的地址，找到后退出；
    }
    node->next = p->next; // 新节点指向ind-1所指向的地址；
    p->next = node;  // ind-1在指向新节点的地址；
    l->length += 1;
    return 1;
}

void clear_node(Node *node) {
    if (node == NULL) return ;
    free(node);
    return ;
}

int erase(List *l, int ind) {
    if (l == NULL) return 0;
    if (ind < 0 || ind > l->length) return 0;
    Node *p = &(l->head), *q;
    while(ind--) {
        p = p->next; //遍历至ind - 1指向的地址
    }
    q = p->next; // 用q存储ind的地址；
    p->next = q->next; //将ind - 1节点个与 ind 所指向的地址相连
    clear_node(q);
    l->length -= 1;
    return 1;

}

void clear_l(List *l) {
    if (l == NULL) return ;
    Node *p = l->head.next, *q;
    while(p !=  NULL) {
        q = p->next;
        clear_node(p);
        p = q;
    }
    free(l);
    return ;

}

void output(List *l) {
    if (l == NULL) return ;
    printf("list = %d\n", l->length);
    for (Node *p = l->head.next; p != NULL; p = p->next) {
        printf("%d->", p->data);
    }
    printf("NULL\n");
    return ;
}

链表原地翻转

代码：

void reverse(List *l) {
    if (l == NULL) return ;
    Node *p = l->head.next, *q;
    l->head.next = NULL; //将虚拟节点后的第一个节点置空
    while(p != NULL) {
        q = p->next;
        p->next = l->head.next;
        l->head.next = p;
        p = q;
    }
    
    return ;
}