顺序表
#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;
}