programming python Odd even Python

Hướng dẫn array even, odd processing in python - xử lý mảng chẵn, lẻ trong python

Trong chương trình này, một danh sách được chấp nhận với hỗn hợp các yếu tố lẻ và chẵn và dựa trên việc phần tử chẵn hay lẻ, nó được chia thành hai danh sách khác nhau.

Examples:

Input : [8, 12, 15, 9, 3, 11, 26, 23]
Output : Even lists: [8, 12, 26]
         Odd lists: [15, 9, 3, 11, 23]


Input : [2, 5, 13, 17, 51, 62, 73, 84, 95]
Output : Even lists: [2, 62, 84]
         Odd lists: [5, 13, 17, 51, 73, 95]

Được đề xuất: Vui lòng thử cách tiếp cận của bạn trên {IDE} trước, trước khi chuyển sang giải pháp.{IDE} first, before moving on to the solution.

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
0 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
7
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
22____23 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
7
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
8 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
5

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
8

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
0

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
4
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
5

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
9
Array after segregation 12 34 90 8 9 45 3
0

Các

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
2

Output:

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]


Giải pháp ngắn hơn:

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
0 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
7
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
4
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
5

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
9
Array after segregation 12 34 90 8 9 45 3
0

Các

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
2

Output:

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]

Đưa ra một mảng a [], viết một hàm tách biệt và số lẻ. Các chức năng nên đặt tất cả các số chẵn lên hàng đầu, và sau đó là số lẻ.

 Example:  Example:  

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}

Trong đầu ra, thứ tự của các số có thể được thay đổi, tức là, trong ví dụ trên, 34 có thể đến trước 12 và 3 có thể đến trước 9.

Vấn đề rất giống với bài viết cũ của chúng tôi tách 0s và 1 trong một mảng, và cả hai vấn đề này là sự thay đổi của vấn đề cờ quốc gia Hà Lan nổi tiếng.

Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]

Implementation:    

C++

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
39

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
40 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
41 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
42

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
44
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
46
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
48

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
52
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
58

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
66

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
71

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
80

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
44
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
46
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
95

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
99

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
01

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
03

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
06

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
10

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
13
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
15
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
17

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
20

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
22

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
24
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
25
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
29

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
31
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

C

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
38

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
44
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
46
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
48

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
52
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
58

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
62

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
67

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
80

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
44
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
46
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
95

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
99

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
01

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
03

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
06

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
10

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
13
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
15
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
17

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
20

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
22

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
20
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
25
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
29

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
20
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
30
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
31

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Java

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
36 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
37

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
38 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
39

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
46

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
51
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
53
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
63
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
65
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
67

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
72
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
65
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
67

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
88

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
90

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
02 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
05

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Các

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
28
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
25
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
35
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
37

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
39
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Python

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
0 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
46

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
48
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
51
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
522____453
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54________
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
58

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
61__

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
70
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
71
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
76
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
8
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
85
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
91

Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
92
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
93
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
95

Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
92
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
70
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
71
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
92
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
85
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Array after segregation 12 34 90 8 9 45 3
04
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Array after segregation 12 34 90 8 9 45 3
07
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Array after segregation 12 34 90 8 9 45 3
3
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
11
Array after segregation 12 34 90 8 9 45 3
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
13
Array after segregation 12 34 90 8 9 45 3
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
15
Array after segregation 12 34 90 8 9 45 3
55
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
17
Array after segregation 12 34 90 8 9 45 3
555

Array after segregation 12 34 90 8 9 45 3
24

Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
25
Array after segregation 12 34 90 8 9 45 3
28

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
3 
Array after segregation 12 34 90 8 9 45 3
32
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2.

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2 
Array after segregation 12 34 90 8 9 45 3
40

C#

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
40 
Array after segregation 12 34 90 8 9 45 3
42

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
38 
Array after segregation 12 34 90 8 9 45 3
44

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Array after segregation 12 34 90 8 9 45 3
51

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Array after segregation 12 34 90 8 9 45 3
56

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
63
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
65
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
67

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
88

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
90

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
02 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
05

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Các

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
12 10 2 10 10 45 9 45
07
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
25
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
35
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
37

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 45 9 45
16
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Python

12 10 2 10 10 45 9 45
22

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
0 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
46

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
48
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
51
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
522____453
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54________
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
58

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
61__

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
12 10 2 10 10 45 9 45
31
12 10 2 10 10 45 9 45
53

12 10 2 10 10 45 9 45
54
12 10 2 10 10 45 9 45
31 
12 10 2 10 10 45 9 45
42
12 10 2 10 10 45 9 45
34
12 10 2 10 10 45 9 45
28

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 45 9 45
31
12 10 2 10 10 45 9 45
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
12 10 2 10 10 45 9 45
34
12 10 2 10 10 45 9 45
68

12 10 2 10 10 45 9 45
54
12 10 2 10 10 45 9 45
31 
12 10 2 10 10 45 9 45
42
12 10 2 10 10 45 9 45
34
12 10 2 10 10 45 9 45
28

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 45 9 45
34
12 10 2 10 10 45 9 45
76

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
12 10 2 10 10 45 9 45
34
12 10 2 10 10 45 9 45
68

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
12 10 2 10 10 45 9 45
31 
12 10 2 10 10 45 9 45
42
12 10 2 10 10 45 9 45
34
12 10 2 10 10 45 9 45
28

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 45 9 45
31
12 10 2 10 10 45 9 45
61

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 45 9 45
34
12 10 2 10 10 45 9 45
76

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Các

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

12 10 2 10 10 45 9 45
23 
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
08
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
10
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
11
12 10 2 10 10 45 9 45
28

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
15 
12 10 2 10 10 45 9 45
35
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09 
12 10 2 10 10 45 9 45
35
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
11
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
11 
12 10 2 10 10 45 9 45
35
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
15
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

12 10 2 10 10 45 9 45
25 
12 10 2 10 10 45 9 45
35
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
32
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
33

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
50
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
5
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
34
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
34 
12 10 2 10 10 45 9 45
35
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
36
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
12 10 2 10 10 45 9 45
25
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
25
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3__

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
66

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
45 
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50__763
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32____
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
67

JavaScript

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

12 10 2 10 10 45 9 45
23 
Array after segregation 12 34 90 8 9 45 3
24

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
71
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
72 
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
73

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
62

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
67

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
61

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
88

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
90

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
68

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
73

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
72 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
86

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
10
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
26

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
10
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
16
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
25
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
10
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
72 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
12

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
71
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
23
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
26

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
10
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
21

Array after segregation 12 34 90 8 9 45 3

Đầu ra O[n]
Auxiliary Space: O[1]

Độ phức tạp về thời gian: O [N] Không gian phụ trợ: O [1]Lomuto partition]: 

C++

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
39

Thực hiện thay thế [phân vùng Lomuto]: & nbsp;

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
40 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
41 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
42

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
52
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
40

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
45

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
50

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
52

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
48

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
06

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
63

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
72

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
66
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
17

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
31
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
77

Java

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
36 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
37

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
38 
Array after segregation 12 34 90 8 9 45 3
44

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
52
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
12 10 2 10 10 9 45 45
00
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54
12 10 2 10 10 9 45 45
02

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
35
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
12 10 2 10 10 9 45 45
09

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
50

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
20

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
22

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
24

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
12 10 2 10 10 9 45 45
12
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
65
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
12 10 2 10 10 9 45 45
16

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
02 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
12 10 2 10 10 9 45 45
35

Các

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
72

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
12 10 2 10 10 9 45 45
59

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 9 45 45
70
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Python3

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
35
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
12 10 2 10 10 9 45 45
68

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
0 
12 10 2 10 10 9 45 45
77

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 9 45 45
79
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
22____23 
Array after segregation 12 34 90 8 9 45 3
32
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
12 10 2 10 10 9 45 45
90

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
12 10 2 10 10 9 45 45
93
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
8 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 9 45 45
79
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
12 10 2 10 10 9 45 45
79
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
71 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
007
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
009

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
011
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
013

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
015
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
017

Các

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
041

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
037
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
52
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
53

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
051
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
12 10 2 10 10 45 9 45
28

C#

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
40 
Array after segregation 12 34 90 8 9 45 3
42

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
38 
Array after segregation 12 34 90 8 9 45 3
44

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
065

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
066
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
073

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
45

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
48

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
50

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
20

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
22

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
24

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
02 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
100

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
105

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
106
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
107

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
110

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
72

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
77

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
119
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

PHP

12 10 2 10 10 45 9 45
22

12 10 2 10 10 45 9 45
23 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
127
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
130
12 10 2 10 10 45 9 45
28

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
135
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
15
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3______750

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
157

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
12 10 2 10 10 45 9 45
61

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
15 
12 10 2 10 10 45 9 45
35
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
169

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
174
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
169

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
174
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
15
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

12 10 2 10 10 45 9 45
25 
12 10 2 10 10 45 9 45
35
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
194

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
130 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
196
12 10 2 10 10 45 9 45
25
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
32
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
130
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50 
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
51______750

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
45
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
220
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

JavaScript

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
67

12 10 2 10 10 45 9 45
23 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
041

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
72 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
073

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
232

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
237

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
50

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 9 45 45
20

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 9 45 45
22

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
12 10 2 10 10 9 45 45
24

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
72 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
254

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
72 
12 10 2 10 10 9 45 45
59

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
72

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
232

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
261
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
26

Đầu ra

12 10 2 10 10 45 9 45

Độ phức tạp về thời gian: O [N] Không gian phụ trợ: O [1] O[n]
Auxiliary Space: O[1]

Thực hiện thay thế [sử dụng phân vùng ổn định]: & nbsp;stable partition]: 

Để thực hiện vấn đề trên, chúng tôi sẽ sử dụng ổn định_partition trong C ++. Thuật toán ổn định_partition [] sắp xếp trình tự được xác định theo bắt đầu và kết thúc sao cho tất cả các phần tử mà vị ngữ được chỉ định bởi PFN trả về đúng đến trước các phần tử mà vị ngữ trả về sai. Các phân vùng là ổn định. Điều này có nghĩa là thứ tự tương đối của chuỗi được bảo tồn.

Syntax:

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];

Parameters: 

start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.

Chức năng này cố gắng phân bổ một bộ đệm tạm thời. Nếu phân bổ thất bại, thuật toán kém hiệu quả hơn được chọn.

Dưới đây là việc thực hiện logic trên.

Code:

C++14

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
265

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
40 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
41 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
42

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
270
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
272

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
275

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
276
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
277
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
278 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
279
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
281

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
286

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
288
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
06

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
296
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
298

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
300

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Đầu ra

12 10 2 10 10 9 45 45

Độ phức tạp về thời gian: O [N] Không gian phụ trợ: O [1]
If enough extra memory is available, linear in the distance between first and last i.e [O[N] ,where N is the distance between first and last]. It applies predicate [i.e 3rd parameter of above code] exactly once to each element, and performs up to that many element moves.

Thực hiện thay thế [sử dụng phân vùng ổn định]: & nbsp;N*log[N] element swaps [where N is the distance above]. It also applies predicate exactly once to each element.
Auxiliary Space: O[1]

Để thực hiện vấn đề trên, chúng tôi sẽ sử dụng ổn định_partition trong C ++. Thuật toán ổn định_partition [] sắp xếp trình tự được xác định theo bắt đầu và kết thúc sao cho tất cả các phần tử mà vị ngữ được chỉ định bởi PFN trả về đúng đến trước các phần tử mà vị ngữ trả về sai. Các phân vùng là ổn định. Điều này có nghĩa là thứ tự tương đối của chuỗi được bảo tồn.

  1. Chức năng này cố gắng phân bổ một bộ đệm tạm thời. Nếu phân bổ thất bại, thuật toán kém hiệu quả hơn được chọn.
  2. Dưới đây là việc thực hiện logic trên.

Code:

C++

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
265

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
40 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
41 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
42

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
270
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
272

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
276
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
277
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
278 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
279
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
281

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
286

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
06

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
36

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
333

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
77

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
358
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
06

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
367

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
66
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
372
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
14
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
374

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
376

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Java

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
36 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
382

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
38 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
384

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
310
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
312
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
35
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
397
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
402

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
407
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
409
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
12 10 2 10 10 45 9 45
28

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
416
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
65
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
12 10 2 10 10 45 9 45
28

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
424

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
445
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2
12 10 2 10 10 9 45 45
68

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
449
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
455
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
457__

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
12 10 2 10 10 9 45 45
20

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 9 45 45
22

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 9 45 45
24

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
472

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
02 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
477

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
481
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54
Array after segregation 12 34 90 8 9 45 3
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9
Array after segregation 12 34 90 8 9 45 3
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
23
Array after segregation 12 34 90 8 9 45 3
555

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
496

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
376

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Python3

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
0 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
502

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
22 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
2

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 9 45 45
79
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
510
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54
12 10 2 10 10 45 9 45
28

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
516
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
518

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
521
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
8 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
03__

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
530
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
8 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
538
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
540

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68______22222

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
79
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
8

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
12 10 2 10 10 9 45 45
79
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
8

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
22
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
71
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
22____23 
Array after segregation 12 34 90 8 9 45 3
32
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
573

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
576
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
12 10 2 10 10 45 9 45
28

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
580
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
020
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
54
Array after segregation 12 34 90 8 9 45 3
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
9
Array after segregation 12 34 90 8 9 45 3
5
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
23
Array after segregation 12 34 90 8 9 45 3
5551488 ____5555556____555551492 
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
1

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
037
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
4 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
52
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
598

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
599

C#

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
40 
Array after segregation 12 34 90 8 9 45 3
42

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
38 
Array after segregation 12 34 90 8 9 45 3
44

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
310
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
610
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
start: the range of elements to reorder
end: the range of elements to reorder
pfn: User-defined predicate function object that defines 
the condition to be satisfied if an element
is to be classified. A predicate takes single argument 
and returns true or false.
Return Value:
Returns an iterator to the beginning of the elements 
for which the predicate is false.
36

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
318

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
402

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
625

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
628

12 10 2 10 10 45 9 45
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
631

12 10 2 10 10 45 9 45
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
633

12 10 2 10 10 45 9 45
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
635

12 10 2 10 10 45 9 45
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

12 10 2 10 10 45 9 45
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

12 10 2 10 10 45 9 45
54
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
232

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
658
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
02 
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
42 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
43 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
667
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
668
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
669

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
674

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
45 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
677

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
376

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

JavaScript

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
683

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
684

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
685

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
688

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
321

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
324

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
329

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
703

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
337

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
335

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
232

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
726
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
730

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
732

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 9 45 45
22

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 9 45 45
24

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
472

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
741

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
744

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
746

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
376

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

PHP

12 10 2 10 10 45 9 45
22

12 10 2 10 10 45 9 45
23 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
310
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Array after segregation 12 34 90 8 9 45 3
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
130
12 10 2 10 10 45 9 45
28

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50 
12 10 2 10 10 45 9 45
32

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
764
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
130 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
766

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
60 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
771
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
12 10 2 10 10 9 45 45
16

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50__1780

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
6 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Array after segregation 12 34 90 8 9 45 3
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
157

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
55

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
794
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09____451
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
51
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
12 10 2 10 10 45 9 45
61

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
12 10 2 10 10 45 9 45
76

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
68
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
12 10 2 10 10 45 9 45
76

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
7

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
4
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
12 10 2 10 10 45 9 45
61

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
1 
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3______750

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
5
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
45
Algorithm: segregateEvenOdd[]
1] Initialize two index variables left and right:  
            left = 0,  right = size -1 
2] Keep incrementing left index until we see an even number.
3] Keep decrementing right index until we see an odd number.
4] If left < right then swap arr[left] and arr[right]
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
63
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
32
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

12 10 2 10 10 45 9 45
23 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
44
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
5
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50__55551134____
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
851

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
15 
12 10 2 10 10 45 9 45
35
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
169

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
50
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
174
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
169

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
12 10 2 10 10 45 9 45
25
Array after segregation 12 34 90 8 9 45 3
3
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
134
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
174
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
15
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
35 
12 10 2 10 10 45 9 45
25
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
26

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
86

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
882

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
130 
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
196
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
2
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
310
template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
09
Array after segregation 12 34 90 8 9 45 3
5
Even lists: [2, 62, 84]
Odd lists: [5, 13, 17, 51, 73, 95]
130
Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3}
23

template  
BiIter stable_partition[BiIter start, BiIter end, UnPred pfn];
66

Độ phức tạp về thời gian: O [n] & nbsp; không gian phụ trợ: O [1] O[N] 
Auxiliary Space: O[1]

Tài liệu tham khảo: & nbsp; //www.csse.monash.edu.au/~lloyd/tildeallgds/sort/flag/pleas Viết nhận xét nếu bạn tìm thấy mã/thuật toán trên không chính xác hoặc tìm ra cách tốt hơn để giải quyết vấn đề tương tự.
//www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Flag/
Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.

Bài Viết Liên Quan

Hướng dẫn which is faster python or powershell? - python hay powershell nhanh hơn?
Hướng dẫn what is for loop explain with example python? - vòng lặp giải thích với ví dụ python là gì?
Wann sind 2023 Ferien in Sachsen Anhalt?
Hướng dẫn latex in python string - latex trong chuỗi python
Cài đặt wordpress với xampp
Hướng dẫn how to remove vertical border in table css - cách xóa viền dọc trong bảng css
Hướng dẫn open new tab with html content - mở tab mới với nội dung html
BMW X5 50e hybrid 2023
Hướng dẫn write php script for addition of two 2x2 matrices - viết tập lệnh php để thêm hai ma trận 2x2
Hướng dẫn how do i make textbox input only numbers in html? - làm cách nào để tạo hộp văn bản chỉ nhập số trong html?
Hướng dẫn scss override style - kiểu ghi đè scss
Hướng dẫn ks test poisson python - kiểm tra ks poisson trăn
MotoGP Aragon 2023
Hướng dẫn can i use linux commands in python? - tôi có thể sử dụng các lệnh linux trong python không?
Hướng dẫn python template vscode - mẫu python vscode
Hướng dẫn how do you get the first two words of a string in python? - làm thế nào để bạn có được hai từ đầu tiên của một chuỗi trong python?
Hướng dẫn is react easy after learning javascript? - phản ứng có dễ dàng sau khi học javascript không?
Hướng dẫn class point2d python - lớp con trăn point2d
Hướng dẫn reset object python - đặt lại đối tượng python
Hướng dẫn where was python developed? - python được phát triển ở đâu?

Toplist mới

#1
Top 4 uống nước chanh sả mật ong có tác dụng gì 2023
6 tháng trước
#2
Top 10 bài tập làm văn số 5 lớp 7 de 4 2023
6 tháng trước
#3
Top 3 vừa chơi đã có tài khoản vương giả chap 1 2023
6 tháng trước
#4
Top 6 anh sẽ on thôi cover phạm nguyên ngọc lyrics 2023
6 tháng trước
#5
Top 7 tài liệu quản lý nhà nước và quản lý ngành giáo dục đào tạo 2023
6 tháng trước
#6
Top 7 hãy ra khỏi người đó đi hợp âm 2023
6 tháng trước
#7
Top 6 giáo án thơ về thăm nhà bác 2023
6 tháng trước
#8
Top 8 giáo án ngữ văn 6 cánh diều 2023
6 tháng trước
#9
Top 9 tinh bột tham gia phản ứng nào 2023
6 tháng trước

Bài mới nhất

Top 10 leadership qualities that make good leaders năm 2024
Chèn ảnh có sẵn trong word vào văn bản năm 2024
Đề thi môn toán lớp 8 học kì 2 năm 2024
Các sở ban ngành tiếng trung là gì năm 2024
Bài 37 sgk toán 9 tập 1 trang 94 năm 2024
Bluestack là gì chơi có quảng cáo không năm 2024
Http www.animesex.pro en search highschool 20dxd-top 1.html năm 2024
Hiền tài sinh lỗi số trong tam quốc diễn nghĩa năm 2024
Bị hạt gạo ở móng tay là bị gì năm 2024
Kim loại nào cứng nhất trong các kim loại năm 2024

Chủ Đề

programming Hỏi Đáp Mẹo Hay Toplist Là gì Địa Điểm Hay Học Tốt Công Nghệ mẹo hay Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn So Sánh Tiếng anh So sánh Bài tập Xây Đựng Sản phẩm tốt Ngôn ngữ Bài Tập Máy tính javascript Ở đâu Hướng dẫn Thế nào Dịch Tại sao Đại học Món Ngon Facebook Khoa Học