C++

See A question. tail recursion, loop for recursion. The idea is good, and it is very useful. There is no gorgeous performance improvement, but it just shows the idea of tail recursion. Indeed, I haven't understood the fast sorting yet. Let's

/* Binary_heap_for_kruskal.h -- binary heap file */ # include "new_adjacenty_list.h" /* data type definition */ typedef struct edge { int v_hash_value; int w_hash_value; int weight; } edge; typedef struct binary_heap { edge * heap; int

Unlike path compression, partial path compression makes the nodes on the access path move up. /* 8-14-12-03-00.30.c -- Chapter 8, question 1 */ settype find (disjiontset gather, const item ); settype find (disjiontset gather, const item) {

At first, we chose to use the ADT operation to allocate storage space. later I found that. in this way, there are so many problems that no analysis results will be produced after the analysis. simply go straight to the problem. My thoughts are good,

/* Stack_adt.c -- stack model implementation file */ # include # include # include "stack_adt.h" /* local function declaration */ static stack_node * make_node (const name * const panme ); /* interface function definition */ int

/* Hash. C -- hash table implementation file */ # include # include # include "hash. H " /* local function declaration */ static int get_a_prime (const int number ); static int is_a_prime (const int number); static int square (const int I );

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

/* New_adjacenty_list.h -- adjacent header file */ # include # include "hash. H " # define infinity (~ (1 # define negativeinfinity (-Infinity-1) /* data type definition */ typedef struct adjoin_to_vertex { int hash_value; int cvw; struct

/* New_adjacenty_list.c -- Name of the adjacent table */ # include # include # include "new_adjacenty_list.h" /* local function declaration */ static adjoin_to_vertex * make_adjoin_to_vertex (const hash_table * const PHT, const name, const int

Dynamic Planning Algorithm. Calculate the minimum access cost after the current Binary Search Tree is constructed into the optimal binary search tree. although I have not written a routine to generate the optimal binary search tree, I am very happy.

I was writing the Kruskal algorithm and thought that I should not be too overdrawn. After all, the young capital would easily be squandered. Yesterday I did not take off my clothes and slept all night. It will take up to 5.30 days, and it will be a

Back-to-algorithm. This is also written after various hardships. After writing it, I don't want to say anything more. /* 10-40-11-02-16-06.10.c -- Chapter 10, question 1 *//* 02-18-40th. it took about 13 hours. */ # include # include # define

/* Stack_adt.h -- stack model header file */ /* data type definition */ typedef char name; typedef struct stack_node { name; struct stack_node * Next; } stack_node; typedef stack_node * stack; /* interface function declaration */ /* operation:

This is used to find all cut points in an undirected graph. The implementation method is simplified and the routine is correct. This algorithm does not work for Directed Graphs. This function is implemented by performing a deep-first search to

/* Adjacenty_list.h -- adjacent header file */ # include /* data type definition */ typedef char name; typedef struct vertex { name; struct vertex * Next; } vertex; typedef struct adjacency_list { vertex * List; int * indegree; int capacity;

Invert an adjacent table without considering the weight. It is a function serving another routine. paste it. Int reverse_a (adjacenty_list * const padj, const hash_table * const Pht) { name; adjoin_to_vertex * scan, * new_vertex, * temp_1, ** temp_

This mainly reflects thoughts. the problem was first defined on a known exercise, so there was no universality. in implementation, if the name is stored in the stack and the index is stored at the same time, many function calls will be skipped. in

After several days, the Code finally appeared today. It is much easier to stretch the tree from top to bottom than the one written last year. I understand what people have summarized. It is very difficult for me to write it myself. Some tips for

This task has been written for 8 hours. It is relatively slow. Implementation is completed step by step. The method is as follows: 1. Perform a depth-first search on the source image, and sort the vertex labels in the subsequent order. 2. Reverse

In other words, I wrote this thing for more than four days. I wrote it for 10 hours today and finally finished it. I feel a lot of feelings .! The new data structure needs to be used in combination with the previous data structure. I designed it