数据结构示例代码

以后代码一定要写注释!!!

动态内存分配

#include <stdio.h>
#include <stdlib.h>void assignment(int **a, int n, int x) {int i, j;for (i = 0; i < n; i++) {for (j = 0; j < n; j++) {a[i][j] = 1;}}
}
void print(int **a, int n) {int i, j;for (i = 0; i < n; i++) {for (j = 0; j < n; j++) {printf("%d ", a[i][j]);}printf("\n");}
}int main() {int n;scanf("%d", &n);int **a = (int **)malloc(n * sizeof(int *));int i;for (i = 0; i < n; i++) {a[i] = (int *)malloc(n * sizeof(int));}assignment(a, n, 1);print(a, n);return 0;
}

链表

#include "Node.c"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>/*Node.c*/// typedef struct Node{
//	int data;
//	struct Node* next;
// } Node;
//
// typedef struct List{
//	Node* head;
//	Node* tail;
// } List;/*添加node至链表*/void list_add(int number, List *pList) {Node *p = (Node *)malloc(sizeof(Node));p->data = number;p->next = NULL;if (pList->head == NULL) {pList->head = p;pList->tail = p;} else {pList->tail->next = p;pList->tail = p;}
}/*链表排序*/void list_sort(List *pList) {if (pList->head == NULL || pList->head->next == NULL) {return;}bool swapped;do {Node *p = pList->head;swapped = false;while (p->next != NULL) {if (p->data > p->next->data) {int type = p->data;p->data = p->next->data;p->next->data = type;swapped = true;}p = p->next;}} while (swapped);
}int main(int argc, char const *argv[]) {/*创建链表*/List List;List.head = NULL;List.tail = NULL;/*输入内容*/int number;do {scanf("%d", &number);if (number != -1) {list_add(number, &List);}} while (number != -1);list_sort(&List);/*输出排序好的链表内容*/Node *p = List.head;for (p = List.head; p; p = p->next) {printf("%d\n", p->data);}return 0;
}

队列

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>#define MAXSIZE 100typedef struct Queue {int data[MAXSIZE];int front;int rear;
} Queue;Queue QueueCreate() {Queue queue;queue.front = 0;queue.rear = 0;return queue;
}bool enqueue(Queue *queue, int input) {if ((queue->rear + 1) % MAXSIZE == queue->front) {return false; // 队列已满;}queue->data[queue->rear] = input;queue->rear = (queue->rear + 1) % MAXSIZE;return true;
}bool dequeue(Queue *queue, int *output) {if (queue->front == queue->rear) {return false; // 队列已空;}*output = queue->data[queue->front];queue->front = (queue->front + 1) % MAXSIZE;return true;
}int main(int argc, const char *argv[]) {Queue queue = QueueCreate();enqueue(&queue, 1);enqueue(&queue, 2);enqueue(&queue, 3);enqueue(&queue, 4);enqueue(&queue, 5);enqueue(&queue, 6);enqueue(&queue, 7);enqueue(&queue, 8);enqueue(&queue, 9);enqueue(&queue, 10);int output;dequeue(&queue, &output);printf("%d\n", output);return 0;
}

栈

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>#define MAXSIZE 100typedef struct Stack{int top;int data[MAXSIZE];
}Stack;Stack stackCreate()
{Stack stack;stack.top = -1;return stack;
}void Push(Stack* stack, int input)
{if(stack->top == MAXSIZE - 1){printf("栈已满\n");return;}stack->top++;stack->data[stack->top] = input;printf("入栈成功\n");return;
}void Pop(Stack* Stack, int* output)
{if(Stack->top == -1){printf("栈已空\n");return;}*output = Stack->data[Stack->top];Stack->top--;printf("出栈成功\n");return;
}int main(int argc, const char* argv[])
{Stack stack = stackCreate();int a = 10;int b;Push(&stack, a);Pop(&stack, &b);printf("b = %d", b);
}

链栈

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>typedef struct StackNode{int data;struct StackNode* next;
}StackNode, StackTop;typedef struct StackLink{StackTop* top;unsigned long long size;
}StackLink;StackLink StackLinkCurate()
{StackLink stackLink;stackLink.top = NULL;stackLink.size = 0;return stackLink;
}StackNode* StackNodeCurate()
{StackNode* stackNode = (StackNode*)malloc(sizeof(StackNode));stackNode->next = NULL;return stackNode;
}bool Push(StackLink* stackLink, int input)
{StackNode* stackNode = StackNodeCurate();stackNode->data = input;stackNode->next = stackLink->top;stackLink->top = stackNode;stackLink->size++;return true;
}bool Pop(StackLink* stackLink, int* output)
{StackNode* curNode = stackLink->top;if(curNode == NULL){printf("栈空\n");return false;}*output = curNode->data;free(curNode);stackLink->top = stackLink->top->next;stackLink->size--;return true;
}int main(int argc, const char* argv[])
{StackLink stackLink = StackLinkCurate();int a = 10;int b;Push(&stackLink, a);if(Pop(&stackLink, &b)){printf("%d\n", b);printf("%llu\n", stackLink.size);}//	if(Push(&stackLink, a)){
//		printf("Push successed\n");
//		printf("%d\n", stackLink.top->data);
//		printf("%llu\n", stackLink.size);
//	}else{
//		printf("Push failed\n");
//	}return 0;
}

串

暴力匹配

#include<stdio.h>
#include<stdlib.h>
#include<string.h>/*T为非空串. 若主串S中包括第pos个字符之后存在与T相等的子串,
则返回第一个子串在S中的位置, 否则返回0*/char* Substring(char*S, int i, int tLens)
{char* sub = (char*)malloc(sizeof(char*)*(tLens + 1));if(!sub){return NULL;}int cut = i;int j = 0;for(i; i < cut + tLens; i++){sub[j] = S[i];j++;}sub[tLens] = '\0';return sub;
}int Index(char* T, char* S, int pos)
{if(pos > 0){unsigned long long tLens = strlen(T);unsigned long long sLens = strlen(S);int i = pos;while(i <= (sLens - tLens + 1)){char* sub;sub = Substring(S, i - 1, tLens);if(strcmp(sub, T) == 0){free(sub);return i;}else{i++;}}}return 0;
}int main(int argc, const char* argv[])
{char* T = "12345678";char* S = "12344412345678";printf("%d\n", Index(T, S, 1));return 0;
}

KMP算法

#include <stdio.h>
#include <string.h>void getNext(char *T, int next[]) {int i, j;i = 0;j = -1;next[0] = -1;int tLen = strlen(T);while (i < tLen) {if (j == -1 || T[j] == T[i]) {j++;i++;next[i] = j;} else {j = next[j];}}
}void getNextval(char *T, int nextval[]) {int i, j;i = 0;j = -1;nextval[0] = -1;int tLen = strlen(T);while (i < tLen) {if (j == -1 || T[j] == T[i]) {j++;i++;if (T[i] != T[j]) {nextval[i] = j;} else {nextval[i] = nextval[j];}} else {j = nextval[j];}}
}int Index_KMP(char *S, char *T, int pos) {int sLen = strlen(S);int tLen = strlen(T);int next[256];getNext(T, next);//	int nextval[256];//	getNextval(T, nextval);int i = pos;int j = 0;while (i < sLen && j < tLen) {if (j == -1 || T[j] == S[i]) {i++;j++;} else {j = next[j];}}if (j > tLen - 1) {return i - tLen + 1; // 若从0开始计数, 去掉"+1";} else {return -1;}
}int main(int argc, const char *argv) {char *T = "五五";char *S = "123456123五五4311";int test = Index_KMP(S, T, 0);printf("%d\n", test);//	int next[256];////	getNext(T, next);////	int tLen = strlen(T);//	for(int i = 0; i < tLen; i++){//		printf("%d ", next[i]);//	}return 0;
}

树

普通的二叉树

#include<stdio.h>
#include<stdlib.h>/*定义二叉树节点*/typedef struct BiTNode
{char data;struct BiTNode* LChild;struct BiTNode* RChild;
}BiTNode, BiTree;/*先序建立二叉树*/void BiTreeCreate(BiTree** biTree)
{char ch;scanf("%c", &ch);if(ch == '#'){*biTree = NULL;}else{*biTree = (BiTree*)malloc(sizeof(BiTree));if(!*biTree){
//			exit(EOVERFLOW);printf("ERROR");}(*biTree)->data = ch;BiTreeCreate(&((*biTree)->LChild));BiTreeCreate(&((*biTree)->RChild));}
}/*前(先)序遍历二叉树*/void PreorderTraverse(BiTNode* biTNode)
{if(biTNode == NULL){return;}printf("%c", biTNode->data);PreorderTraverse(biTNode->LChild);PreorderTraverse(biTNode->RChild);
}/*中序遍历二叉树*/void InorderTraverse(BiTNode* biTNode)
{if(biTNode == NULL){return;}InorderTraverse(biTNode->LChild);printf("%c", biTNode->data);InorderTraverse(biTNode->RChild);	
}/*后序遍历二叉树*/void PostorderTraverse(BiTNode* biTNode)
{if(biTNode == NULL){return;}PostorderTraverse(biTNode->LChild);PostorderTraverse(biTNode->RChild);printf("%c", biTNode->data);
}int main(int argc, const char* argv[])
{BiTree* root = NULL;BiTreeCreate(&root); // 使用双重指针版本
//	printf("Preorder:\n");PreorderTraverse(root);printf("\n");
//	printf("Inorder:\n");InorderTraverse(root);printf("\n");
//	printf("Postorder:\n");PostorderTraverse(root);return 0;
}

线索二叉树

#include <stdio.h>
#include <stdlib.h>/*定义线索化二叉树结构*/typedef enum {Link,thread
} PointerTag; // link表示有孩子, thread表示无孩子, 指向前驱或后继typedef struct BiThrNode {char data;struct BiThrNode *LChild;struct BiThrNode *RChild;PointerTag ltag;PointerTag rtag;
} BiThrNode, BiThrTree;/*建立二叉树*/
BiThrTree *BiThrTreeCreate(BiThrTree *biThrTree) {char ch;scanf("%c", ch);if (ch != '#') {biThrTree = NULL;} else {biThrTree = (BiThrTree *)malloc(sizeof(biThrTree));if (!biThrTree) {printf("错误");}biThrTree->data = ch;biThrTree->LChild = BiThrTreeCreate(biThrTree->LChild);biThrTree->RChild = BiThrTreeCreate(biThrTree->RChild);}return biThrTree;
}/*建立头节点*/BiThrNode BiThrNodeHeadCreate() {BiThrNode biThrNodeHead;BiThrNode *biThrTree;biThrNodeHead.ltag = 0;biThrNodeHead.rtag = 1;BiThrNode *LChild = BiThrTreeCreate(biThrTree);return biThrNodeHead;
}/*中序线索化*/BiThrTree *pre;void InThrTree(BiThrTree *p) {if (p != NULL) {InThrTree(p->LChild);if (p->LChild == NULL) {p->ltag = thread;p->LChild = pre;}if (pre->RChild == NULL) {pre->rtag = thread;pre->RChild = p;}pre = p;InThrTree(p->RChild);} else {return;}
}/*遍历线索二叉树*/void InorderTraverse_Thr(BiThrTree *T) {BiThrTree *p;p = T->LChild;while (p != T) {while (p->ltag == Link) {p = p->LChild;}printf("%c", p->data);while (p->rtag == thread && p->RChild != T) {p = p->RChild;printf("%c", p->data);}p = p->RChild;}
}int main(int argc, const char *argv) {BiThrNode biThrNodeHead = BiThrNodeHeadCreate();return 0;
}

图

邻接表

#include<stdio.h>
#include<stdlib.h>#define MAXVEX 100/*规定定点类型为char, 权值类型为int*//*边表节点*/typedef struct EdgeNode{int adjvex;int weight;struct EdgeNode* next;
}EdgeNode;/*节点*/typedef struct VertexNode{char data;EdgeNode* firstEdge;
}VertexNode;/*图*/typedef struct GraphAdjList{VertexNode adjList[MAXVEX];int numVertexes;int numEdges;
}GraphAdjList;/*创建图*/void ALGraphCreate(GraphAdjList* G)
{printf("请输入节点数和边数");scanf("%d %d", &(G->numVertexes), &(G->numEdges));int i, j, k, l;printf("请连续输入每一个节点的数据:");for(i = 0; i < G->numVertexes; i++){scanf("%c", &(G->adjList[i].data));	G->adjList[i].firstEdge = NULL;}for(k = 0; k < G->numEdges; k++){printf("输入边[Vi, Vj]的顶点序号和权值:");scanf("%d,%d %d", &i, &j, &l);EdgeNode* e = (EdgeNode*)malloc(sizeof(EdgeNode));e->adjvex = j;e->weight = l;e->next = G->adjList[i].firstEdge;G->adjList[i].firstEdge = e;EdgeNode* f = (EdgeNode*)malloc(sizeof(EdgeNode));f->adjvex = i;f->weight = l;f->next = G->adjList[j].firstEdge;G->adjList[j].firstEdge = f;}
}int main(int argc, const char* argv[])
{return 0;
}

邻接矩阵

#include<stdio.h>
#include<stdlib.h>/*定点类型为char, 权值类型为char*/#define MAXVEX 100
#define INFINITY 65535typedef struct MGraph{char vexs[MAXVEX];int arc[MAXVEX][MAXVEX];int numVertexes;int numEdges;
}MGraph;void MGraphCreate(MGraph* G)
{printf("输入顶点数和边数:");scanf("%d %d",&(G->numVertexes), &(G->numEdges));int i, j, k, w;for(i = 0; i < G->numVertexes; i++){printf("输入顶点信息:");scanf("%c", &(G->vexs[i]));}for(i = 0; i < G->numVertexes; i++){for(j = 0; j < G->numVertexes; j++){G->arc[i][j] = INFINITY;}}for(k = 0; k < G->numEdges; k++){printf("请输入边[Vi, Vj]上的下标i和j和权重W:");scanf("%d %d %d",&i, &j, &w);G->arc[i][j] = w;G->arc[j][i] = G->arc[i][j];}
}int main(int argc, const char* argv[])
{return 0;
}

搜索

深度优先搜索

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>#define MAXVEX 100/*规定顶点类型为char, 权值类型为int*//*判断是否访问数组*/bool visited[MAXVEX];/*边表节点*/typedef struct EdgeNode{int adjvex;int weight;struct EdgeNode* next;
}EdgeNode;/*节点*/typedef struct VertexNode{char data;EdgeNode* firstEdge;
}VertexNode;/*图*/typedef struct GraphAdjList{VertexNode adjList[MAXVEX];int numVertexes;int numEdges;
}GraphAdjList;/*创建图*/void ALGraphCreate(GraphAdjList* G)
{printf("请输入节点数和边数");scanf("%d %d", &(G->numVertexes), &(G->numEdges));int i, j, k, l;printf("请连续输入每一个节点的数据:");for(i = 0; i < G->numVertexes; i++){scanf("%c", &(G->adjList[i].data));	G->adjList[i].firstEdge = NULL;}for(k = 0; k < G->numEdges; k++){printf("输入边[Vi, Vj]的顶点序号和权值:");scanf("%d,%d %d", &i, &j, &l);EdgeNode* e = (EdgeNode*)malloc(sizeof(EdgeNode));e->adjvex = j;e->weight = l;e->next = G->adjList[i].firstEdge;G->adjList[i].firstEdge = e;EdgeNode* f = (EdgeNode*)malloc(sizeof(EdgeNode));f->adjvex = i;f->weight = l;f->next = G->adjList[j].firstEdge;G->adjList[j].firstEdge = f;}
}/*邻接表的深度优先算法*/void DFS(GraphAdjList* GL, int i)
{EdgeNode* p;visited[i] = true;printf("%c", GL->adjList[i].data);p = GL->adjList[i].firstEdge;while(p){if(visited[p->adjvex] == false){DFS(GL, p->adjvex);}p = p->next;}
}/*邻接表的深度遍历操作*/void DFSTraverse(GraphAdjList* GL)
{int i;for(i = 0; i < GL->numVertexes; i++){visited[i] = false;}for(i = 0; i < GL->numVertexes; i++){if(!visited[i]){DFS(GL, i);}}
}int main(int argc, const char* argv[])
{return 0;
}

广度优先搜索

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>/*定义图*/#define MAXVEX 100/*规定顶点类型为char, 权值类型为int*//*判断是否访问数组*/bool visited[MAXVEX];/*边表节点*/typedef struct EdgeNode{int adjvex;int weight;struct EdgeNode* next;
}EdgeNode;/*节点*/typedef struct VertexNode{char data;EdgeNode* firstEdge;
}VertexNode;/*图*/typedef struct GraphAdjList{VertexNode adjList[MAXVEX];int numVertexes;int numEdges;
}GraphAdjList;/*队列*//*定义队列类型*/typedef struct Queue{int data[MAXVEX];int front;int rear;
}Queue;/*函数:创造队列*/Queue QueueCreate()
{Queue queue;queue.front = 0;queue.rear = 0;return queue;
}/*函数:进入队列*/void EnQueue(Queue* queue, int input)
{if((queue->rear + 1) % MAXVEX == queue->front){printf("队列已满");return;}queue->data[queue->rear] = input;queue->rear = (queue->rear + 1) % MAXVEX;
}/*函数:出队列*/void Dequeue(Queue* queue, int* output)
{if(queue->front == queue->rear){printf("队列已空");return;}*output = queue->data[queue->front];queue->front = (queue->front + 1) % MAXVEX;
}bool QueueEmpty(Queue* queue)
{if(queue->front == queue->rear){return true;}else{return false;}
}/*创建图*/void ALGraphCreate(GraphAdjList* G)
{printf("请输入节点数和边数:");scanf("%d %d", &(G->numVertexes), &(G->numEdges));int i, j, k, l;printf("请输入每一个节点的数据:");for(i = 0; i < G->numVertexes; i++){scanf(" %c", &(G->adjList[i].data));	G->adjList[i].firstEdge = NULL;}for(k = 0; k < G->numEdges; k++){printf("输入边[Vi, Vj]的顶点序号和权值/格式:(a,a a):");scanf("%d,%d %d", &i, &j, &l);EdgeNode* e = (EdgeNode*)malloc(sizeof(EdgeNode));e->adjvex = j;e->weight = l;e->next = G->adjList[i].firstEdge;G->adjList[i].firstEdge = e;EdgeNode* f = (EdgeNode*)malloc(sizeof(EdgeNode));f->adjvex = i;f->weight = l;f->next = G->adjList[j].firstEdge;G->adjList[j].firstEdge = f;}
}/*广度优先搜索*/void BFSTraverse(GraphAdjList* GL)
{int i;for(i = 0; i < GL->numVertexes; i++){visited[i] = false;}Queue Q = QueueCreate();EdgeNode* p;for(i = 0; i < GL->numVertexes; i++){if(visited[i] == false){visited[i] = true;printf("%c\n", GL->adjList[i].data);EnQueue(&Q, i);while(QueueEmpty(&Q) == false){Dequeue(&Q, &i);p = GL->adjList[i].firstEdge;while(p){if(visited[p->adjvex] == false){visited[p->adjvex] = true;printf("%c\n", GL->adjList[p->adjvex].data);EnQueue(&Q, p->adjvex);}p = p->next;}}}}
}int main(int argc, const char* argv[])
{GraphAdjList G;ALGraphCreate(&G);BFSTraverse(&G);return 0;
}

拓扑排序

#include<stdio.h>
#include<stdbool.h>
#include<malloc.h>#define MAXVEX 100typedef struct EdgeNode{int adjvex;struct EdgeNode* next;
}EdgeNode;typedef struct VertexNode{int in;int data;						//data存放的数据是数组下标EdgeNode* firstedge;
}VertexNode, AdjList[MAXVEX];typedef struct{AdjList adjList;int numVertexes;int numEdges;
}graphAdjList, *GraphAdjList;/*函数: 创建邻接表*/void GraphAdjListCreate(GraphAdjList G)
{printf("请输入节点数和边数:");scanf("%d %d", &(G->numVertexes), &(G->numEdges));int i, j, k;for(i = 0; i < G->numVertexes; i++){printf("请输入第%d个节点的数据:", i);scanf("%d", &(G->adjList[i].data));G->adjList[i].firstedge = NULL;G->adjList[i].in = 0;}for(k = 0; k < G->numEdges; k++){printf("请输入[vi,vj]边的节点的下标:");scanf("%d,%d", &i, &j);EdgeNode* curNode = (EdgeNode*)malloc(sizeof(EdgeNode));if(!curNode){perror("CurEdgeNode Create failed");free(curNode);return;}curNode->adjvex = j;curNode->next = G->adjList[i].firstedge;G->adjList[i].firstedge = curNode;	}/*计算每一个节点的入度*/for(i = 0; i < G->numVertexes; i++){EdgeNode* p = G->adjList[i].firstedge;while(p){G->adjList[p->adjvex].in++;p = p->next;}}
}/*函数: 拓扑排序*/bool TopologicalSort(GraphAdjList G)
{int* stack = (int*)malloc(G->numVertexes*sizeof(int));int i;int top = -1;int count = 0;for(i = 0; i < G->numVertexes; i++){if(G->adjList[i].in == 0){stack[++top] = i;}}int getTop;EdgeNode* e;while(top != -1){getTop = stack[top--];printf("%d -> ", G->adjList[getTop].data);count++;e = G->adjList[getTop].firstedge;while(e){if((--(G->adjList[e->adjvex].in)) == 0){stack[++top] = e->adjvex;}e = e->next;}}free(stack);if(count < G->numVertexes){return false;}else{return true;}
}int main(int argc, const char* argcc[])
{return 0;
}

关键路径

#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>#define MAXVEX 100typedef struct EdgeNode{int adjvex;int weight;struct EdgeNode* next;
}EdgeNode;typedef struct VertexNode{int in;int data;						//data存放的数据是数组下标EdgeNode* firstedge;
}VertexNode, AdjList[MAXVEX];typedef struct{AdjList adjList;int numVertexes;int numEdges;
}graphAdjList, *GraphAdjList;/*函数: 创建邻接表*/void GraphAdjListCreate(GraphAdjList G)
{printf("请输入节点数和边数:");scanf("%d %d", &(G->numVertexes), &(G->numEdges));int i, j, k, w;for(i = 0; i < G->numVertexes; i++){printf("请输入第%d个节点的数据:", i);scanf("%d", &(G->adjList[i].data));G->adjList[i].firstedge = NULL;G->adjList[i].in = 0;}for(k = 0; k < G->numEdges; k++){printf("请输入[vi,vj]边的节点的下标和权数:");scanf("%d,%d %d", &i, &j, &w);EdgeNode* curNode = (EdgeNode*)malloc(sizeof(EdgeNode));if(!curNode){perror("CurEdgeNode Create failed");free(curNode);return;}curNode->adjvex = j;curNode->weight = w;curNode->next = G->adjList[i].firstedge;G->adjList[i].firstedge = curNode;	}/*计算每一个节点的入度*/for(i = 0; i < G->numVertexes; i++){EdgeNode* p = G->adjList[i].firstedge;while(p){G->adjList[p->adjvex].in++;p = p->next;}}
}/*函数: 拓扑排序*/int *etv, *ltv;
int *stack2;
int top2;bool TopologicalSort(GraphAdjList GL)
{int top = -1;int gettop;int count = 0;int* stack = (int*)malloc(GL->numVertexes * sizeof(int));if(!stack){perror("stack create failed");}int i;for(i = 0; i < GL->numVertexes; i++){if(GL->adjList[i].in == 0){stack[++top] = i;}}top2 = -1;etv = (int*)malloc(GL->numVertexes * sizeof(int));for(i = 0; i < GL->numVertexes; i++){etv[i] = 0;}stack2 = (int*)malloc(GL->numVertexes * sizeof(int));EdgeNode *e;while(top != -1){gettop = stack[top--];count++;stack2[++top2] = gettop;e = GL->adjList[gettop].firstedge;while(e){if(--(GL->adjList[e->adjvex].in) == 0){stack[++top] = e->adjvex;}if(etv[gettop] + e->weight > etv[e->adjvex]){etv[e->adjvex] = etv[gettop] + e->weight;}e = e->next;}}if(count < GL->numVertexes){return false;}else{return true;}
}/*函数: 求关键路径*/void CriticalPath(GraphAdjList GL)
{TopologicalSort(GL);ltv = (int*)malloc(GL->numVertexes * sizeof(int));int i, j;int ete, lte;int gettop;for(i = 0; i < GL->numVertexes; i++){ltv[i] = etv[GL->numVertexes - 1];}EdgeNode* e;while(top2 != -1){gettop = stack2[top2--];e = GL->adjList[gettop].firstedge;while(e){if(ltv[e->adjvex] - e->weight < ltv[gettop]){ltv[gettop] = ltv[e->adjvex] - e->weight;}e = e->next;}	}for(j = 0; j < GL->numVertexes; j++){for(e = GL->adjList[j].firstedge; e; e = e->next){ete = etv[j];lte = ltv[e->adjvex] - e->weight;if(ete == lte){printf("<v%d,v%d> lenth: %d, ", GL->adjList[j].data, GL->adjList[e->adjvex].data, e->weight);}}}
}int main(int argc, const char* argv[])
{return 0;
}

最短路径

迪杰斯特拉算法

#include <stdio.h>/*定点类型为char, 权值类型为char*/#define MAXVEX 100
#define INFINITY 65535typedef struct MGraph {char vexs[MAXVEX];int arc[MAXVEX][MAXVEX];int numVertexes;int numEdges;
} MGraph;void MGraphCreate(MGraph *G) {printf("输入顶点数和边数:");scanf("%d %d", &(G->numVertexes), &(G->numEdges));int i, j, k, w;for (i = 0; i < G->numVertexes; i++) {printf("输入顶点信息:");scanf("%c", &(G->vexs[i]));}for (i = 0; i < G->numVertexes; i++) {for (j = 0; j < G->numVertexes; j++) {G->arc[i][j] = INFINITY;}}for (k = 0; k < G->numEdges; k++) {printf("请输入边[Vi, Vj]上的下标i和j和权重W:");scanf("%d %d %d", &i, &j, &w);G->arc[i][j] = w;G->arc[j][i] = G->arc[i][j];}
}typedef int patharc;
typedef int ShortPathTable;void ShortestPath_Dijstra(MGraph *G, int v0, patharc P[], ShortPathTable D[]) {int v, w, k, min;int final[MAXVEX];for (v = 0; v < G->numVertexes; v++) {final[v] = 0;D[v] = G->arc[v0][v];P[v] = 0;}D[v0] = 0;final[v0] = 1;for (v = 1; v < G->numVertexes; v++) {min = INFINITY;for (w = 0; w < G->numVertexes; w++) {if (final[w] == 0 && D[w] < min) {k = w;min = D[w];}}final[k] = 1;for (w = 0; w < G->numVertexes; w++) {if (final[w] == 0 && (min + G->arc[k][w] < D[w])) {D[w] = min + G->arc[k][w];P[w] = k;}}}
}int main(int argc, const char *argv[]) { return 0; }

弗洛伊德算法

#include<stdio.h>/*顶点类型为char, 权值类型为int*/#define MAXVEX 100
#define INFINITY 65535typedef struct MGraph{char vexs[MAXVEX];int arc[MAXVEX][MAXVEX];int numVertexes;int numEdges;
}MGraph;void MGraphCreate(MGraph* G)
{printf("输入顶点数和边数:");scanf("%d %d",&(G->numVertexes), &(G->numEdges));int i, j, k, w;for(i = 0; i < G->numVertexes; i++){printf("输入顶点信息:");scanf("%c", &(G->vexs[i]));}for(i = 0; i < G->numVertexes; i++){for(j = 0; j < G->numVertexes; j++){G->arc[i][j] = INFINITY;}}for(k = 0; k < G->numEdges; k++){printf("请输入边[Vi, Vj]上的下标i和j和权重W:");scanf("%d %d %d",&i, &j, &w);G->arc[i][j] = w;G->arc[j][i] = G->arc[i][j];}
}typedef int Pathmatirx[MAXVEX][MAXVEX];			// 对应最短路径的前驱矩阵
typedef int ShortPathTable[MAXVEX][MAXVEX];void ShortestPath_Floyd(MGraph* G, Pathmatirx* P, ShortPathTable* D)
{int  v, w, k;for(v = 0; v < G->numVertexes; v++){for(w = 0; w < G->numVertexes; w++){(*D)[v][w] = G->arc[v][w];(*P)[v][w] = w;}}for(k = 0; k < G->numVertexes; k++){for(v = 0; v < G->numVertexes; v++){for(w = 0; w < G->numVertexes; w++){if((*D)[v][w] > (*D)[v][k] + (*D)[k][w]){(*D)[v][w] = (*D)[v][k] + (*D)[k][w];(*P)[v][w] = (*P)[v][k];}}}}for(v = 0; v < G->numVertexes; v++){for(w = v + 1; w < G->numVertexes; w++){printf("v%d", v);k = (*P)[v][w];while(k != w){printf(" -> v%d", k);k = (*P)[k][w];}printf(" -> v%d", w);}}
}int main(int argc, const char* argv[])
{return 0;
}

最小生成树

克鲁斯卡尔算法

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>#define MAXVEX 100
#define MAXEDGE 200
#define INFINITY 65535/*定义边集数组*/typedef struct Edge
{int begin;int end;int weight;
} Edge;/*定义邻接矩阵*/typedef struct AdjGraph{char vexs[MAXVEX];int arc[MAXVEX][MAXVEX];int numVexs;int numEdges;
} AdjGraph;/*函数: 创造邻接矩阵*/void AdjGraphCreate(AdjGraph* adjGraph)
{printf("请输入顶点数和边数:");scanf("%d %d", &adjGraph->numVexs, &adjGraph->numEdges);int i, j, k, w;printf("请输入每个顶点的数据:");for(i = 0; i < adjGraph->numVexs; i++){scanf(" %c", &adjGraph->vexs[i]);}for(i = 0; i < adjGraph->numVexs; i++){for(j = 0; j < adjGraph->numVexs; j++){adjGraph->arc[i][j] = INFINITY;}adjGraph->arc[i][i] = 0;}for(k = 0; k < adjGraph->numEdges; k++){printf("请以Vi,Vj W的格式输入边的下标和权重:");scanf("%d,%d %d", &i, &j, &w);adjGraph->arc[i][j] = w;adjGraph->arc[j][i] = w;}
}/*函数: 将邻接矩阵转化为边集数组*/void EdgeCreate(AdjGraph* G, Edge edges[])
{int i, j, k = 0;for(i = 0; i < G->numVexs; i++){for(j = i; j  < G->numVexs; j++){if(G->arc[i][j] != INFINITY && G->arc[i][j] != 0){edges[k].begin = i;edges[k].end = j;edges[k].weight = G->arc[i][j];k++;}}}for(i = 0; i < k - 1; i++){for(j = 0; j < k - i - 1; j++){if(edges[j].weight > edges[j+1].weight){Edge type = edges[j];edges[j] = edges[j+1];edges[j+1] = type;}}}
}/*克鲁斯卡尔算法*/int Find(int* parent, int f)
{while(parent[f] > 0){f = parent[f];}return f;
}void MinispanTree_Kruskal(AdjGraph* G)
{int i, n, m;Edge edges[MAXVEX];int parents[MAXVEX];EdgeCreate(G, edges);for(i = 0; i < G->numEdges; i++){n = Find(parents, edges[i].begin);m = Find(parents, edges[i].end);if(n != m){parents[n] = m;printf("(%d,%d) %d", edges[i].begin, edges[i].end, edges[i].weight);}}
}int main(int argc, const char* argv[])
{return 0;
}

普里姆算法

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>#define INFINITY 65535
#define MAXVEX 100typedef struct AdjGraph{char vexs[MAXVEX];int arc[MAXVEX][MAXVEX];int numVexs;int numEdges;
} AdjGraph;void AdjGraphCreate(AdjGraph* adjGraph)
{printf("请输入顶点数和边数:");scanf("%d %d", &adjGraph->numVexs, &adjGraph->numEdges);int i, j, k, w;printf("请输入每个顶点的数据:");for(i = 0; i < adjGraph->numVexs; i++){scanf(" %c", &adjGraph->vexs[i]);}for(i = 0; i < adjGraph->numVexs; i++){for(j = 0; j < adjGraph->numVexs; j++){adjGraph->arc[i][j] = INFINITY;}}for(k = 0; k < adjGraph->numEdges; k++){printf("请以Vi,Vj W的格式输入边的下标和权重:");scanf("%d,%d %d", &i, &j, &w);adjGraph->arc[i][j] = w;adjGraph->arc[j][i] = w;}
}void MiniSpanTree_Prim(AdjGraph* G)
{int min, i, j, k;int adjvex[MAXVEX];int lowcost[MAXVEX];lowcost[0] = 0;adjvex[0] = 0;for(i = 1; i < G->numVexs; i++){lowcost[i] = G->arc[0][i];adjvex[i] = 0;}for(i = 1; i < G->numVexs; i++){min = INFINITY;j = 1;k = 0;while(j < G->numVexs){if(lowcost[j] != 0 && lowcost[j] < min){min = lowcost[j];k = j;}j++;}printf("(%d,%d)\n", adjvex[k], k);lowcost[k] = 0;for(j = 1; j < G->numVexs; j++){if(lowcost[j] != 0 && G->arc[k][j] < lowcost[j]){lowcost[j] = G->arc[k][j];adjvex[j] = k;}}}
}int main(int argc, const char* argv[])
{return 0;
}