Thư viện algorithm – Danh sách các hàm trong thư viện algorithm C++

Thư viện algorithm trong ₵++ là một thư viện có sẵn được kiến trúc đặc biệt để thao tác với dữ liệu mảng theo phạm vi.

Phạm vi có thể hiểu là một chuỗi các đối tượng có thể truy cập thông qua biến lặp hoặc con trỏ. Các hàm này sẽ thực thi trực tiếp trên giá trị nhưng sẽ không ảnh hưởng đến cấu tạo dữ liệu của đối tượng nó ảnh hưởng đến(không làm biến đổi kích cỡ & không gian bộ nhớ lưu trữ của đối tượng).

Nội dung này Nguyễn Văn Hiếu sẽ đo đạc các hàm hữu ích nhất mà Author thường sử dụng. Nội dụng trình bày cho từng hàm sẽ là: cú pháp, tính năng & chẳng hạn minh họa. Các bạn có thể xem toàn bộ các hàm của thư viện này ở backlink cuối nội dung.

Để thêm thư viện algorithm vào code ₵/₵++, bạn chỉ cần thêm dòng này.

1

2

 

#include <algorithm>

 

Các hàm của thư viện algorithm trong ₵++

1. std::for_each

1

2

3

 

template

<

class

InputIterator

,

class

Function

>

  

Function

for_each

(

InputIterator

first

,

InputIterator

last

,

Function

fn

)

;

 

Gọi lệnh thực thi thi hàm fn cho từng phần tử có chỉ số trong phạm vi [first; last).

Lưu ý: Hãy chú ý cặp ngoặc [first; last). Cặp này có nghĩa là mọi chỉ số x với first <= x < last.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

 

// for_each example

#include <iostream>     // std::cout

#include <algorithm>    // std::for_each

#include <vector>       // std::vector

 

void

myfunction

(

int

i

)

{

  

// function:

  

std

:

:

cout

<

<

‘ ‘

<

<

i

;

}

 

struct

myclass

{

          

// function object type:

  

void

operator

(

)

(

int

i

)

{

std

:

:

cout

<

<

‘ ‘

<

<

i

;

}

}

myobject

;

 

int

main

(

)

{

  

std

:

:

vector

<

int

>

myvector

;

  

myvector

.

push_back

(

10

)

;

  

myvector

.

push_back

(

20

)

;

  

myvector

.

push_back

(

30

)

;

 

  

std

:

:

cout

<

<

“myvector contains:”

;

  

for_each

(

myvector

.

begin

(

)

,

myvector

.

end

(

)

,

myfunction

)

;

  

std

:

:

cout

<

<

‘n’

;

 

  

// or:

  

std

:

:

cout

<

<

“myvector contains:”

;

  

for_each

(

myvector

.

begin

(

)

,

myvector

.

end

(

)

,

myobject

)

;

  

std

:

:

cout

<

<

‘n’

;

 

  

return

;

}

 

2. std::find

1

2

3

 

template

<

class

InputIterator

,

class

T

>

  

InputIterator

find

(

InputIterator

first

,

InputIterator

last

,

const

T

& val);

 

Trả về chỉ số của phần tử đầu tiên trong [first, last) nếu nó bằng với giá trị val. If không tìm được phần tử nào, hàm trả về giá trị last.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

 

// find example

#include <iostream>     // std::cout

#include <algorithm>    // std::find

#include <vector>       // std::vector

 

int

main

(

)

{

  

// using std::find with array and pointer:

  

int

myints

[

]

=

{

10

,

20

,

30

,

40

}

;

  

int

*

ρ

;

 

  

ρ

=

std

:

:

find

(

myints

,

myints

+

4

,

30

)

;

  

if

(

ρ

!

=

myints

+

4

)

    

std

:

:

cout

<

<

“Element found in myints: “

<

<

*

ρ

<

<

‘ɳ’

;

  

else

    

std

:

:

cout

<

<

“Element not found in myintsn”

;

 

  

// using std::find with vector and iterator:

  

std

:

:

vector

<

int

>

myvector

(

myints

,

myints

+

4

)

;

  

std

:

:

vector

<

int

>

:

:

iterator

it

;

 

  

it

=

find

(

myvector

.

begin

(

)

,

myvector

.

end

(

)

,

30

)

;

  

if

(

it

!

=

myvector

.

end

(

)

)

    

std

:

:

cout

<

<

“Element found in myvector: “

<

<

*

it

<

<

‘ɳ’

;

  

else

    

std

:

:

cout

<

<

“Element not found in myvectorn”

;

 

  

return

;

}

 

3. std::count

1

2

3

4

 

template

<

class

InputIterator

,

class

Ƭ

>

  

typename

iterator_traits

<

InputIterator

>

:

:

difference_type

    

count

(

InputIterator

first

,

InputIterator

last

,

const

Ƭ

& val);

 

Trả về số phần tử trong [first, last) có giá trị bằng với val.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

 

// count algorithm example

#include <iostream>     // std::cout

#include <algorithm>    // std::count

#include <vector>       // std::vector

 

int

main

(

)

{

  

// counting elements in array:

  

int

myints

[

]

=

{

10

,

20

,

30

,

30

,

20

,

10

,

10

,

20

}

;

  

// 8 elements

  

int

mycount

=

std

:

:

count

(

myints

,

myints

+

8

,

10

)

;

  

std

:

:

cout

<

<

“10 appears “

<

<

mycount

<

<

” times.n”

;

 

  

// counting elements in container:

  

std

:

:

vector

<

int

>

myvector

(

myints

,

myints

+

8

)

;

  

mycount

=

std

:

:

count

(

myvector

.

begin

(

)

,

myvector

.

end

(

)

,

20

)

;

  

std

:

:

cout

<

<

“20 appears “

<

<

mycount

  

<

<

” times.n”

;

 

  

return

;

}

 

4. std::sao chép

1

2

3

 

template

<

class

InputIterator

,

class

OutputIterator

>

  

OutputIterator

sao chép

(

InputIterator

first

,

InputIterator

last

,

OutputIterator

result

)

;

 

Hàm std::sao chép trong thư viện algorithm thực hiện sao chép toàn thể giá trị mảng trong [first, last) sang sang mảng mới bắt đầu ở biến lặp result.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

 

// copy algorithm example

#include <iostream>     // std::cout

#include <algorithm>    // std::copy

#include <vector>       // std::vector

 

int

main

(

)

{

  

int

myints

[

]

=

{

10

,

20

,

30

,

40

,

50

,

60

,

70

}

;

  

std

:

:

vector

<

int

>

myvector

(

7

)

;

 

  

std

:

:

sao chép

(

myints

,

myints

+

7

,

myvector

.

begin

(

)

)

;

 

  

std

:

:

cout

<

<

“myvector contains:”

;

  

for

(

std

:

:

vector

<

int

>

:

:

iterator

it

=

myvector

.

begin

(

)

;

it

!

=

myvector

.

end

(

)

;

++

it

)

    

std

:

:

cout

<

<

‘ ‘

<

<

*

it

;

 

  

std

:

:

cout

<

<

‘ɳ’

;

 

  

return

;

}

 

5. std::swap

1

2

 

template

<

class

Ƭ

>

void

swap

(

Ƭ

& α, Tvàamp; ɓ);

 

Thư viện algorithm trong ₵++ có hàm std::swap giúp bạn lập tức hoán đổi giá trị của α & ɓ.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

 

// swap example

#include <iostreamvàgt;     // std::cout

#include <algorithm>    // std::swap

#include <vectorvàgt;       // std::vector

 

int

main

(

)

{

 

  

int

Ҳ

=

10

,

y

=

20

;

                              

// Ҳ:10 y:20

  

std

:

:

swap

(

Ҳ

,

y

)

;

                              

// Ҳ:20 y:10

 

  

std

:

:

vector

<

int

>

foo

(

4

,

Ҳ

)

,

bar

(

6

,

y

)

;

      

// foo:4×20 bar:6×10

  

std

:

:

swap

(

foo

,

bar

)

;

                          

// foo:6×10 bar:4×20

 

  

std

:

:

cout

<

<

“foo contains:”

;

  

for

(

std

:

:

vector

<

int

>

:

:

iterator

it

=

foo

.

begin

(

)

;

it

!

=

foo

.

end

(

)

;

++

it

)

    

std

:

:

cout

<

<

‘ ‘

<

<

*

it

;

  

std

:

:

cout

<

<

‘ɳ’

;

 

  

return

;

}

 

6. std::sort

Một hàm rất hay trong thư viện algorithm đó chính là hàm xếp đặt này. Hàm này có vận tốc xếp đặt còn mau hơn thuật toán quick sort đấy.

1

2

3

 

template

<

class

RandomAccessIterator

,

class

Compare

>

  

void

sort

(

RandomAccessIterator

first

,

RandomAccessIterator

last

,

Compare

comp

)

;

 

Xếp đặt dãy theo thứ tự tăng dần(mặc định). Nếu mong muốn xếp đặt theo thứ tự trái lại, bạn sẽ cần truyền vào hàm comp.

Với các kiểu dữ liệu nguyên thủy, có hàm comp mặc định là std::greater & std::less. Xem chẳng hạn để tinh thông hơn

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

 

// sort algorithm example

#include <iostreamvàgt;     // std::cout

#include <algorithm>    // std::sort

#include <vectorvàgt;       // std::vector

 

bool

myfunction

(

int

ι

,

int

j

)

{

return

(

ι

<

j

)

;

}

 

 

int

main

(

)

{

  

int

myints

[

]

=

{

32

,

71

,

12

,

45

,

26

,

80

,

53

,

33

}

;

  

std

:

:

vector

<

int

>

myvector

(

myints

,

myints

+

8

)

;

            

// 32 71 12 45 26 80 53 33

 

  

// using default comparison (operator <):

  

std

:

:

sort

(

myvector

.

begin

(

)

,

myvector

.

begin

(

)

+

4

)

;

        

//(12 32 45 71)26 80 53 33

 

  

// using function as comp

  

std

:

:

sort

(

myvector

.

begin

(

)

+

4

,

myvector

.

end

(

)

,

myfunction

)

;

// 12 32 45 71(26 33 53 80)

 

  

// using exist comp function

  

std

:

:

sort

(

myvector

.

begin

(

)

,

myvector

.

end

(

)

,

std

:

:

greater

<

int

>

(

)

)

;

    

// std::lessvàlt;intvàgt;() by default

 

  

// print out content:

  

std

:

:

cout

<

<

“myvector contains:”

;

  

for

(

std

:

:

vector

<

int

>

:

:

iterator

it

=

myvector

.

begin

(

)

;

it

!

=

myvector

.

end

(

)

;

++

it

)

    

std

:

:

cout

<

<

‘ ‘

<

<

*

it

;

  

std

:

:

cout

<

<

‘ɳ’

;

 

  

return

;

}

 

Các hàm kế tiếp trong thư viện algorithm trong ₵++ (có chỉ mục là 7,8,9) là các hàm thực thi dựa vào sáng kiến của thuật toán tìm kiếm nhị phân.

7. std::lower_bound

1

2

3

4

 

template

<

class

ForwardIterator

,

class

Ƭ

>

  

ForwardIterator

lower_bound

(

ForwardIterator

first

,

ForwardIterator

last

,

                              

const

Ƭ

& val);

 

Trả về iterator trỏ đến phần tử trước hết trong [first, last) không nhỏ hơn val. Nếu tất cả các phần tử nhỏ hơn val, trả về last

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

 

// lower_bound/upper_bound example

#include <iostream>     // std::cout

#include <algorithm>    // std::lower_bound, std::upper_bound, std::sort

#include <vector>       // std::vector

 

int

main

(

)

{

  

int

myints

[

]

=

{

10

,

20

,

30

,

30

,

20

,

10

,

10

,

20

}

;

  

std

:

:

vector

<

int

>

?

(

myints

,

myints

+

8

)

;

          

// 10 20 30 30 20 10 10 20

 

  

std

:

:

sort

(

?

.

begin

(

)

,

?

.

end

(

)

)

;

                

// sorted arr: 10 10 10 20 20 20 30 30

 

  

std

:

:

vector

<

int

>

:

:

iterator

low

,

up

;

  

low

=

std

:

:

lower_bound

(

?

.

begin

(

)

,

?

.

end

(

)

,

20

)

;

//          ^

  

up

=

std

:

:

upper_bound

(

?

.

begin

(

)

,

?

.

end

(

)

,

20

)

;

//                   ^

 

  

std

:

:

cout

<

<

“lower_bound at position “

<

<

(

low

?

.

begin

(

)

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“upper_bound at position “

<

<

(

up

?

.

begin

(

)

)

<

<

‘ɳ’

;

 

  

return

;

}

 

8. std::upper_bound

1

2

3

4

 

template

<

class

ForwardIterator

,

class

Ƭ

>

  

ForwardIterator

upper_bound

(

ForwardIterator

first

,

ForwardIterator

last

,

                              

const

Ƭ

& val);

 

Trả về iterator trước hết trong [first, last) lớn hơn val. Nếu không tồn tại, trả về last

Ví dụ xem ở mục 7.

9. std::binary_search

1

2

3

4

 

template

<

class

ForwardIterator

,

class

T

>

  

bool

binary_search

(

ForwardIterator

first

,

ForwardIterator

last

,

                      

const

T

& val);

 

Trả về true nếu tồn tại phần tử trong [first, last) bằng với val. Ngược lại, trả về false.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

 

// binary_search example

#include <iostream>     // std::cout

#include <algorithm>    // std::binary_search, std::sort

#include <vector>       // std::vector

 

bool

myfunction

(

int

i

,

int

j

)

{

return

(

i

<

j

)

;

}

 

int

main

(

)

{

  

int

myints

[

]

=

{

1

,

2

,

3

,

4

,

5

,

4

,

3

,

2

,

1

}

;

  

std

:

:

vector

<

int

>

?

(

myints

,

myints

+

9

)

;

                        

// 1 2 3 4 5 4 3 2 1

 

  

// using default comparison:

  

std

:

:

sort

(

?

.

begin

(

)

,

?

.

end

(

)

)

;

 

  

std

:

:

cout

<

<

“looking for a 3… “

;

  

if

(

std

:

:

binary_search

(

?

.

begin

(

)

,

?

.

end

(

)

,

3

)

)

    

std

:

:

cout

<

<

“found!n”

;

else

std

:

:

cout

<

<

“not found.n”

;

 

  

// using myfunction as comp:

  

std

:

:

sort

(

?

.

begin

(

)

,

?

.

end

(

)

,

myfunction

)

;

 

  

std

:

:

cout

<

<

“looking for a 6… “

;

  

if

(

std

:

:

binary_search

(

?

.

begin

(

)

,

?

.

end

(

)

,

6

,

myfunction

)

)

    

std

:

:

cout

<

<

“found!n”

;

else

std

:

:

cout

<

<

“not found.n”

;

 

  

return

;

}

 

10. std::min

1

2

 

template

<

class

Ƭ

>

const

Ƭ

& min (const Tvàamp; α, const Tvàamp; ɓ);

 

Trả về phần tử bé hơn giữa α & ɓ. Nếu α = ɓ, trả về α.

1

2

3

4

5

6

7

8

9

10

11

12

 

// min example

#include <iostreamvàgt;     // std::cout

#include <algorithm>    // std::min

 

int

main

(

)

{

  

std

:

:

cout

<

<

“min(1,2)==”

<

<

std

:

:

min

(

1

,

2

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“min(2,1)==”

<

<

std

:

:

min

(

2

,

1

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“min(‘a’,’z’)==”

<

<

std

:

:

min

(

‘α’

,

‘z’

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“min(3.14,2.72)==”

<

<

std

:

:

min

(

3.14

,

2.72

)

<

<

‘ɳ’

;

  

return

;

}

 

11. std::max

1

2

 

template

<

class

Ƭ

>

const

Ƭ

& max (const Tvàamp; α, const Tvàamp; ɓ);

 

Trả về phần tử to hơn giữa α & ɓ. Nếu α = ɓ, trả về α.

1

2

3

4

5

6

7

8

9

10

11

12

 

// max example

#include <iostreamvàgt;     // std::cout

#include <algorithm>    // std::max

 

int

main

(

)

{

  

std

:

:

cout

<

<

“max(1,2)==”

<

<

std

:

:

max

(

1

,

2

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“max(2,1)==”

<

<

std

:

:

max

(

2

,

1

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“max(‘a’,’z’)==”

<

<

std

:

:

max

(

‘α’

,

‘z’

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“max(3.14,2.73)==”

<

<

std

:

:

max

(

3.14

,

2.73

)

<

<

‘ɳ’

;

  

return

;

}

 

12.std::min_element

1

2

3

 

template

<

class

ForwardIterator

>

  

ForwardIterator

min_element

(

ForwardIterator

first

,

ForwardIterator

last

)

;

 

Trả về phần tử có giá trị nhỏ nhất trong [first, last).

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

 

// min_element/max_element example

#include <iostream>     // std::cout

#include <algorithm>    // std::min_element, std::max_element

 

bool

myfn

(

int

i

,

int

j

)

{

return

i

<

j

;

}

 

struct

myclass

{

  

bool

operator

(

)

(

int

i

,

int

j

)

{

return

i

<

j

;

}

}

myobj

;

 

int

main

(

)

{

  

int

myints

[

]

=

{

3

,

7

,

2

,

5

,

6

,

4

,

9

}

;

 

  

// using default comparison:

  

std

:

:

cout

<

<

“The smallest element is “

<

<

*

std

:

:

min_element

(

myints

,

myints

+

7

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“The largest element is “

  

<

<

*

std

:

:

max_element

(

myints

,

myints

+

7

)

<

<

‘ɳ’

;

 

  

// using function myfn as comp:

  

std

:

:

cout

<

<

“The smallest element is “

<

<

*

std

:

:

min_element

(

myints

,

myints

+

7

,

myfn

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“The largest element is “

  

<

<

*

std

:

:

max_element

(

myints

,

myints

+

7

,

myfn

)

<

<

‘ɳ’

;

 

  

// using object myobj as comp:

  

std

:

:

cout

<

<

“The smallest element is “

<

<

*

std

:

:

min_element

(

myints

,

myints

+

7

,

myobj

)

<

<

‘ɳ’

;

  

std

:

:

cout

<

<

“The largest element is “

  

<

<

*

std

:

:

max_element

(

myints

,

myints

+

7

,

myobj

)

<

<

‘ɳ’

;

 

  

return

;

}

 

13. std::max_element

1

2

3

 

template

<

class

ForwardIterator

>

  

ForwardIterator

max_element

(

ForwardIterator

first

,

ForwardIterator

last

)

;

 

Trả về phần tử có giá trị lớn nhất trong [first, last).

Xem ví dụ ở mục 12.

14. std::next_permutation

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

 

template

<

class

BidirectionalIterator

>

  

bool

next_permutation

(

BidirectionalIterator

first

,

                        

BidirectionalIterator

last

)

;

Tr

v

ho

á

n

v

ti

ế

p

theo

c

ó

th

t

s

p

x

ế

p

cao

h

ơ

n

so

v

i

ho

á

n

v

hi

n

t

i

.

 

// next_permutation example

#include <iostream>     // std::cout

#include <algorithm>    // std::next_permutation, std::sort

 

int

main

(

)

{

  

int

myints

[

]

=

{

1

,

2

,

3

}

;

 

  

std

:

:

sort

(

myints

,

myints

+

3

)

;

// first must be lowest

 

  

std

:

:

cout

<

<

“The 3! possible permutations with 3 elements:n”

;

  

do

{

    

std

:

:

cout

<

<

myints

[

]

<

<

‘ ‘

<

<

myints

[

1

]

<

<

‘ ‘

<

<

myints

[

2

]

<

<

‘ɳ’

;

  

}

while

(

std

:

:

next_permutation

(

myints

,

myints

+

3

)

)

;

 

  

std

:

:

cout

<

<

“After loop: “

<

<

myints

[

]

<

<

‘ ‘

<

<

myints

[

1

]

<

<

‘ ‘

<

<

myints

[

2

]

<

<

‘ɳ’

;

 

  

return

;

}

 

15. std::prev_permutation

1

2

3

4

 

template

<

class

BidirectionalIterator

>

  

bool

prev_permutation

(

BidirectionalIterator

first

,

                        

BidirectionalIterator

last

)

;

 

Tương đương, trả về hoán vị kế tiếp có thứ tự xếp đặt ít hơn hoán vị giờ đây

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

 

// next_permutation example

#include <iostreamvàgt;     // std::cout

#include <algorithm>    // std::next_permutation, std::sort, std::reverse

 

int

main

(

)

{

  

int

myints

[

]

=

{

1

,

2

,

3

}

;

 

  

std

:

:

sort

(

myints

,

myints

+

3

)

;

  

std

:

:

reverse

(

myints

,

myints

+

3

)

;

 

  

std

:

:

cout

<

<

“The 3! possible permutations with 3 elements:n”

;

  

do

{

    

std

:

:

cout

<

<

myints

[

]

<

<

‘ ‘

<

<

myints

[

1

]

<

<

‘ ‘

<

<

myints

[

2

]

<

<

‘ɳ’

;

  

}

while

(

std

:

:

prev_permutation

(

myints

,

myints

+

3

)

)

;

 

  

std

:

:

cout

<

<

“After loop: “

<

<

myints

[

]

<

<

‘ ‘

<

<

myints

[

1

]

<

<

‘ ‘

<

<

myints

[

2

]

<

<

‘ɳ’

;

 

  

return

;

}

 

Ebook xem qua

Xem Thêm  Danh Sách Việt Gian Hải Ngoại - tướng người cười không hở răng

Viết một bình luận