Features
Features:

Product Tour >

Edraw AI >

Paid Plans:

Individuals >

Business >

Eduaction >
Resources
Blog

History

How-tos & Tips

Discovery

Biography

Business Analysis

Examples

AI concept Map

Free AI Mind Map Generator

Onenote Mind Map

Bcg Matrix Examples

Nike Marketing Strategy

Unilever SWOT Analysis

Make Mind Maps in Google Docs

Guide

FAQs

What's New

Resource Center
Templates
All Templates

Brain Storming Templates

Strategy and Planning Templates

Project Management Templates

Product Management Templates

Human Resources Templates

Agile Workflow Templates

Marketing Templates

Education Templates

Fun and Games Templates

User Gallery
Download
Pricing
Enterprise

MindMap Gallery Data structure 2 (updating

Data structure 2 (updating

Data Data element (basic unit) Data item (minimum unit) Data object (element collection data subset). The content of the tree is more suitable for viewing pictures. What I have done should be the most comprehensive and easiest to understand.

Edited at 2023-10-26 22:08:37

PlotWizard

Recent works View more works>>

Data structure 2 (updating

PlotWizard

Recent works View more works>>

Recommended to you
Outline

data structure

Tree

clue binary tree

Huffman tree

You can sort them first, from small to large, bottom to top, and then combine them in comparison.

degree definition

picture

1. basic concept

I. complete graph

No direction

n(n-1)/2 edges

promising

n(n-1) arcs.

II. connected graph

Undirected has n-1 edges.

III. Strongly connected graph

directed n items

2. Traverse

breadth bfs (queue)

apex to all

depth dfs (queue)

End to end

3. minimum spanning tree

prim algorithm tree

One point from small to large weight

kruskal kruskal algorithm forest

Whole picture from small to large

4. Shortest path directed and weighted

Dijkstra's algorithm directed

Each endpoint is set to the outer minimum

O(n²) (adjacency matrix, adjacency list)

Floyd algorithm directed

Taking a certain point as an intermediary, the comparison directly reaches the minimum.

5. storage

adjacency matrix

Traversing/storing O(n^2)

adjacency list

2e (undirected)e (directed)

Store O(n e)e coefficients and throw them away

Traverse O(n) stack or queue only accessed once

6. Topological sorting is not unique. There is no predecessor node.

Find

Sequential search (linear arbitrary: including sequential chains

ordered decision tree

ASL failed

You can bring a computer, usually write decimals

All void nodes (path*number of layers)/total number

Average ∑i/n=n 1/n

ASL successful

(layer*number of layers)/total number

Average∑i n/n 1=n/2 n/n 1

Failure = Success 1

optimization

The probability is higher

Half (bisection) search (ordered sequence list)

Step m=(l h )/2

m versus search

Move small to small, move big to big

decision tree

Construct a binary sorting tree

Number of comparisons Height

N number of failures=2n-(n-1)=n 1 ASL=

Block search (ordered order between blocks)

Number of blocks b Within block s

sequential search

Ls=∑i/s Lb=∑I/b Min=Ls Lb=s b 2/2 by multiplying s above and below: the basic inequality of the numerator and denominator

O(n)=sb

Hash lookup

hash

Linear

secondary

chain address

hash address Keywords Number of comparisons

Calculation process: H(element)=element%XX=? . Conflict (? method)%XX=?

ASL success = (sum of comparison times)/number of elements

AS L failure = (number of times from each point to the next empty point, the empty point is 1)/module;

Average lookup length ASL

sort

1. insertion sort

I. Direct insertion sort: sentinel = 1, small exchange

o(n^2) o(1)

II. Hill sorting: di compares each number i, unstable

O(n^1.3) o(1)

2. swap sort

I. Bubble sort: Adjacent pairwise comparison for (i <= n) for (j <= n-i). Stablize

o(n^2) o(1)

II. Quick sort (halve) 1 When the boundary point is placed in the middle (round down) The empty position is compared to the other end. Small, left, large, right. If empty, the other end shrinks in. When ij meets the boundary point, put it back. Unstable.

O(nlog2n) Each number must be determined Number of layers o(log2n)

process

Round right up

subtopic

3. selection sort

I. Simple selection sort: traverse to find the best value and put it at one end

II. Heap sort decision establishment adjustment

Adjust MaxMin Exchange Output Drop Exchange

O(nlog2n)

set up process

(Traverse the sorting code according to the level)

Find the largest/smallest child node from n/2

Note: After the upper layer exchanges, it is judged that the lower layer parent > child is established.

4. Merge sort 1 1 =2

Time O(nlog2n): look at the merge, except the last level. Traverse each level O(n). Space O(n): create arrays temp equal length.

Stable: first fall to the left and then to the right

5. Radix sorting, hundreds of digit sorting, unstable

6. external sort

Summary of sorting knowledge points

time complexity

Quickly hope nlog2n returns to the heap

space complexity

Merge n

stability

I'm emotionally unstable, so I hope I can find some good friends to chat with.

Arrays and generalized tables

string

Main string n

pattern string m

Matching success is best O(m) Matching fails. Best O(n-m 1)=O(n) Worst O((n-m 1)*n)=O(nm)

array

storage computing

[1..10,1..10] refers to ten rows and ten columns

Upper triangle special method

subtopic

Number of lower triangles {big (big 1)/2} small

{Big (Big-1)/2} Small compression

[Storage word: 16-bit binary;] [Storage word length: 8/16/32 binary]

KMP algorithm

next defaults to 01 - starting with letter 1: look at the previous letters that overlap 1 [meaning to skip a few numbers from i j=next[j]]

j=next[j]

nextval defaults to 0, the same is brought to the front, and the difference is dropped. [You can skip the next repeated character directly]

If(T.ch[nextval[j]]==T.ch[next[j]])

generalized table

Header: first element (single/table)

Footer: (go to header)

Operation: from the inside out

Depth: number of brackets on one side

Breadth: number of elements

stacks and queues

Postfix expression, add parentheses

queue

circular queue

Empty f=r

Full r 1=f

Number of elements (n small-large)%n: n-difference

queue

big-small=n

order

Q.base[Q.rear]=e; Q.rear=(Q.rear 1)%MAXQSIZE;

e=Q.base[Q.front]; //Out Q.front=(Q.front 1)%MAXQSIZE;

return Q.base[Q.front];

chain

stack

Pop instant kill: mark the sequence, click the small sequence after the sequence to reverse the order

shared stack

top1 top2 starts from the beginning and end respectively, enters top1 1 top2-1 and fills to top1 1=top2

order

(SqStack &S)*S.top =e; e=*--S.top;*(S.top-1);

chain

P-next=S;S=p;

e=P->data;s=p;p=p->next;

linear table

Stack queues are linear structures, logical structures, and special restricted linear lists. Linear random access, stack queue, first-in-first-out

introduction

concept

Data Data element (basic unit) Data item (minimum unit) Data object (element collection data subset)

logical structure

graph or mesh

Tree

Linear

gather

storage structure

order

Advantages: Random access Disadvantages: Inserting, deleting and moving elements

chain

Disadvantages: low storage density, slow storage Advantage: Convenient to insert and delete Features: Data domain and pointer domain are logically adjacent but not necessarily physically different.

index

Advantages: fast retrieval Disadvantages: takes up a lot of memory

hash

Advantage: Access is O(1) faster than array O(n)

floating theme

code

Creation point

struct node naming *pointer 1, *pointer 2;

typedef struct a{} has no seal but alias;

Pointer = i.e. left points to/replaces right

== is equal to =assignment