建设教育网站怎么样千库网会员

线性表：n个数据元素的有限序列（数据元素是同一个类型

链表：优点：内存动态化

栈：先进后出原则(类似弹夹)

队列：先进先出

二叉树：子树：树枝  节点：树叶  节点的度：叶子数目

哈夫曼树： 带权路径长度最短（带权路径长度：树中所有的叶结点的权值乘上其到根结点的路径长度

dfs/bfs

数据结构代码(self)

#include<stdio.h>
#include<stdlib.h>//双向链表
typedef int elemtype;//链表存储结构
typedef struct Node{int data;struct node* next;struct node*prev;
}node;
node* init(){//初始化node* head = (node*)malloc(sizeof(node));head->data = 0;head->prev = NULL;head->next = NULL;return head;
}
int inserthead(node* L, elemtype e) {//头插法node* p = (node*)malloc(sizeof(node));p->data = e;p->prev = L;p->next = L->next;if (L->next != NULL) {L->next->prev = p;L->next = p;return 1;}
}
node* gettail(node* L) {//获取尾结点node* p = L;while (p->next != NULL) {p = p->next;}return p;
}
node* inserttail(node* tail, elemtype e) {//尾插法node* p = (node*)malloc(sizeof(node));p->data = e;p->prev = tail;tail->next = p;p->next = NULL;return p;
}
int insertnode(node* L, int pos, elemtype e) {//指定位置插入node* p = L;int i = 0;while (i < pos - 1) {p = p->next;i++;if (p = NULL) {return 0;}}
}
int delectnode(node* L, int pos) {//删除指定位置节点node* p = L;int i = 0;while (i < pos - 1) {p->next;i++;if (p = NULL) {return 0;}}if (p->next = NULL) {printf("位置错误");return 0;}node* q = p->next;p->next = q->next;free(q);return 1;
}
void listnode(node* L) {//遍历node* p = L->next;while (p != NULL) {printf("%d", p->data);p = p->next;}printf("\n");
}
int listlength(node* L) {//获取链表长度node* p = L;int len = 0;while (p != NULL) {p = p->next;len++;}return len;
}
void freelist(node* L) {//释放链表node* p = L->next;node* q;while (p != NULL) {q = p->next;free(p);p = q;}L->next = NULL;
}//栈
//栈的顺序结构实现
#define max 100//初始化
typedef int elemtype;
typedef struct {elemtype data[max];int top;
}stack;
void initlist(stack* s) {s->top = -1;
}
int isempty(stack* s) {//判断栈是否为空if (s->top = -1) {printf("空");return 1;}else {return 0;}
}
int pop(stack* s, elemtype *e) {//出栈if (s->top = -1) {printf("空\n");return 0;}*e = s->data[s->top];s->top--;return 1;
}
int push(stack* s, elemtype e) {//进栈if (s->top >= max - 1) {printf("满了\n");return 0;}s->top++;s->data[s->top] = e;return 1;
}
//栈的链式结构实现
typedef int elemtype;//初始化
typedef struct Stack {elemtype data;struct stack* next;
}stack;
stack* init() {stack* s = (stack*)malloc(sizeof(stack));s->data = 0;s->next = NULL;return s;
}
int push(stack* s, elemtype e) {//进栈stack* p = (stack*)malloc(sizeof(stack));p->data = e;p->next = s->next;s->next = p;return 1;
}
int pop(stack* s, elemtype* e) {//出栈if (s->next = NULL) {printf("空\n");return 0;}*e = s->next->data;stack* q = s->next;s->next = q->next;free(q);return 1;
}
int gettop(stack* s, elemtype* e) {//获取栈顶元素if (s->next = NULL) {printf("空\n");return 0;}*e = s->next->data;return 1;
}//队列
#define max 100
typedef int elemtype;
typedef struct {//顺序结构—初始化elemtype data[max];int front;int rear;
}queue;
void initqueue(queue* q) {q->front = 0;q->rear = 0;
}
int isempty(queue* q) {//判断队列是否为空if (q->front = q->rear) {printf("空\n");return 1;}else {return 0;}
}
elemtype dequeue(queue* q) {//出队if (q->front == q->rear) {printf("空\n");return 0;}elemtype e = q->data[q->front];q->front++;return e;
}
int equeue(queue* q, elemtype e) {//入队if (q->rear >= max) {if (!queuefull(0)) {return 0;}}q->data[q->rear] = e;q->rear++;return 1;
}
int queuefull(queue* q) {//队列满了，调整队列if (q->front > 0) {int step = q->front;for (int i = q->front;i <= q->rear;++i) {q->data[i - step] = q->data[i];}q->front = 0;q->rear = q->rear - step;return 1;}else {printf("已满\n");return 0;}
}
int gethead(queue* q, elemtype* e) {//获取队头数据if (q->front == q->rear) {printf("空\n");return 0;}*e = q->data[q->front];return 1;
}
typedef struct {//动态内存分配elemtype* data;int front;int rear;
}queue;
queue* initqueue() {queue* q = (queue*)malloc(sizeof(queue));q->data = (elemtype*)malloc(sizeof(int) * max);q->front = 0;q->rear= 0;return q;
}
//循环队列
int equeue(queue* q, elemtype e) {//入队if ((q->rear + 1) % max = q->front) {printf("满\n");return 0;}q->data[q->rear] = e;q->rear = (q->rear + 1) % max;return 1;
}
int dequeue(queue* q, elemtype* e) {//出队if (q->front = q->rear) {printf("空\n");return 0;}*e = q->data(q->front);q->front = (q->front + 1) % max;return 1;
}
//链式结构
typedef struct queuenode {elemtype data;struct queuenode* next;
}queuenode;
typedef struct {queuenode* front;queuenode* rear;
}queue;
queue* initqueue() {//初始化queue* q = (queue*)malloc(sizeof(queue));queuenode* node = (queuenode*)malloc(sizeof(queuenode));node->data = 0;node->next = NULL;q->front = node;q->rear = node;return q;
}
int isempty(queue* q) {//判断队列是否为空if (q->front = q->rear) {printf("空\n");return 1;}else {return 0;}
}
void equeue(queue* q, elemtype e) {//入队尾插法queuenode* node = (queuenode*)malloc(sizeof(queuenode));node->data = e;node->next = NULL;q->rear->next = node;q->rear = node;
}
int dequeue(queue* q, elemtype* e) {//出队queuenode* node = q->front->next;*e = node->data;q->front->next = node->next;if (q->rear = node) {q->rear = q->front;}free(node);return 1;
}//递归
int fun(int n) {//计算1—n的和if (n == 1) {return 1;}else {return fun(n - 1) + n;}
}//二叉树
typedef char elemtype;//便于快速改变数据类型
typedef struct Treenode {//存储结构——链式结构elemtype data;Treenode * lchild;Treenode * rchild;
}treenode;
typedef treenode* bitree;
void preorder(bitree t) {//前序遍历if (t = NULL) {return;}printf("%c", t->data);preorder(t->lchild);preorder(t->rchild);
}
void inorder(bitree t) {//中序遍历if (t = NULL) {return;}inorder(t->lchild);printf("%c", t->data);inorder(t->rchild);
}
void postorder(bitree t) {//后序遍历if (t = NULL) {return;}postorder(t->lchild);postorder(t->rchild);printf("%c", t->data);
}
void iterpreorder(stack* s, bitree t) {//非递归前序遍历while (t != NULL || isempty(s) != 0) {while (t != NULL) {printf("%c", t->data);push(s, t);t = t->lchild;}pop(s, &t);t = t->rchild;}
}
//线索二叉树
typedef char elemtype;
typedef struct threadnode {//存储结构char data;struct threadnode* lchild;struct threadnode* rchild;int ltag;int rtag;
}threadnode;
typedef threadnode* threadtree;
void threading(threadtree t) {//具体线索化if (t != NULL) {threading(t->lchild);if (t->lchild = NULL) {t->ltag = 1;t->lchild = prev;}if (prev->rchild = NULL) {prev->rtag = 1;prev->rchild = t;}prev = t;threading(t->rchild);}
}
void inorder(threadtree t) {//使用线索进行遍历threadtree curr;curr = t->lchild;while (curr != t) {while (curr->ltag = 0) {curr = curr->lchild;}printf("%c", curr->data);while (curr->rtag = 1 && curr->rchild != t) {curr = curr->rchild;printf("%c", curr->data);}curr = curr->rchild;}printf("\n");
}//哈夫曼树
void huffmancoding(huffmantree ht, huffmancode* hc, int n) {*hc = (huffmancode)malloc((n + 1) * sizeof(char*));char* cd = (char*)malloc(n * sizeof(char));cd[n - 1] = '\0';for (int i = 0;i < n;i++) {int start = n - 1;int c = i;int j = ht[i].parent;while (j != 0) {if (ht[j].left == c)cd[--start] = '0';elsecd[--start] = '1';c = j;j = ht[j].parent;}(*hc)[i] = (char*)malloc((n - start) * sizeof(char));strcpy((*hc)[i], &cd[start]);}free(cd);
}//二分查找——递归
int recursion_binarysearch(int* a, const int& x, int left, int right) {int middle = (left + right) / 2;if (x = a[middle]) {return middle;}if (left = right) {return 0;}else if (x > a[middle]) {return recursion_binarysearch(a, x, middle + 1, right);}else if (x < a[middle]) {return recursion_binarysearch(a, x, left, middle - 1);}return 0;
}//图
#define max 100
typedef struct {//邻接矩阵char vex[max];int edge[max][max];int vexnum, arcnum;
}mgraph;
#define max 100//带权图/网
#define infintity
typedef char vertextype;
typedef int edgetype;
typedef struct {char vex[max];int edge[max][max];int vexnum, arcnum;
}mgraph;