数据结构

顺序表

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

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

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

int expend (Vector *vec) {
    int extr_size = vec->size;
    int *p;
    while (extr_size) {
        p = (int *)realloc(vec->data, sizeof(int) * (vec->size + extr_size));
        if (p) break;
        extr_size /= 2;
    }
    if (extr_size == 0) return 0;
    vec->data = p;
    vec->size += extr_size;
    return 1;
}

int insert(Vector *vec, int loc, int val) {
    if (vec == NULL) return 0;
    if (loc < 0 || loc > vec->length) return 0;
    if (vec->length == vec->size) {
        if (!expend(vec)) return 0;
        printf("success to expend ! the Vector size is %d\n", vec->size);
    }
    for (int i = vec->length; i > loc; i--) {
        vec->data[i] = vec->data[i - 1];
    }
    vec->data[loc] = val;
    vec->length += 1;
    return 1;
}

int delete_node(Vector *vec, int loc) {
    if (vec == NULL) return 0;
    if (loc < 0 || loc >= vec->length) return 0;
    for (int i = loc + 1; i < vec->length; i++) {
        vec->data[i - 1] = vec->data[i];
    }
    vec->length -= 1;
    return 1;
}

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

void clear(Vector *vec) {
    free(vec->data);
    free(vec);
    return ;
}
int main () {
    srand(time(0));
    #define max_op 20
    Vector *vec = init(max_op);
    for (int i = 0; i < max_op * 4; i++) {
        int op = rand() % 4;
        int loc = rand() % (vec->length + 3) - 1;
        int val = rand() % 100;
        switch (op) {
            case 0:
            case 1:
            case 2: {
                printf("insert %d at %d to Vector = %d\n", val, loc, insert(vec, loc, val));
            }break;
            case 3: {
                printf("delete a item at %d from Vector = %d\n", loc, delete_node(vec, loc));
            }break;
        }
        output(vec);
        printf("\n");
    }
    clear(vec);
    #undef max_op
    return 0;
}

链表

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

typedef struct List {
    ListNode head;
    int length;
} List;

ListNode *getNewNode(int);
List *getLinkList();
int insert(List *, int, int);
int erase(List *,int);
void reverser(List *);
void output(List *);
void clear_ListNode(ListNode *);
void clear_List(List *);
void outout1(List *, int );
int main(){
    srand(time(0));
    #define max_op 20
    List *l = getLinkList();
    int ind, op, val, flag;

    for (int i = 0; i < max_op; i++) {
        op = rand() % 4;
        ind = rand() % (l->length + 3) - 1;
        val = rand() % 1000;
        switch(op) {
            case 0:
            case 1: {
                flag = insert(l, ind, val);
                printf("insert %d at  %d to List = %d\n", val, ind, flag);
            }break;
            case 2: {
                flag = erase(l, ind);
                printf("erase item at %d is from List = %d\n", ind, flag);
            }break;
            case 3: {
                printf("reverse the List !\n");
                reverser(l);
                flag = -1;
            }break;
        }
        output(l);
        outout1(l, flag);
        printf("\n");
    }
    clear_List(l);
    #undef max_op
    return 0;
}

ListNode *getNewNode(int val) {
    ListNode *p = (ListNode *) malloc (sizeof(ListNode));
    p->data = val;
    p->next = NULL;
    return p;
}

List *getLinkList(){
    List *l =  (List *)malloc(sizeof(List));
    l->head.next = NULL;
    l->length = 0;
    return l;
}

int insert(List *l, int ind, int val) {
    int ret = ind;
    if (l == NULL) return -1;
    if (ind < 0 || ind > l->length) return -1;
    ListNode *p = &(l->head), *node = getNewNode(val);
    while (ind--) p = p->next;
    node->next = p->next;
    p->next = node;
    l->length += 1;
    return ret;
}

int erase(List *l, int ind) {
    int ret = ind;
    if (l == NULL) return -1;
    if (ind < 0 || ind >= l->length) return -1;
    ListNode *p = &(l->head), *q;
    while (ind--) p = p->next;
    q = p->next;
    p->next = q->next;
    free(q);
    l->length -= 1;
    return ret;
}

void output(List *l){
    printf("head->");
    ListNode *p = l->head.next;
    while(p) {
        printf("%d->", p->data);
        p = p->next;
    }
    /*for (ListNode *p = l->head.next; p; p = p->next) {
        printf("%d->", p->data);
    }*/
    printf("NULL\n");
    return ;
}
void outout1(List *l, int ind) {
    char str[100];
    int offset = 3;
    ListNode *p = l->head.next;
    while (ind != -1 && p) {
        offset += sprintf(str, "%d->", p->data);
        ind -= 1;
        p = p->next;
    }
    for (int i = 0; i < offset; i++) printf(" ");
    printf("^\n");
    for (int i = 0; i < offset; i++) printf(" ");
    printf("|\n\n");
    return ;

}
//翻转
void reverser(List *l) {
    ListNode *p = l->head.next, *q;
    l->head.next = NULL;
    while (p) {
        q = p->next;
        p->next = l->head.next;
        l->head.next = p;
        p = q;
    }
    return ;
}

void clear_ListNode(ListNode *node) {
    if(node == NULL) return ;
    free(node);
    return ;
}

void clear_List(List *l) {
    if (l == NULL) return ;
    ListNode *p = l->head.next, *q;
    while (p) {
        q = p->next;
        clear_ListNode(p);
        p = q;
    }
    free(l);
    return ;
}

队列

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct Queue {
    int *data;
    int size, head, tail, cnt;
} Queue;

Queue *init(int);
int front(Queue *);
int empty(Queue *);
int push(Queue *, int);
int pop(Queue *);
void output(Queue *);
void clear(Queue *);

int main () {
    srand(time(0));
    #define max_op 20
    Queue *q = init(10);
    for (int i = 0; i < max_op; i++) {
        int val = rand() % 100;
        int op = rand() % 4;
        switch (op) {
            case 0 :
            case 1 :
            case 2 : {
                printf("push %d to the Queue = %d\n", val, push(q, val));
            } break;
            case 3 : {
                int f = front (q);
                printf("pop %d from the Queue = %d\n", f, pop(q));
            } break;
        }
        output(q);
    }
    #undef max_op
    clear(q);
    return 0;
}

Queue *init(int n) {
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * n);
    q->size = n;
    q->head= q->tail = q->cnt = 0;//q->tail 下一个指针空白处
    return q;
}

int front(Queue *q) {
    return q->data[q->head];
}

int empty(Queue *q) {
    return q->cnt == 0; 
}

int expend (Queue *q) {
    int extr_size = q->size;
    int *p;
    while (extr_size) {
        p = (int *)malloc (sizeof(int) * (q->size + extr_size));
        if (p) break;
        extr_size >>= 1;
    }
    if (p == NULL) return 0;
    int i = q->head;
    for (int j = 0; j < q->cnt; j++) {
        p[j] = q->data[(i + j) % q->size];
    }
    free(q->data);
    q->data = p;
    q->size += extr_size;
    q->head = 0;
    q->tail = q->cnt;
    return 1;
}


int push (Queue *q, int val) {
    if (q == NULL) return 0;
    if (q->cnt == q->size) {
        if (!expend(q)) return 0;
        printf("\033[32mexpend successful !\033[0m"" size = %d\n", q->size);
        
    }
    q->data[q->tail++] = val;
    if (q->tail == q->size) q->tail -= q->size;
    q->cnt += 1;
    return 1;
}

int pop(Queue *q) {
    if (q == NULL) return 0;
    if (empty(q)) return 0;
    q->head ++;
    if (q->head == q->size) q->head -= q->size;
    q->cnt -= 1;
    return 1;
}

void output (Queue *q) {
    printf("Queue : [");
    for (int i = q->head, j = 0; j < q->cnt; j++) {
        j && printf(", ");
        printf("%d", q->data[(i + j) % q->size]);
    }
    printf("]\n\n");
    return ;
}

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

栈

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef struct stack {
    int *data;
    int size, top;
} Stack;

Stack *init(int);
void clear(Stack *);
int top(Stack *);
int empty(Stack *);
int push(Stack *, int);
int pop(Stack *);
void output(Stack *);

int main() {
    #define max_op 20
    srand(time(0));
    Stack *s = init(10);
    for (int i = 0; i < max_op; i++) {
        int val = rand() % 100;
        int op = rand() % 4;
        switch(op){
            case 0 :
            case 1 :
            case 2 : {
                printf("push %d to the stack is = %d\n", val, push(s, val));
            } break;
            case 3 : {
                int t = top(s);
                printf("pop %d from the Stack is = %d\n", t, pop(s));
            } break;
            
        }
        output(s);
    }
    #undef max_op
    clear(s);
    return 0;
}

Stack *init(int n) {
    Stack *s = (Stack *)malloc (sizeof(Stack));
    s->data = (int *)malloc(sizeof(int) * n);
    s->size = n;
    s->top = -1;
    return s;
}

int top(Stack *s) {
    return s->data[s->top];
}

int empty(Stack *s) {
    return s->top == -1;
}

int expend (Stack *s) {
    int extr_size = s->size;
    int *p;
    while(extr_size) {
        p = (int *)realloc(s->data,sizeof(int) * (s->size + extr_size));
        if (p) break;
        extr_size >>= 1; 
    }
    if (p == NULL) return 0;
    s->size += extr_size;
    s->data = p;
    return 1;
}

int push(Stack *s, int val) {
    if (s == NULL) return 0;
    if (s->top + 1 == s->size) {
        expend(s);
        printf("\033[31mexpend Stack is success!, Stack's size is = %d\n\n\033[0m", s->size);
    }
    s->data[++(s->top)] = val;
    return 1;
}

int pop(Stack *s) {
    if (s == NULL) return 0;
    if (empty(s)) return 0;
    s->top -= 1;
    return 1;
}

void output (Stack *s) {
    printf("Stack(%d) = [", s->top + 1);
    for (int i = 0; i <= s->top; i++) {
        i && printf(", ");
        printf("%d", s->data[i]);
    }
    printf("];\n\n");
}

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

优先队列

/*************************************************************************
	> File Name: 10.priority_queue.cpp
	> Author: 
	> Mail: 
	> Created Time: Sat Jul  4 15:24:21 2020
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include<time.h>
#define swap(a, b) {\
    __typeof(a) __temp = (a);\
    (a) = (b), (b) = __temp;\
}

typedef struct priority_queue {
    int *data;
    int cnt, size;
} priority_queue;

priority_queue *init(int n) {
    priority_queue *q = (priority_queue *)malloc(sizeof(priority_queue));
    q->data = (int *)malloc(sizeof(int) * (n  + 1));
    q->cnt = 0;
    q->size = n;
    return q;
}

int empty(priority_queue *q) {
    return q->cnt == 0;
}

int top(priority_queue *q) {
    return q->data[1];
}

int push(priority_queue *q, int val) {
    if (q == NULL) return 0;
    if (q->cnt >= q->size) return 0;
    q->data[++(q->cnt)] = val;
    int ind = q->cnt;
    while (ind >> 1 && q->data[ind] > q->data[ind >> 1]) {
        swap(q->data[ind], q->data[ind >> 1]);
        ind >>= 1;
    }
    return 1;
}

void update(priority_queue *q, int ind) {
    while ((ind << 1) <= q->cnt) {
        int max = ind, l = ind << 1, r = ind << 1 | 1;
        if (l <= q->cnt && q->data[l] > q->data[max]) max = l;
        if (r <= q->cnt && q->data[r] > q->data[max]) max = r;
        if (max == ind) break;
        swap(q->data[ind], q->data[max]);
        ind = max;
    }
    return ;
}

int pop(priority_queue *q) {
    if (q == NULL) return 0;
    if (empty(q)) return 0;
    q->data[1] = q->data[q->cnt--];
    update(q, 1);
    return 1;
}

void output(priority_queue *q) {
    for (int i = 1; i <= q->cnt; i++) {
        i - 1 && printf(" ");
        printf("%d", q->data[i]);
    }
    printf("\n");
}

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

int main () {
    srand (time(0));
    #define max_op 20
    priority_queue *q = init(max_op);
    for (int i = 0; i < max_op; i++) {
        int val = rand() % 100;
        push(q, val);
        printf("insert %d to priority_queue\n", val);
    }
    output(q);
    for (int i = 0; i < max_op; i++) {
        printf("%d ", top(q));
        pop(q);
    }
    printf("\n");
    clear(q);
    return 0;
}

堆排序

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define swap(a, b) {\
    __typeof(a) __temp = (a);\
    (a) = (b), (b) = __temp;\
}

void downUpdata(int *arr, int ind, int n) {
    while ((ind << 1) <= n) {
        int temp = ind, l = ind << 1, r = ind << 1 | 1;
        if (l <= n && arr[l] > arr[temp]) temp = l;
        if (r <= n && arr[r] > arr[temp]) temp = r;
        if (temp == ind) break;
        swap(arr[temp], arr[ind]);
        ind = temp;
    }
    return ;
}

void output(int *arr, int n) {
    printf("arr(%d) = [", n);
    for (int i = 0; i < n; i++) {
        printf(" %d", arr[i]);
    }
    printf("]\n");
    return ;
}
void heap_sort(int *arr, int n) {
    arr -= 1;
    for (int i = n >> 1; i >= 1; i--) {
        downUpdata(arr, i, n); 
    }
    for (int i = n; i > 1; i--) {
        swap(arr[i], arr[1]);
        downUpdata(arr, 1, i - 1);
    }
    return ;
}

int main () {
    srand(time(0));
    #define max_op 20
    int *arr = (int *)malloc(sizeof(int) * max_op);
    for (int i = 0; i < max_op; i++) {
        arr[i] = rand() % 100;
    }
    output(arr, max_op);
    heap_sort(arr, max_op);
    output(arr, max_op);
    free(arr);
    return 0;
}