Common data structures include: java interview - data structure, Hashtable, Concurrentjava interview - data structure.

(Related video sharing: java teaching video)

Let’s introduce them separately:

java interview - data structure

• Underlying implementation: The underlying overall structure of java interview - data structure is an array, and each element in the array is a linked list. Each time an object (put) is added, a linked list object (Object type) will be generated. Each Entry in the Map is an element in the array (Map.Entry is a <key></key>) , which has a reference from the current element to the next element, which forms a linked list.
• Storage principle: When adding an element to HsahMap, first calculate the Hash value of the Key object and get the array subscript. If the position in the array is empty, insert it, otherwise traverse the linked list at this position. When a node's Key object and Node object are both equals to the new element, replace the node's Value object with the new element's Value object, otherwise insert a new node. (Note: Red-black trees were added after JDK 8)

The length of java interview - data structure is 2 raised to the nth power in order to make all bits of the binary value of length-1 complete. is 1. In this case, when the hash value and (table.length - 1) perform an & operation to calculate the index, the result is equivalent to the value of the last few digits of the hashcode. At this time, as long as the input hashcode itself is evenly distributed, the Hash algorithm The result is uniformity. Therefore, the default length of java interview - data structure is 16 to reduce the probability of hash collision, and it is also a suitable size.

Hashtable

Hashtable thread-safety strategy is very expensive to implement. All related operations of get/put are synchronized, and the performance is very poor in highly competitive concurrency scenarios.

Concurrentjava interview - data structure

Concurrentjava interview - data structure is a thread-safe and efficient java interview - data structure implementation provided in the Java concurrent package. It adopts a very sophisticated Segmentation Lock strategy, The backbone of Concurrentjava interview - data structure is the Segment array. Segment inherits from ReentrantLock and is a reentrant lock. Each Segment is a sub-hash table, and a HashEntry array is maintained in the Segment. In a concurrent environment, there is no need to consider lock competition when operating data from different Segments.

Linkedjava interview - data structure, TreeMap, TreeSet

• Linkedjava interview - data structure: Sequential access java interview - data structure (implemented based on arrays and doubly linked lists).
• TreeMap: Internal sorting (based on red-black tree implementation).
• TreeSet: Ordered Set collection (based on binary tree implementation).

ArrayList, LinkedList, Vector

• ArrayList: dynamic array (based on array implementation).
• LinkedList: Ordered array (implemented based on doubly linked list).
• Vector: Object container, which can put objects of different types (implemented based on arrays).

Collection and Collections

• Collection: The superior interface of the collection class, and the sub-interfaces mainly include List, Set, Queue, etc.
• Collections: Provides tool classes for searching, sorting, replacing, and thread-safety operations on collections.

(Recommendations for more related interview questions: java interview questions and answers)

Binary tree

Common binary tree concepts

• B tree: see database sectionhttps://blog.csdn.net/u012102104/article/details/79773362

• Balanced Binary Tree (AVL tree): The absolute value of the depth difference between the left and right subtrees of each node does not exceed 1.

• Huffman tree: The binary tree with the smallest weighted path length is called the optimal binary tree. The Huffman tree construction is not unique, but the sum of the weighted path lengths of all leaf nodes is the smallest.

• Red-black tree: a self-balancing binary search tree, its properties are:

  1. Nodes are red or black.
  2. The root node is black.
  3. Each leaf node is a black empty node (NIL node).
  4. The two child nodes of each red node are black.
  5. All paths from any node to each of its leaves contain the same number of black nodes.

  There cannot be two consecutive red nodes on all paths from each leaf to the root

Binary tree traversal

// 1. 先序遍历算法 DLRvoid Preorder ( BinTree bt ) {
	if ( bt ) {
		visit ( bt->data );
		Preorder ( bt->lchild );
		Preorder ( bt->rchild );
	}}// 2. 中序遍历算法 LDRvoid Inorder ( BinTree bt ) {
	if ( bt ) {
		Inorder ( bt->lchild );
		visit ( bt->data );
		Inorder ( bt->rchild );
	}}// 3. 后序遍历 LRDvoid Postorder ( BinTree bt ) {
	if ( bt ) {
		Postorder ( bt->lchild );
		Postorder ( bt->rchild );
		visit ( bt->data );
	}}// 4. 按层次遍历。/* 思路：利用一个队列，首先将根（头指针）入队列，以后若队列不空则取队头元素 p，
如果 p 不空，则访问之，然后将其左右子树入队列，如此循环直到队列为空。*/void LevelOrder ( BinTree bt ) {
	// 队列初始化为空
	InitQueue ( Q );
	// 根入队列
	EnQueue ( Q, bt );
	// 队列不空则继续遍历
	while ( ! QueueEmpty(Q) ) {
		DeQueue ( Q, p );
		if ( p!=NULL ) {
			visit ( p->data );
			// 左、右子树入队列
			EnQueue ( Q, p->lchild );
			EnQueue ( Q, p->rchild );
		}
	}}// 非递归遍历二叉树一般借助栈实现

Related recommendations: java introductory tutorial

The above is the detailed content of java interview - data structure. For more information, please follow other related articles on the PHP Chinese website!