Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Praefatio

Si vis scire quid sit multiplicitas spatii / temporis, scire debes quid structura data sit.

Quod dupliciter potest intelligi. Data ubique in vita nostra existunt, ut eventus internationalis in rebus calidis in Douyin, armorum Yongzheng amotione etc. Quid nostri notores videre possunt esse notitias quae Douyin traduntur in servo backend. Haec autem omnia unam proprietatem habent, hoc est, omnes in indice inquisitionis calidi Douyin sunt, et hoc indicem exstructum est ut notitia in certo loco usorum percurrere.

Praeterea, algorithms cum notitiis structurae inseparabiles sunt. Bene, ut modo diximus, notitiae structurae thesaurorum notitia regulariter in structura, ut efficaciter ex structura accedere data est algorithmus.

tempus complexionem

Cum algorithms est tempus multiplicitatis et complexionis spatii. Quia memoria computatorum maior et maior est questus, tempus multiplicitatis maius est quam spatium complexionis.Primum igitur tempus complexionis intelligamus

conceptum

Tempus multiplicitatis, quod maxime verbum est tempus, tempus hic refertur ad tempus quo programma currit.Tempus multiplicitatis calculi per formulam functionis T(N) exprimitur.

Cur ergo non computamus complexitatem temporis huius programmatis praemisso et scribendo codicem solutionis optimae? Hoc computatrum quaestiones involvit.

1. Quia tempus cursus programma refertur ad ambitum ambitum et figuram machinae currens, exempli gratia, programmatis algorithmus vetus compilator utitur.
   Componendo cum novo compilatore et cum novo compilatore componendo varias temporum cursus in eadem machina habent.
2. Eadem algorithmus programma diversis temporibus currit utens machina vetus humilis-figurationis et nova machina summus configurationis.
3. Tempus et tempus solum probare possunt, postquam programma scriptum est, non computata et aestimata per theoricam cogitationem antequam programma scriberet.

Intueamur fragmen codice:

// 请计算⼀下Func1中count语句总共执⾏了多少
次？
void Func1(int N)
{
int count = 0;
for (int i = 0; i < N ; ++ i)
{
for (int j = 0; j < N ; ++ j)
{
++count;
}
}
for (int k = 0; k < 2 * N ; ++ k)
{
++count;
}
int M = 10;
while (M--)
{
++count;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Si hunc codicem spectes secundum numerum suppliciorum comitis, debet esse;
T (N) = N2 + 2 N + 10
• N = 10 T(N) = 130
• N = 100 T(N) = 10210
• N = 1000 T(N) = 1002010

Hoc tempore, quidam dixit, hoc int count=0 non computat;

Hic nimium computatorium nostrum minoris aestimamus. Ergo tempus complexionem quam rationem non accurate, id est asperam aestimationem.

Asymptotica notatio Big O

Magna notatio o: Est symbolum mathematicum ad mores asymptotici functionis adhibitos;

Etiamne aestimat simile T(N) hic? Hoc pertinet ad regulas numerandi O;

1. In tempore multiplicitatis formulae functionis T(N), solum termini supremi ordinis retinentur et termini ordinis ignobilis removentur, quia, cum N crescere pergit, impulsus termini ordinis ignobilis inde minuitur et minor fit. Cum N infinitus sit, negligi potest.
2. Si terminus supremus ordo existat et non sit 1, removere constantem coefficientem huius vocabuli, quia, ut N crescunt, coefficiens minus minusque in effectum habebit.
3. Si res in T(N) nullae N relatae sunt, sed solum constantes item, omnes constantes additivos constantibus 1 restitue.

Deinde vide supra T(N)=N^ 2 + 2 N + 10. Ordo supremus hic est N2, ita sublatis aliis humilibus ordinibus, implicatio est (ON^2).

SECURIS minoris pretii

// 计算Func3的时间复杂度？
void Func3(int N, int M)
{
int count = 0;
for (int k = 0; k < M; ++ k)
{
++count;
}
for (int k = 0; k < N ; ++
k)
{
++count;
}
printf("%dn", count);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Hic T(N)=M+N, cogitemus iterum O(N) hic M et N utrumque eiusdem ordinis, ut primae regulae non pareant, nec secundae et tertiae regulis respondeant. ergo o(N+M), quaesivit, quid si N maius sit quam M, sit O(N). Quid si M maior est quam N, ergo hic modo in tuto manemus.

// 计算strchr的时间复杂度？
const char * strchr ( const char
 * str, int character)
{
const char* p_begin = s;
while (*p_begin != character)
{
if (*p_begin == '0')
return NULL;
p_begin++;
}
return p_begin;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Quaerimus hic indolem in str.

• Nostra calculus plerumque est algorithm multiplicitas pessima.
  Hic dividi potest in tres gradus complexionis;
  1. optimus causa sem
  Ad inveniendum qualitatem in primo chordi positione, deinde;
  F (N) = 1, complexitas est o (1).

2. Mediocris situ:
Characterem invenire in media chorda, deinde;
F (N) = N/2, O(N/2) ;

3. Maxime in re sem
Ad inveniendum characterem in postremo chordi positione, deinde;
F (N) = N, O(N) ;

// 计算BubbleSort的时间复杂度？
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i-1] > a[i])
{
Swap(&a[i-1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

In pejissimo casu, quia summus ordo retinetur et n/2 tollitur (primum item), et coefficiens (secundum item) ignoratur, ON^2 est.

void func5(int n)
{
int cnt = 1;
while (cnt < n)
{
cnt *= 2;
}
}
1
2
3
4
5
6
7
8

Cum n=2, numerus suppliciorum est 1
Quando n=4, numerus caedium est 2
Quando n=16, numerus caedium est 4
Supposito caedium numero x, erit 2 .
x = n
Numerus ergo suppliciorum: x = log n
Ergo: pessimus casus temporis multiplicitas func5 est;
O(log2^n)

Diversi libri modos loquendi diversas habent. Superiores modi scribendi non multum differunt

spatium complexionem

Quid notandum est de multiplicitate spatii, quod ejus calculi repraesentatio etiam per O repraesentatur, ejusque regulae ejusdem temporis complexionem sequantur tres regulas.

Notice

BIBLIOTHECA spatium requiritur cum munus currit (parametrorum ac variabilium localium, nonnullae informationes mandare etc.) determinatum est in compilatione, ideo spatium multiplicitas maxime determinatur ab additamento spatii explicite applicato munere cum currit. .

exemplum 1;

// 计算BubbleSort的时间复杂度？
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i-1] > a[i])
{
Swap(&a[i-1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Munus ACERVUS frame inter compilationem determinatum est.
Tantum opus est ut ad ulteriorem spatium a functione in runtime petitum attendas.
Additional application spatium ad BubbleSort est
Numerus variabilium localium paucae sunt sicut commutatio, quae constanti spatii extra spatium utitur.
Itaque spatium complexionis est O(1).