C++

I have not studied this in depth, but I haveCodeI have understood and expanded it. I have become a slave. If no code appears for a long time, I will be very depressed. This can help ease the pressure on myself. /* Aatree. H -- AA tree header

/* 9-10 (B)-12-13-000026.c -- Chapter 9, question 10 (B) */ # include # include # include "binary_heap.h" int main (void); int new_dijkstra (const adjacenty_list * padj, const hash_table * const PHT, const int start); int main (void) {

// Block. H -- simulate the integrated circuit board header file # include # include "intervaltree. H " namespace block { using tree: item; using tree: node; using tree: intervaltree; typedef struct block { item xmin, xmax, ymin, Ymax; int

/* Disjiont_set.h -- Non-intersecting set ADT header file */ # define height (0) # define OOS (1 /* data type definition */ typedef int setitem; typedef setitem settype; typedef setitem * disjiont; /* interface function declaration */ /*

/* Binary_heap.c -- binary heap implementation file */ # include # include # include "binary_heap.h" /* local function declaration */ static int percolate_up (const binary_heap * const PBH, const int index); static int percolate_down (const

Determine the maximum flow of a tree, that is, the sum of the maximum flow of leaves, that is, the flow of the whole tree. The outbound traffic of each non-leaf node in the tree = min (inbound traffic, path capacity ). Knowing this, we can solve

/* 9-18 (B)-12-19-00.49.c -- Chapter 9, question 1 */ # include # include # include "binary_heap_for_kruskal.h" # include "disjiont_set.h" # define size (10) int main (void); void Kruskal (const adjacenty_list * const padj, const

A point set of the same degree is the point set that generates the same distance, but is the point set of a different point set. This is something that has been around for the whole day. It is not very clear till now. But the code is written out,

The second day of Chapter 8 is not difficult to implement. This is mainly a collection that represents non-intersecting sets. It can combine known sets to determine the set where an element is located. programming costs are low. the problems

This algorithm can be completed by changing the Edge Weight of the algorithm's main routine to a different number. My original intention is to change the minimum heap to the maximum heap. But it turns out that this is not feasible. paste the code. /

/* Disjiont_set.c -- Non-intersecting set implementation file */ # include # include # include "disjiont_set.h" /* interface function definition */ int initialize_d (disjiont D, const int capacity) { int I; If (capacity return 0; d [0] =

/* Adjacenty_list.c -- Name of the adjacent table */ # include # include # include "adjacenty_list.h" /* local function declaration */ vertex * make_vertex (const name vertex); /* interface function definition */ int createadjacent_list

This ensures that the depth of the tree is very low, and the number of rotations is very small. AVL trees of the same type have greatly improved. But it is not easy to implement. Okay, let's continue with my habits. The Code explains the problem. /*

I have been writing this thing for less than 12 hours. By writing this article, we have strengthened our understanding of the problem of finding a cut point and understood the process of searching for a dual-connection branch. What I want to explain

The Euler loop is written out, and it is natural that Euler's traveling around will be done with some more conditional checks. I can only say that I have fully prepared for this implementation. /* 9-32 (B)-12-31-12.37.c -- Chapter 9, question 1 */ #

I haven't written any code for a long time. This is an exercise in the book. Starting from this code, it means that the crazy encoding in this chapter has started... Recently, some slashes and some distractions... Niang's job is suspended! Tragedy!

/* 10-5-11-1-11-21.47.c -- Chapter 10 Fifth Question */ # include "uiversal_queue.h" typestrudef CT data { int time; int count; } data; int main (void); int showmenuandgetchoice (void ); void eatline (void); int getinput (int * const input,

/* Binary_heap.h -- binary heap file */ # define mindata-32768 /* data type definition */ typedef int item; typedef struct heap { item * array; int capacity;/* capacity */ int size; /* Current Data Volume */} * heap; /* interface function

/* Aatree. C -- AA tree implementation file */ # include "aatree. H "/* global variable Declaration */ static node * nullnode = NULL; /* local function declaration */ static node * singlerotatewithleft (node * const PN ); static node *

What I want to say about this is. about the nullnode node. after calling release () to release the memory, you need to restore it to null for the next continuous use. I think of it, very good. /* Treap. C -- treap tree implementation file */ #