C++

// Binarysearchtree. H -- 2011-07-27-17.14class binarysearchtree {public: Enum direction {direction_left, direction_right}; typedef int item; typedef struct node {item; struct node * left, * right;} node; private: node * m_root; int m_current; node *

Practice: sort the data from small to large, so that the nearest few numbers can be together, and then use (I-j + 1) * A [I]-sum; sum-= A [J ++]; in this way, I-j + 1 can be used as the number of duplicates, and the maximum number of duplicates can

The traversal of the sequence is complete. Unlike pre-order traversal, middle-order traversal, and post-order traversal, sequence traversal does not use the stack mode, but uses a queue. The data in the queue, that is, the queueitem is the

Static node * search_the_deepmost_node (const tree) { node * left_node, * right_node; If (tree! = NULL) { left_node = search_the_deepmost_node (tree-> left); right_node = search_the_deepmost_node (tree-> right ); If (null = left_node & null =

// 13-1.h # include namespace binarysearchtree { typedef int item; typedef struct node { item; struct node * left, * right; } node; class binarysearchtree { PRIVATE: node * m_root; int m_current; node * m_makenode (const item & item);

I like the idea of merging two text files. /* 7-37-11-27-22.11.c -- Chapter 7, question 1 */ # include int main (void); int main (void) { file * FPA, * FPB, * FPC; char Cha, ChB; FPA = fopen ("a.txt", "R "); FPB = fopen ("B .txt", "R"

Today, we talked about the iterator and made a research on the Yield keyword in the iterator.   Speaking of yield, we have to talk about the iterator first.The iterator is a new function in C #2.0. With it, we can support foreach iteration in our

/* Splay_tree.h -- stretch tree header file */ /* data type definition */ typedef int item; typedef struct node { item; struct node * left; struct node * right; } node; typedef node * position; typedef node * splaytree; /* interface function

/* Open_addressing_double_hash.h -- enable the address-specific hash header file */ Enum kindofentry {legitimate, empty, deleted }; # define prime 7 /* data type definition */ typedef int item; typedef struct cell { item; Enum kindofentry Info;

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

I thought it was very simple, but I accidentally did it for five hours. Fortunately, I got it. I will not talk about it much, but I will post the code, which is very clear. Node * findkthmin_s (const splaytree * const PST, int K) { node * scan;

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

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

It took 18 hours to finish the study. Am I too stupid? But fortunately, it was written. Clean up and prepare to visit the city. I hope to bring back the real data for my reference. /* 9-32 (a)-12-29-21.48.c -- Chapter 9, question 1 */ # include #

//Chessboard.h#include #include #include #include "Chessman.h"//Ignore examining parameter and error.class Chessboard: private Chessman{private:Chessman * * m_chessboard ;m_Direction * * m_whichDirectionFrom ;int m_lenthOfEdge ;int

The Interval Tree is also an extended data structure based on a binary tree. Each node stores the interval information. This routine is mainly written for the next thing. Of course, it is also worth a long time. // Intervaltree. H -- Interval Tree

This is really difficult to say. in the previous section, I thought about this issue when I was thinking about other issues. I studied it myself and looked at it online again. I finally got a result. I have not considered any further issues. this

Search for the right shift of arithmetic and the right shift of logic. to be honest, the data structure has come to an end recently. Looking at algorithms, we haven't reached the encoding level yet... a little lonely. so, just yesterday, I saw what

When I wrote the previous article, I found that I would not construct the double-∞, so I was determined to have a cryptorchidism. it wasn't until yesterday that the cryptorchidism came out. during the process, I would like to thank my friend who

Rule: 1). Each member's address can be divisible by its own number of bytes;2). The total number of bytes must be divisible by the maximum number of bytes;3). Generally, the starting address is address 0. Otherwise, a complement is generated. For