CS 2412 Data Structures. Chapter 9 Graphs

Size: px

Start display at page:

Download "CS 2412 Data Structures. Chapter 9 Graphs"

Susanna Bennett
6 years ago
Views:

1 CS 2412 Data Structures Chapter 9 Graphs

2 Some concepts A graph consists of a set of vertices and a set of lines (edges, arcs). A directed graph, or digraph, is a graph in which each line has a direction. Usually, the lines are called arcs. A path is a sequence of vertices in which each vertex is adjacent to the next one, where adjacent means that there is an line from one to the next one. A cycle is a path consisting of at least three vertices that starts and ends with the same vertex. A loop is a single arc from a vertex to itself. A connected graph is a graph in which any pair of vertices has a path between them. Data Structure 2016 R. Wei 2

3 For a directed graph: Strong connected if there is a path from each vertex to every other vertex. Weakly connected if there is a path from each vertex to every other vertex when the direction of the arc is ignored, but at least two vertices are not connected when we consider the direction of the path. The outdegree of a vertex is the number of arcs leaving the vertex. The indegree is the number of arcs entering the vertex. Data Structure 2016 R. Wei 3

4 Data Structure 2016 R. Wei 4

5 Data Structure 2016 R. Wei 5

6 Data Structure 2016 R. Wei 6

7 Operations Inset a vertex: add a new vertex to the graph. Delete a vertex: removed a vertex from the graph and all edges connected to that vertex are also removed. Add an edge: two vertices must be specified to add an edge. For a digraph, one vertex must be specified as the source and other one as the destination. Delete an edge: remove an edge from the graph. Data Structure 2016 R. Wei 7

8 Traverse graph: Depth-first traversal: Suppose the traversal has just visited a vertex v which is adjacent to vertices w 1, w 2,, w k. Then the traversal visit w 1 and traverse all the vertices to which it is adjacent before returning to traverse w 2,, w k. Breadth-first traversal: Suppose the traversal has just visited a vertex v. Then it next visits all the vertices adjacent to v. Data Structure 2016 R. Wei 8

9 We can use a recursive method to implement graph traverse. But we also can use a stack to implement. Depth-first traversal: 1. Push the first vertex into the stack. 2. Loop: pop a vertex from the stack process the vertex push all of the adjacent vertices into the stack. 3. When the stack is empty, the traversal is complete. Data Structure 2016 R. Wei 9

10 Data Structure 2016 R. Wei 10

11 Use a queue to implement the breadth-first traversal: 1. Enqueue the first vertex into the queue. 2. Loop: dequeue a vertex from the Process the vertex. place all of its adjacent vertices into the queue. 3. When the queue is empty, the traversal is complete. Data Structure 2016 R. Wei 11

12 Data Structure 2016 R. Wei 12

13 Graph representation Adjacency matrix: a 0-1 matrix its rows and columns are indexed by vertices. The cell i, j is 1 if and only if the ith vertex and the jth vertex is adjacent. The matrix of a non-directed graph must be symmetric to its main diagonal. Adjacency list: a list of vertices that are adjacent to the vertex. Each vertex has a adjacent list (unless it is isolated). Data Structure 2016 R. Wei 13

14 Data Structure 2016 R. Wei 14

15 There are different methods to implement graphs. The following implementation are based on the adjacent list. Data Structure 2016 R. Wei 15

16 Data Structure 2016 R. Wei 16

17 typedef struct int count; struct vertex* first; int (*compare) (void* argu1, void* argu2); } GRAPH; typedef struct vertex struct vertex* pnextvertex; void* dataptr; int indegree; int outdegree; short processed; struct arc* parc; } VERTEX; typedef struct arc struct vertex* destination; struct arc* pnextarc; } ARC; Data Structure 2016 R. Wei 17

18 To create a graph is simple. Data Structure 2016 R. Wei 18

19 GRAPH* graphcreate (int (*compare) (void* argu1, void* argu2)) GRAPH* graph; graph = (GRAPH*) malloc (sizeof (GRAPH)); if (graph) graph->first = NULL; graph->count = 0; graph->compare = compare; } // if return graph; } // graphcreate Data Structure 2016 R. Wei 19

20 For the insertion and deletion of vertex in a graph with adjacency list implementation: The vertex list is arranged in order (usually in the increasing order corresponding to the keys). For insertion, first insert the vertex to the vertex list according to the order of key. Then insert the related edges. For deletion, first delete the edges connected to the vertex that will be deleted. Then delete the vertex. We only consider the graph here. But the implementation of digraph is similar. Data Structure 2016 R. Wei 20

21 Data Structure 2016 R. Wei 21

22 void graphinsvrtx (GRAPH* graph, void* datainptr) VERTEX* newptr; VERTEX* locptr; VERTEX* predptr; newptr = (VERTEX*)malloc(sizeof (VERTEX)); if (newptr) newptr->pnextvertex = NULL; newptr->dataptr = datainptr; newptr->indegree = 0; newptr->outdegree = 0; newptr->processed = 0; newptr->parc = NULL; (graph->count)++; } // if malloc else printf("overflow error 100\a\n"), exit (100); locptr = graph->first;// Now find insertion point if (!locptr) Data Structure 2016 R. Wei 22

23 graph->first = newptr; else predptr = NULL; while (locptr && (graph->compare (datainptr, locptr->dataptr) > 0)) predptr = locptr; locptr = locptr->pnextvertex; } // while if (!predptr) graph->first = newptr; else predptr->pnextvertex = newptr; newptr->pnextvertex = locptr; } // else return; } // graphinsvrtx Data Structure 2016 R. Wei 23

24 Data Structure 2016 R. Wei 24

25 int graphdltvrtx (GRAPH* graph, void* dltkey) VERTEX* predptr; VERTEX* walkptr; if (!graph->first) return -2; predptr = NULL; walkptr = graph->first; while (walkptr && (graph->compare(dltkey, walkptr->dataptr) > 0)) predptr = walkptr; walkptr = walkptr->pnextvertex; } // walkptr && if (!walkptr graph->compare(dltkey, walkptr->dataptr)!= 0) Data Structure 2016 R. Wei 25

26 return -2; // then found vertex. Test degree if ((walkptr->indegree > 0) (walkptr->outdegree > 0)) return -1; if (!predptr) //delete graph->first = walkptr->pnextvertex; else predptr->pnextvertex = walkptr->pnextvertex; --graph->count; free(walkptr); return 1; } // graphdltvrtx Data Structure 2016 R. Wei 26

27 Data Structure 2016 R. Wei 27

28 Data Structure 2016 R. Wei 28

29 int graphinsarc (GRAPH* graph, void* pfromkey, void* ptokey) ARC* newptr; ARC* arcpredptr; ARC* arcwalkptr; VERTEX* vertfromptr; VERTEX* verttoptr; newptr = (ARC*)malloc(sizeof(ARC)); if (!newptr) return (-1); //locate source vertex vertfromptr = graph->first; while (vertfromptr && (graph->compare(pfromkey, vertfromptr->dataptr) > 0)) vertfromptr = vertfromptr->pnextvertex; } if (!vertfromptr (graph->compare(pfromkey, vertfromptr->dataptr)!= 0)) Data Structure 2016 R. Wei 29

30 return (-2); verttoptr = graph->first; while (verttoptr && graph->compare(ptokey, verttoptr->dataptr) > 0) verttoptr = verttoptr->pnextvertex; } if (!verttoptr (graph->compare(ptokey, verttoptr->dataptr)!= 0)) return (-3); // From and to vertices located. Insert new arc ++vertfromptr->outdegree; ++verttoptr ->indegree; newptr->destination = verttoptr; if (!vertfromptr->parc) // Inserting first arc for this vertex vertfromptr->parc = newptr; newptr-> pnextarc = NULL; return 1; Data Structure 2016 R. Wei 30

31 } // Find insertion point in adjacency (arc) list arcpredptr = NULL; arcwalkptr = vertfromptr->parc; while (arcwalkptr && graph->compare(ptokey, arcwalkptr->destination->dataptr) >= 0) arcpredptr = arcwalkptr; arcwalkptr = arcwalkptr->pnextarc; } // arcwalkptr && if (!arcpredptr) // Insertion before first arc vertfromptr->parc = newptr; else arcpredptr->pnextarc = newptr; newptr->pnextarc = arcwalkptr; return 1; } // graphinsarc Data Structure 2016 R. Wei 31

32 Data Structure 2016 R. Wei 32

33 Data Structure 2016 R. Wei 33

34 int graphdltarc (GRAPH* graph, void* fromkey, void* tokey) VERTEX* fromvertexptr; VERTEX* tovertexptr; ARC* prearcptr; ARC* arcwalkptr; if (!graph->first) return -2; // Locate source vertex fromvertexptr = graph->first; while (fromvertexptr && (graph->compare(fromkey, fromvertexptr->dataptr) > 0)) fromvertexptr = fromvertexptr->pnextvertex; if (!fromvertexptr graph->compare(fromkey, fromvertexptr->dataptr)!= 0) return -2; // Locate destination vertex in adjacency list if (!fromvertexptr->parc) return -3; prearcptr = NULL; arcwalkptr = fromvertexptr->parc; while (arcwalkptr && (graph->compare(tokey, Data Structure 2016 R. Wei 34

35 arcwalkptr->destination->dataptr) > 0)) prearcptr = arcwalkptr; arcwalkptr = arcwalkptr->pnextarc; } // while arcwalkptr && if (!arcwalkptr (graph->compare(tokey, arcwalkptr->destination->dataptr)!= 0)) return -3; tovertexptr = arcwalkptr->destination; // from, tovertex & arcptr located. Delete arc --fromvertexptr->outdegree; --tovertexptr -> indegree; if (!prearcptr) // Deleting first arc fromvertexptr->parc = arcwalkptr->pnextarc; else prearcptr->pnextarc = arcwalkptr->pnextarc; free (arcwalkptr); return 1; } // graphdltarc Data Structure 2016 R. Wei 35

36 Data Structure 2016 R. Wei 36

37 int graphretrvrtx (GRAPH* graph, void* keyptr, void** pdataout) VERTEX* walkptr; if (!graph->first) return -2; walkptr = graph->first; while (walkptr && (graph->compare (keyptr, walkptr->dataptr) > 0)) walkptr = walkptr->pnextvertex; if (graph->compare(keyptr, walkptr->dataptr) == 0) *pdataout = walkptr->dataptr; return 1; } // if else return -2; } // graphretrvrtx Data Structure 2016 R. Wei 37

38 Data Structure 2016 R. Wei 38

39 Data Structure 2016 R. Wei 39

40 void graphdpthfrst (GRAPH* graph, void (*process) (void* dataptr)) bool success; VERTEX* walkptr; VERTEX* vertexptr; VERTEX* verttoptr; STACK * stack; ARC* arcwalkptr; if (!graph->first) return; // Set processed flags to not processed walkptr = graph->first; while (walkptr) walkptr->processed = 0; walkptr = walkptr->pnextvertex; } // while // Process each vertex in list stack = createstack (); walkptr = graph->first; Data Structure 2016 R. Wei 40

41 while (walkptr) if (walkptr->processed < 2) if (walkptr->processed < 1) // Push & set flag to pushed success = pushstack (stack, walkptr); if (!success) printf("\astack overflow 100\a\n"), exit (100); walkptr->processed = 1; } // if processed < 1 } // if processed < 2 // Process descendents of vertex at stack top while (!emptystack (stack)) vertexptr = popstack(stack); process (vertexptr->dataptr); vertexptr->processed = 2; // Push all vertices from adjacency list Data Structure 2016 R. Wei 41

42 arcwalkptr = vertexptr->parc; while (arcwalkptr) verttoptr = arcwalkptr->destination; if (verttoptr->processed == 0) success = pushstack(stack, verttoptr); if (!success) printf("\astack overflow 101\a\n"), exit (101); verttoptr->processed = 1; } // if verttoptr arcwalkptr = arcwalkptr->pnextarc; } // while pwalkarc } // while!emptystack walkptr = walkptr->pnextvertex; } // while walkptr destroystack(stack); return; } // graphdpthfrst Data Structure 2016 R. Wei 42

43 void graphbrdthfrst (GRAPH* graph, void (*process) (void* dataptr)) bool success; VERTEX* walkptr; VERTEX* vertexptr; VERTEX* verttoptr; QUEUE* queue; ARC* arcwalkptr; if (!graph->first) return; // Set processed flags to not processed walkptr = graph->first; while (walkptr) walkptr->processed = 0; walkptr = walkptr->pnextvertex; } // while // Process each vertex in list queue = createqueue (); walkptr = graph->first; Data Structure 2016 R. Wei 43

44 while (walkptr) if (walkptr->processed < 2) if (walkptr->processed < 1) // Enqueue & set flag to queue success = enqueue(queue, walkptr); if (!success) printf("\aqueue overflow 100\a\n"), exit (100); walkptr->processed = 1; } // if processed < 1 } // if processed < 2 // Process descendents of vertex at que frnt while (!emptyqueue (queue)) dequeue(queue, (void**)&vertexptr); process (vertexptr->dataptr); vertexptr->processed = 2; // Enqueue vertices from adjacency list Data Structure 2016 R. Wei 44

45 arcwalkptr = vertexptr->parc; while (arcwalkptr) verttoptr = arcwalkptr->destination; if (verttoptr->processed == 0) success = enqueue(queue, verttoptr); if (!success) printf("\aqueue overflow 101\a\n"), exit (101); verttoptr->processed = 1; } // if verttoptr arcwalkptr = arcwalkptr->pnextarc; } // while pwalkarc } // while!emptyqueue walkptr = walkptr->pnextvertex; } // while walkptr destroyqueue(queue); return; } // graphbrdthfrst Data Structure 2016 R. Wei 45

46 Data Structure 2016 R. Wei 46

47 Weighted graph Weighted graph is a graph whose edges are weighted. The meaning of the weights depends on the applications. Sometimes, a weighted graph is also called a network. Example: Data Structure 2016 R. Wei 47

48 Two methods can be used to store a weighted graph: Data Structure 2016 R. Wei 48

49 Minimum spanning tree A spanning tree contains all of the vertices in a connected graph. A minimum spanning tree is a spanning tree in which the total weight of the edges is the minimum of all possible spanning trees in the graph. Example: Find a minimum spanning tree for the network: Data Structure 2016 R. Wei 49

50 The main idea: Start from any vertex, say A. Put A into the set S. Consider all the edges connected to A and find out the minimum weight edge, say the edge connect to C. Put C in S and put edge AC to the tree T. In general, consider all the edges connected to a vertex in S, but the vertex of the other end of the edge is not in S. Select the minimum weight edge which is then put in the tree T. The vertex of the other end of the edge is also put in S. If S contains all the vertices of the graph, output T. Data Structure 2016 R. Wei 50

51 Data Structure 2016 R. Wei 51

52 Data structure for spanning tree of graph: We use adjacency list implementation which is similar to the previous implementation of graphs. The main differences are: For graph vertex, intree are used instead of processed. intree is a indicator to indicate if the vertex is included in the spanning tree. For graph edge, weight and intree are added. The weight used to record the weight of the edge and intree is used to indicate if the edge is included in the spanning tree. is Data Structure 2016 R. Wei 52

53 Data Structure 2016 R. Wei 53

54 Data Structure 2016 R. Wei 54

55 Shortest path: Dijkstra algorithm A shortest path between two vertices in a network is a path with minimum weights. Dijkstra algorithm is used to find the shortest path between any two nodes in a graph: Insert the first vertex into the tree. From every vertex already in the tree, check the total path to all adjacent vertices not in the tree. Select the edge with the minimum total path weight and insert it into the tree. Repeat above step until all vertices are in the tree. Data Structure 2016 R. Wei 55

56 Data Structure 2016 R. Wei 56

57 Data Structure 2016 R. Wei 57

58 Algorithm shortestpath (graph) Data Structure 2016 R. Wei 58

59 Data Structure 2016 R. Wei 59

60 The above algorithm is based on adjacency list. We also can use the adjacency matrix to find about the shortest path. Data Structure 2016 R. Wei 60

Chapter 9 STACK, QUEUE

Chapter 9 STACK, QUEUE 1 LIFO: Last In, First Out. Stacks Restricted form of list: Insert and remove only at front of list. Notation: Insert: PUSH Remove: POP The accessible element is called TOP. Stack