以后代码一定要写注释!!!
动态内存分配
c
复制代码
#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;
}
链表
c
复制代码
#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;
}
队列
c
复制代码
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100
typedef 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;
}
栈
c
复制代码
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#define MAXSIZE 100
typedef 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);
}
链栈
c
复制代码
#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;
}
串
暴力匹配
c
复制代码
#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算法
c
复制代码
#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;
}
树
普通的二叉树
c
复制代码
#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;
}
线索二叉树
c
复制代码
#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;
}
图
邻接表
c
复制代码
#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;
}
邻接矩阵
c
复制代码
#include<stdio.h>
#include<stdlib.h>
/*定点类型为char, 权值类型为char*/
#define MAXVEX 100
#define INFINITY 65535
typedef 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;
}
搜索
深度优先搜索
c
复制代码
#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;
}
广度优先搜索
c
复制代码
#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;
}
拓扑排序
c
复制代码
#include<stdio.h>
#include<stdbool.h>
#include<malloc.h>
#define MAXVEX 100
typedef 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;
}
关键路径
c
复制代码
#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>
#define MAXVEX 100
typedef 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;
}
最短路径
迪杰斯特拉算法
c
复制代码
#include <stdio.h>
/*定点类型为char, 权值类型为char*/
#define MAXVEX 100
#define INFINITY 65535
typedef 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; }
弗洛伊德算法
c
复制代码
#include<stdio.h>
/*顶点类型为char, 权值类型为int*/
#define MAXVEX 100
#define INFINITY 65535
typedef 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;
}
最小生成树
克鲁斯卡尔算法
c
复制代码
#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;
}
普里姆算法
c
复制代码
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define INFINITY 65535
#define MAXVEX 100
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;
}
}
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;
}