《大话数据结构》读书笔记（三）

最新推荐文章于 2023-06-26 20:30:44 发布
最新推荐文章于 2023-06-26 20:30:44 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whizchen/article/details/8466628
版权

第7章 图（Graph）


图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V，E），其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。


无向边（Edge），用无序偶对（Vi，Vj）来表示。

有向边，也称为弧（Arc），用有序偶<Vi，Vj>来表示，Vi称为弧尾（Tail），Vj称为弧头（Head），图形显示为Vi---->Vj。


图的存储结构

1、邻接矩阵（Adjacency Matrix）

邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧的信息。

typedef char VertexType;           /* 顶点类型应由用户定义 */

typedef int EdgeType;              /* 边上的权值类型应由用户定义 */

#define MAXVEX 100                 /* 最大顶点数，应由用户定义 */

#define INFINITY 65535             /* 用65535来代表无穷大 */

typedef struct
{
	VertextType vexs[MAXVEX];      /* 顶点表 */

	EdgeType arc[MAXVEX][MAXVEX];  /* 邻接矩阵，可看做边表 */

	int numVertexes, numEdges;     /* 图中当前的顶点数和边数 */

}MGraph;


2、邻接表（adjacency List）

临界表顶点采用一个一维数组存储，另外对于顶点数组中，每个数据元素还需要存储指向第一个邻接点的指针，以便于查找该顶点的边信息。

顶点的所有邻接点构成一个线性表，用单链表存储，无向图为顶点的边表，有向图为顶点弧尾的出边表。

typedef char VertexType;           /* 顶点类型应由用户定义 */

typedef int EdgeType;              /* 边上的权值类型应由用户定义 */

typedef struct EdgeNode            /* 边表结点 */
{
	int adjvex;                    /* 邻接点域，存储该顶点对应的下标 */

	EdgeType weight;               /* 用于存储权值，对于非网图可以不需要 */

	struct EdgeNode *next;         /* 链域，指向下一个邻接点 */

}EdgeNode;

typedef struct VertexNode          /* 顶点表结点 */
{
	VertexType data;               /* 顶点域，存储顶点信息 */

	EdgeNode* firstedge;           /* 边表头指针 */

}VertexNode, AdjList[MAXVEX];

typedef struct
{
	AdjList adjList;

	int numVertexes,numEdges;      /* 图中当前顶点数和边数 */

}GraphAdjList;

3、十字链表（Orthogonal List）

对于有向图来说，邻接表只关心出度问题，入度必须要遍历整个图才能知道。有向图中采用了十字链表的存储方法。

结构定义书中没有给出，整理如下

typedef char VertexType;           /* 顶点类型应由用户定义 */

typedef int EdgeType;              /* 边上的权值类型应由用户定义 */

typedef struct ArcNode            /* 弧表结点 */
{
	int tailvex;                  /* 弧起点在顶点表的下标 */
	
	int headvex;                  /* 弧终点在顶点表的下标 */

	struct ArcNode *headlink;     /* 入边表指针域，指向终点相同的下一条边 */

	struct ArcNode *taillink;     /* 边表指针域，指向起点相同的下一条边 */

	EdgeType weight;               /* 用于存储权值，对于非网图可以不需要 */

}ArcNode;

typedef struct VertexNode          /* 顶点表结点 */
{
	VertexType data;               /* 顶点域，存储顶点信息 */

	ArcNode* firstin;              /* 表示入边头指针，指向该顶点的入边表中的第一个结点 */

	ArcNode* firstout;             /* 表示出边头指针，指向该顶点的出边表中的第一个结点 */

}VertexNode, OrtList[MAXVEX];

typedef struct
{
	OrtList ortList;

	int numVertexes,numEdges;      /* 图中当前顶点数和边数 */

}GraphOrtList;

4、邻接多重表（Adjacency MulList）

邻接多重表示对于无向图的邻接表的优化。

typedef char VertexType;         /* 顶点类型应由用户定义 */

typedef int EdgeType;            /* 边上的权值类型应由用户定义 */

typedef emnu{ unvisited,visited} VisitIf;

typedef struct EBox
{
	VisitIf mark:                  /*访问标记*/

	int ivex,jvex;                 /*该边依附的两个顶点的位置*/

	struct EBox ilink, jlink;      /*分别指向依附这两个顶点的下一条边*/

	InfoType info;                 /*该边信息指针*/

}EBox;

typedef struct VexBox
{
	VertexType data;

	EBox fistedge;                 /*指向第一条依附该顶点的边*/

}VexBox, Adjmulist[MAXVEX];

typedef struct
{
	Adjmulist adjmulist;

	int numVertexes,numEdges;      /* 无向图中当前顶点数和边数 */

}AMLGraph;

5、边集数组

边集数组是有两个一维数组构成。一个是存储顶点的信息；另一个是存储边的信息，这个边数组每个数据元素 有一条边的起点下标（begin）、终点下标（end）和权（weight）组成。


图的遍历

深度优先遍历DFS（Depth_First_Search）

邻接矩阵的深度优先遍历算法，对于n个顶点e条边的图，要查找每个顶点的邻接点需要访问矩阵中的所有元素，因此需要O（n^2)的时间。

typedef int Boolean;      /* Boolean是布尔类型， 其值是true或false */

Boolen visited[MAX];     /* 访问标志的数组 */

/* 邻接矩阵的深度优先递归算法 */

void DFS ( MGraph G, int i )
{
	int j;
	
	visited[i] = true;
	
	printf("%c ",G.vexs[i]);
	
	for(j=0;j<G.numVertexes; j++)
		if (G.arc[i][j] == 1 && !visited[j])
			DFS(G, j);
}

/* 邻接矩阵的深度遍历操作 */

void DFSTraverse(MGraph G )
{
	int i;
	
	for(i=0; i<G.numVertexes; i++)
		visited[i] = false;
		
	for(i=0; i<G.numVertexes; i++)
		if (! visited[i])
			DFS(G, i);
}

邻接表的深度优先遍历算法，对于那个顶点e条边的图，找邻接点所需的时间取决于顶点和边的数量，O（n+e）。 

/* 邻接表的深度优先递归算法 */

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])
			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);
}

广度优先遍历BFS（Breadth_First_Search）

邻接矩阵的广度遍历

/* 邻接矩阵的广度遍历算法 */

void BFSTraverse (MGraph G)
{
	int i, j;
	
	Queue Q;
	
	for(i=0; i<G.numVertexes; i++)
		visited[i] = false;
		
	InitQueue(&Q);
	
	for(i=0; i<G.numVertexes; i++)
	{
		if (! visited[i])
		{
			visited[i] = true;
			
			printf("%c ", G.vexs[i]);
			
			EnQueue[&Q,i);
			
			while(! QueueEmpty(Q))
			{
				DeQueue(&Q, &i);
				for(j=0; j<G.numVertexes;j++)
				{
					if (G.arc[i][j] == 1 && !visited[j])
					{
						visited[j] = true;
						
						printf("%c ",G.vexs[j]);
						
						EnQueue(&Q,j);
					}
				}
			}
		}
	}
}


邻接表的广度遍历 

/* 邻接表的广度遍历算法 */

void BFSTraverse(GraphAdjList GL)
{
	int i;
	
	EdgeNode *p;
	
	Queue Q;
	
	for(i=0; i<GL->numVertexes; i++)
		visited[i] = false;
	
	InitQueue(&Q);
	
	for(i=0; i<GL->numVertexes; i++)
	{
		if (! visited[i])
		{
			visited[i] = true;
			
			printf("%c ",GL->adjList[i].data);
			
			EnQueue(&Q,i);
			
			while(! QueueEmpty(Q))
			{
				DeQueue(&Q,i);
				
				p = GL->adjList[i].firstedge;
				
				while(p)
				{
					if (! visited[p->adjvex])
					{
						visited[p->adjvex] = true;
						
						printf("%c ",GL->adjList[p->adjvex].data);
						
						EnQueue(&Q, p->adjvex);
					}
					
					p = p->next;
				}
			}
		}
	}
}

最小生成树（Minimum Cost Spanning Tree）


最小生成树：构造连通图的最小代价生成树


普利姆（Prim）算法

普利姆算法是以顶点为起点，逐步找各顶点上最小权值的边来构建最小生成树的。

/* Prim算法生成最小生成树 */

void MiniSpanTree_Prim( MGraph G )
{
	int min, i, j, k;
	
	int adjvex[MAXVEX];     /* 保存相关顶点下标 */
	
	int lowcost[MAXVEX];    /* 保存相关顶点间边的权值 */
	
	lowcost[0] = 0;         /* 初始化第一个权值为0， 即V0加入生成树 */
	
	adjvex[0] = 0;          /* 初始化第一个顶点下标为0 */
	
	for(i=1; i< G.numVertexes; i++)  /* 循环除下标为0外的全部顶点 */
	{
		lowcost[i] = G.arc[0][i];   /* 将V0顶点与之有边的权值存入数组 */
		
		adjvex[i] = 0;              /* 初始化都为V0的下标 */
		
	}
	
	for(i=1; i<G.numVertexes; i++)
	{
		min = INFINITY;             /* 初始化最小权值为无穷大 */
		
		j = 1; k = 0;
		
		while(j < G.numVertexes)    /* 循环全部顶点 */
		{
			if (lowcost[j] !=0 && lowcost[j] < min)  /* 如果权值不为0 且权值小于min */
			{
				min = lowcost[j];       /* 则让当前权值称为最小值 */
				
				k = j;                  /* 将当前最小值的下标存入k */
			}
			j++;
		}
		
		printf("(%d,%d)",adjvex[k],k);
		
		lowcost[k] = 0;             /* 将当前顶点的权值设置为0， 表示此顶点已经完成任务 */
		
		for(j=1;j<G.numVertexes; j++) /* 循环所有顶点 */
		{
			/* 若下标为k顶点各边权值小雨此前这些顶点未被加入生成树权值 */
			if (lowcost[j] != 0 && G.arc[k][j] < lowcost[j])
			{
				lowcost[j] = G.arc[k][j];  /* 将较小权值存入lowcost */
				
				adjvex[j] = k;             /* 将下标为k的顶点存入adjvex */
			}
		}
	}	
}

克鲁斯卡尔（Kruskal）算法

克鲁斯卡尔以边为目标去构建最小生成树，采用图的存储结构中的边集数组结构。

/* 对边集数组Edge结构的定义 */
typedef struct
{
	int begin;
	
	int end;
	
	int weight;
	
}Edge;


/* Kruskal算法生成最小生成树 */

void MiniSpanTree_Kruskal (MGraph G) /* 生成最小生成树 */
{
	int i, n, m;
	
	Edge edges[MAXEDGE];    /* 定义边集数组 */
	
	int parent[MAXVEX];     /* 定义一数组用来判断边与边是否形成环路 */
	
	/* 此处省略将邻接矩阵G转化为边集数组edges，并按权由小到大排列的代码 */
	
	for (i=0; i<G.numVertexes; i++)	
		parent[i] = 0;        /* 初始化数组为0 */
		
	for(i=0; i<G.numEdges; i++)  /* 循环每一条边 */
	{
		n = Find(parent, edges[i].begin);
		
		m = Find(parent, edges[i].end);
		
		if (n != m)      /* 假如n与m不等，说明此边没有与现有生成树形成环路 */
		{
			parent[n] = m; /* 将此边的结尾顶点放入下标为起点的parent中，表示此顶点已经在生成树集合中 */
			
			printf("(%d,%d) %d ",edges[i].begin,edges[i].end,edges[i].weight);
		}
		
	}
}

int Find(int* parent, int f)  /* 查找连线顶点的尾部下标 */
{
	while(parent[f] > 0)
		f = parent[f];
	
	return f;
}


对比两个算法，克鲁斯卡尔算法主要是针对边来展开，边数少时效率会非常高，所有对稀疏图有很大优势；而普利姆算法对于稠密图，即边数非常多的情况会更好一些。


最短路径


迪杰斯特拉（Dijkstra）算法

#define MAXVEX 9

#define INFINITY 65535

typedef int Pathmatirx[MAXVEX];      /* 用于存储最短路径下标的数组 */

typedef int ShortPathTable[MAXVEX];  /* 用于存储到各点最短路径的权值 */

/* Dijkstra算法，求有向图G的V0顶点到其余顶点v最短路径P[v]及带权长度D[v] */
void ShortestPath_Dijkstra(MGraph G, int v0, Pathmatirx* P, ShortPathTable* D)
{
	int v,w,k,min;
	
	int final[MAXVEX];   /* final[w]=1表示求得顶点V0至Vw的最短路径 */
	
	for(v=0,v<G.numVertexes;v++)  /* 初始化数据 */
	{
		final[v] = 0;      /* 全部顶点初始化为未知最短路径状态 */
		
		(*D)[v] = G.matirx[v0][v]; /* 将与V0点有连线的顶点加上权值 */
		
		(*P)[v] = 0;		   /* 初始化路径数组P为0 */
	}
	
	(*D)[v0] = 0;        /* V0至V0路径为0 */
	
	final[v0] = 1;       /* V0至V0不需要求路径 */
	
	/* 开始主循环，每次求得V0到某个V顶点的最短路径 */
	for(v=1;v<G.numVertexes; v++) 
	{
		min = INFINITY;
		
		for(w=0;w<G.numVertexes;w++)   /* 寻找离V0最近的顶点 */
		{
			if (! final[w] && (*D)[w]<min)
			{
				k = w;
				min = (*D)[w];             /* w顶点离V0顶点更近 */
			}
		}
		
		final[k] = 1;   /* 将目前找到的最近的顶点置为1 */
		
		for(w=0;w<G.numVertexes;w++)  /* 修正当前最短路径及距离 */
		{
			/* 如果经过v顶点的路径比现在这条路径的长度短的话 */
			if (! final[w] && (min+G.matirx[k][w]<(*D)[w]))
			{
				/* 说明找到了更短的路径，修改D[w]和P[w] */
				(*D)[w] = min + G.matirx[k][w]; /* 修改当前路径的长度 */
				
				(*P)[w] = k;
			}
		}
	}
}


弗洛伊德（Floyd）算法 

typedef int Pathmatirx[MAXVEX][MAXVEX];

typedef int ShortPathTable[MAXVEX][MAXVEX];

/* Floyd 算法，求网图G中各顶点v到其余顶点w最短路径P[v][w]及带权长度D[v][w] */
void ShortestPath_Floyd(MGraph G, Pathmatirx *P, ShortPathTable *D)
{
	int v,w,k;
	
	/*初始化D与P */
	for(v=0;v<G.numVertexes;v++)
	{
		for(w=0;w<G.numVertexes;w++)
		{
			(*D)[v][w] = G.matirx[v][w];   /* D[v][w]值即为对应点间的权值 */
			
			(*P)[v][w] = w;                /* 初始化 P */
		}
	}
	
	for(k=0;k<G.numVertexes;k++)
	{
		for(v=0;v<G.numVertexes;v++)
		{
			for(w=0;w<G.numVertexes;w++)
			{
				/* 如果经过下标为k顶点路径比原两点间路径更短 */
				/* 将当前两点间权值设为更小的一个 */
				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];   /* 路径设置经过下标为k的顶点 */
				}
			}
		}
	}
}

拓扑排序

AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系。

拓扑排序：对一个有向图构造拓扑序列的过程。

typedef struct EdgeNode  /* 边表结点 */
{
	int adjvex;        /* 邻接点域，存储该顶点对应的下标 */
	
	int weight;        /* 用于存储权值，对于非网图可以不需要 */
	
	struct EdgeNode *next; /* 链域，指向下一个邻接点 */
	
}EdgeNode;

typedef struct VertexNode  /* 顶点表结点 */
{
	int in;                  /* 顶点入度 */
	
	int data;                /* 顶点域，存储顶点信息 */
	
	EdgeNode *firstedge;     /* 边表头指针 */
	
}VertexNode, AdjList[MAXVEX];

typedef struct
{
	AdjList adjList;
	
	int numVertexes, numEdges; /* 图中当前顶点数和边数 */
	
}graphAdjList,*GraphAdjList;

/* 拓扑排序， 若GL无回路， 则输出拓扑排序序列并返回OK， 若有回路返回ERROR */
Status TopologicalSort(GraphAdjList GL)
{
	EdgeNode *e;
	
	int i,k,gettop;
	
	int top = 0;        /* 用于栈指针下标 */
	
	int count = 0;      /* 用于统计输出顶点的个数 */
	
	int *stack;         /* 建栈存储入度为0的顶点 */
	
	stack = (int *)malloc(GL->numVertexes * sizeof(int));
	
	for(i=0;i<GL.numVertexes;i++)
		if (GL->adjList[i].in = 0)
			stack[++top] = i; /* 将入度为0的顶点入栈 */
	
	while(top != 0)
	{
		gettop = stack[top--];  /* 出栈 */
		
		printf("%d -> ",GL->adjList[gettop].data);
		
		count++;  /* 统计输出顶点数 */
		
		/*对此顶点弧表遍历 */
		for(e=GL->adjList[gettop].firstedge; e; e=e->next)
		{
			k = e->adjvex;   
			
			if (!(--GL->adjList[k].in))  /* 将k号顶点邻接点的入度减1 */
				
				stack[++top] = k;          /* 若为0则入栈，以便于下次循环输出 */
		}
	}
	
	if (count < GL->numVertexes)		/* 如果count小于顶点数，说明存在环 */
		return ERROR;
	else
		return OK;	
}

关键路径 

int *etv, *ltv;     /* 事件最早发生时间和最迟发生时间数组 */

int *stack2;        /* 用于存储拓扑序列的栈 */

int top2;           /* 用于stack2的指针 */

/* 拓扑排序，用于关键路径计算 */
Status TopologicalSort(GraphAdjList GL)
{
	EdgeNode *e;
	
	int i,k,gettop;
	
	int top = 0;        /* 用于栈指针下标 */
	
	int count = 0;      /* 用于统计输出顶点的个数 */
	
	int *stack;         /* 建栈存储入度为0的顶点 */
	
	stack = (int *)malloc(GL->numVertexes * sizeof(int));
	
	for(i=0;i<GL.numVertexes;i++)
		if (GL->adjList[i].in = 0)
			stack[++top] = i; /* 将入度为0的顶点入栈 */
	
	top2 = 0 ;  /* 初始化为0 */
	
	etv = (int *)malloc(GL->numVertexes*sizeof(int));
	
	for(i=0;i<GL->numVertexes;i++)
		etv[i] = 0;  /* 初始化为0 */
	
	stack2 = (int *)malloc(GL->numVertexes * sizeof(int));  /* 初始化 */
	
	while(top != 0)
	{
		gettop = stack[top--];  /* 出栈 */
		
		printf("%d -> ",GL->adjList[gettop].data);
		
		count++;  /* 统计输出顶点数 */
		
		stack2[++top2] = gettop;  /* 将弹出的顶点序号压入拓扑序列的栈 */
		
		/*对此顶点弧表遍历 */
		for(e=GL->adjList[gettop].firstedge; e; e=e->next)
		{
			k = e->adjvex;   
			
			if (!(--GL->adjList[k].in))  /* 将k号顶点邻接点的入度减1 */
				
				stack[++top] = k;          /* 若为0则入栈，以便于下次循环输出 */
			
			if ((etv[gettop]+e->weight)>etv[k])  /* 求各顶点事件最早发生时间值 */
				etv[k] = etv[gettop]+e->weight;
		}
	}
	
	if (count < GL->numVertexes)		/* 如果count小于顶点数，说明存在环 */
		return ERROR;
	else
		return OK;	
}

/* 求关键路径，GL为有向图，输出GL的各项关键活动 */
void CriticalPath(GraphAdjList GL)
{
	EdgeNode *e;
	
	int i,gettop,k,j;
	
	int ete,lte;    /* 声明活动最早发生时间和最迟发生时间变量 */
	
	TopologicalSort(GL);  /* 求拓扑序列，计算数组etv和stack2的值 */
	
	ltv=(int *)malloc(GL->numVertexes*sizeof(int));  /* 事件最晚发生时间 */
	
	for(i=0;i<GL->numVertexes;i++)
		ltv[i] = etv[GL->nmVertexes-1];      /* 初始化ltv */
	
	while(top2 != 0)                       /* 计算ltv */
	{
		gettop = stack2[top--];              /* 将拓扑序列出栈，后进先出 */
		
		for(e = GL->adjList[gettop].firstedge; e; e->next)
		{
			/* 求各顶点事件的最迟发生时间ltv值 */
			k = e->adjvex;
			
			/* 求各顶点事件最晚发生时间ltv */
			if (ltv[k]-e->weight<ltv[gettop])
				ltv[gettop] =  ltv[k]-e->weight;
			
		}
	}
	
	/* 求ete，lte和关键活动 */
	for(j=0;j<GL->numVertexes; j++)
	{
		for(e=GL->adjList[j].firstedge; e; e->next)
		{
			k = e->adjvex;
			
			ete = etv[j];              /* 活动最早发生时间 */
			
			lte = ltv[k] - e->weight;  /* 活动最迟发生时间 */
			
			if(ete == lte)             /* 两者相等即在关键路径上 */
			{
				printf("<v%d,v%d> length: %d, ",
				GL->adjList[j].data,GL-.adjList[k].data,e->weight);
			}
		}
	}
}




whizchen
关注
专栏目录
大话数据结构 读书笔记 （一）
只不停的博客
01-04 441
数据结构：是相互之间存在的一种或者多种特定关系的数据元素的集合。
《大话数据结构》读书笔记
tingyuanyuan的博客
06-24 566
书名：《大话数据结构》 作者：清华大学出版社 程杰 刚毕业那会看的，那时候看数据结构就是背，为了面试嘛。现在回过头再来看，结合平时用的api，发现能理解平时写的很多代码的底层实现逻辑了，做了一下笔记。 ......
《大话数据结构》读书笔记(一)
僵尸吃过跳跳跳
07-11 431
1.1数据结构的起源数据结构是一门研究非数值计算的程序设计问题中的操作对象，以及他们之间的关系和操作等相关问题的学科程序设计 = 数据结构 + 算法1.2基本概念和术语1.2.1 数据数据：是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合。数据不仅仅包括整形、实型等数值类型，还包括字符及声音、图像、视频等非数值类型。数据，也就是符号，必须具备两个前提：...
大话数据结构(读书笔记)
CoderLi
10-11 763
数据结构 什么是数据结构 是相互之间存在一种或多种特定关系的数据元素的集合。 说白了就是数据的集合、但是集合里面的数据之间存在特地的关系(这翻译得好像没说一样) 数据结构的逻辑结构 是指数据元素之间的相互关系 集合结构：集合中的数据元素除了同属一个集合外、它们之间没有其他关系。 线性结构：线性结构中的数据元素之间是一对一的关系 树形结构：树形结构中的数据元素之间存在一种一对多的层次关系 图形结构：图形结构的数据元素是多对多的关系 数据结构的物理结构 指数据的逻辑结构在计算机存储形
大话数据结构读书笔记1
qq_44905426的博客
03-19 427
《大话数据结构》读书笔记1 文章目录《大话数据结构》读书笔记1第一章 数据结构绪论逻辑结构物理结构第二章 算法算法效率的度量方法第三章 线性表线性表的顺序存储结构线性表的链式存储结构静态链表循环链表和双向链表循环链表和双向链表 第一章 数据结构绪论 逻辑结构 1、集合结构：数据元素除了同属于一个集合外，没有其他关系 2、线性结构：数据元素之间是一对一的关系 3、树结构：数据元素之间是一对多的关系 4、图结构：数据元素之间是多对多的关系 物理结构 1、顺序存储结构 2、链式存储结构 第二章 算法 算法效率的度
【数据结构】《大话数据结构》笔记
小徐！勿忘初心！
06-26 186
《大话数据结构》阅读笔记 && 数据结构基础知识查漏补缺
读书笔记大化设计模式、大话数据结构.zip
最新发布
07-19
读书笔记大化设计模式、大话数据结构
大话数据结构读书笔记（3）----栈和链表
小土豆啊的博客
10-08 311
1、栈的定义（stack） 2、栈的顺序和链式存储结构 3、队列的定义（stack） 4、队列的顺序和链式存储结构
《大话数据结构》读书笔记（1）
xuzhouhhy的博客
05-23 342
《大话数据结构》读书笔记 2017-05-22 进度：开始到10% 第一章 数据结构绪论 摘抄“只要你相信自己一定可以学得会、学得好，既然无数人已经掌握了，你凭什么不行。”这句话看起来励志，但其实不是那么回事，人要做适合自己的事情，但是怎样才是，要了解自己才讲得通！ 但是，数据结构是理论知识，确实大多数人都可以掌握。说偏了，说一说今天看的内容。 程序设计=数据结构+算法。这句话很精髓，
大话数据结构 读书笔记
Apple
06-22 667
数据： 是秒速客观事物的符号。
大话数据结构读书笔记
carolineme的博客
03-09 404
一、绪论 1、数据：是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，别输入给计算机处理的符号集合。 数据元素：是组成数据的、有一定意义的基本单位，在计算机中通常作为整体处理。也被称为记录。 数据项：一个数据元素可以由若干个数据项组成。数据项是数据不可分割的最小单位。 数据对象：是性质相同的数据元素的集合，是数据的子集。 总结：数据 > 数据对象 > 数据元素 > 数据项 2、数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。 逻辑结构：数据对象中数
《大话数据结构》读书笔记（一）
高玉龙的博客
06-06 911
学科起源数据结构是一门研究非数值计算的程序设计问题中的操作对象，以及它们之间的关系和操作等相关问题的学科。 程序设计的本质是对确定的问题选择一种好的结构，加上设计一种好的算法， 程序设计 = 数据结构 + 算法 基本概念与术语 数据 是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合。数据元素 是组成数据的、有一定意义的基本单位，在计算机中通常作
【读书笔记】大话数据结构
Keep Reading Keep Writing Keep Thinking
10-26 253
持续学习&持续更新中… 守破离 【读书笔记】大话数据结构前言数据结构和设计模式本书特点如何学习参考书目参考 前言 数据结构很重要，一定要学好。 数据结构非常有趣，数据结构和算法是智慧的结晶，学习它是去感受计算机编程技术的魅力，在理解掌握它的同时，整个过程都是一种愉悦的心情感受，而非枯燥乏味的一门课程。 克服困难 战胜自己 数据结构和设计模式 数据结构和设计模式在某种程度上很类似：都是前辈的武功套路。 设计模式是近几十年卓越程序员的智慧结晶。 数据结构是几百上千年无数科学家、数学家的.
读书笔记 --《大话数据结构》
Mai_NO的博客
10-16 377
大话数据结构 数据结构绪论 数据结构 逻辑结构 指数据对象中数据元素之间的相互关系逻辑结构分为以下四种：集合结构： 集合机构中的数据元素除了同属于一个集合外，它们之间没有其他关系。线性结构： 线性结构中的数据元素之间是一对一的关系。树形结构： 树形结构中的数据元素之间存在一种一对多的层次关系。图形结构： 图形结构的数据元素是多对多的关系。 物理结构 物理结构是指数据的逻辑结构在计算...
读书笔记--大话数据结构
weixin_42384444的博客
06-14 405
大话数据结构 第二章 算法2.1 开场白2.2 数据结构与算法的关系2.3 两种算法的比较2.4 算法的定义2.5 算法的特征2.5.1 输入输出2.5.2 有穷性2.5.3 确定性2.5.4 可行性2.6 算法设计的要求2.6.1 正确性 2.1 开场白 2.2 数据结构与算法的关系 程序设计 = 数据结构+算法 2.3 两种算法的比较 问题：求1+2+3+…+100的和 算法一： int i, sum = 0, n = 100; for(i=0;i<100;i++) { sum += i; }
大话数据结构超清pdf
08-17
很抱歉，根据提供的引用内容，我没有找到关于《大话数据结构》超清PDF的相关信息。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *2* *3* [算法与数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值