2016. 12. 9. 14:03

Hello, i am GameDeveloperPlayground.

I am a Korean student and I post it for English practise.

I would appreciate pointing out grammar or typos.


In this posting in about select sort.



About Quick Sort


Quick sort algorithm is developed by Charles Anthony Richard Hore(1962).


Quick sort is selects the pivot to place data smaller than the pivot to the left, and large data to the right.

At the end of this process, the pivoted element finds the aligned position. As a result data smaller than the standard is left, and large data to the right.

In this algorithms are repeated until the left data group and the right data group are no longer resursively based on pibot(Repeat until the number of data groups count is 0 or 1)

At the end of ther repeat, can get a sort groupd of data.



(출처 : 위키백과 퀵정렬)




Sorting process



Le't sort by random data array

15 13 9 10 26 24 85


1. Set up Pivot



15 13 9 10 26 24 85


2 IF is smaller than the pivot, it is dicided info left and right sides.

13 9 03 15 26 24 85


3. Repeat algorithms with left and right data.


( 13 9 10 )   15   ( 26 24 85 )

13 9 10 )   15   ( 26 24 85 )

( 9 10 13 )   15   ( 26 24 85 )

9 10 )   13 15   ( 26 24 85 )


9 10 13 15   ( 26 24 85 )

9 10 13 15   ( 26 24 85 )
9 10 13 15   ( 24 26 85 )


9 10 13 15 24 26 85


Completed!


Example Code


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
void QuickSort(int arrays[], int left, int right)
{
    if(left<right)
    {
        int pivot = Partition(arrays,left,right);
        QuickSort(arrays, left, pivot-1);
        QuickSort(arrays, pivot+1, right);
    }
}
 
int Partition(int arrays[],int left, int right)
{
    int pivot = left;
    right = right +1;
 
    while(left<right)
    {
        do
        {
            ++left;
        }while(arrays[left] < arrays[pivot]);
 
        do
        {
            --right;
        }while(arrays[right] > arrays[pivot]);
 
        if(left<right)
        {
            int swap = arrays[left];
            arrays[left] = arrays[right];
            arrays[right] = swap;
        }
    }
 
    int swap = arrays[pivot];
    arrays[pivot] = arrays[right];
    arrays[right] = swap;
 
    return right;
}
cs


another code


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void QuickSort(int arrays[], int left, int right)
{
    int row = left;
    int high = right;
    int pivot = arrays[(left + right) / 2];
 
    while (row <= high) {
        while (arrays[row] < pivot)
            row++;
        while (arrays[high] > pivot)
            high--;
 
        if (row <= high) {
            int tmp = arrays[row];
            arrays[row] = arrays[high];
            arrays[high] = tmp;
            row++;
            high--;
        }
    };
 
    if (left < high)
        QuickSort(arrays, left, high);
 
    if (row < right)
        QuickSort(arrays, row, right);
}
cs




Algorithm analysis



The time complexity in the most average situation is the time complexity of the algorithm.


There are two main situations.


1. In the best case, it is divided by half for every family member.

2. In the worst case, when divided into one and the rest per family.


First, we calculate the case of 1.


Number of times = (2ⁿ - 1) + 2x (2ⁿ -¹¹) ...

= ⁿ-¹Σ 2 ... I do not know how to write this formula.


Calculate ... NLogN comes out.


In case of 2, it is N².


Later, if you know how to add formulas properly ... then I'll have to fix them.



In any case, since the second case is an extreme situation, the time complexity is O (N logN) using the first case.


Thank you.









'Programing > Algorithm' 카테고리의 다른 글

[Algorithm] About Select Sort  (0) 2016.12.08
[Algorithm] About Insertion Sort  (0) 2016.12.08
[Algorithm] About Bubble Sort !!  (0) 2016.12.08
[Algorithm] About Linear Search  (0) 2016.12.08
[Algorithm] About Binary Search Algorithm.  (0) 2016.12.08
Posted by 시리시안
2016. 12. 8. 17:24


Hello, i am GameDeveloperPlayground.

I am a Korean student and I post it for English practise.

I would appreciate pointing out grammar or typos.


In this posting in about select sort.


About Select Sort


Select sort is sorted is three ways.


1. Find the minimum value in a give array.

2. Replace the value with the value at the front of the array.

3. Replace the array with the first position subtracted in the same way.


Sorting Process


Let's start by randomly array numbers.


9 5 4 3 8 1 7


First find the lowest value in the unaligned array { 9 5 4 3 8 1 7}


It's 1. Replace the found value with the first value.


9 5 4 3 8 1 7 => 1 5 4 3 8 9 7


this one loop is over.


The second is to sort the array except for the first value, 


Find the lowest value 1 { 5 4 3 8 9 7 }. It's 3. Replace with the first array except 1


1 3 4 5 8 9 7


This is the way to go to the end.



(출처 : 위키백과 선택정렬)



Sample Code.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void SelectionSort(int arrays[], int length) 
{
    for(int i=0; i<length; ++i)
    {
        int Minindex = i;
        for(int j= i+1; j<length; ++j)
        {
            if(arrays[j] < arrays[Minindex])
                Minindex = j;
        }
 
        int swap = arrays[i];
        arrays[i] = arrays[Minindex];
        arrays[Minindex] = swap;
    }
}
cs


Implemented simply.



Algorithms analysis


Select sort is should be done entirely to get he minimum value. Therefore.

(n-1) + (n-2) + ..... + 2 + 1 = n(n-1)/2 


The time Complexity will be O(N²) with Big O notation.




Example.



(source:  위키백과 선택정렬 )


Video Example

( source: Youyube )




Thank you

'Programing > Algorithm' 카테고리의 다른 글

[Algorithm] About Quick Sort.  (0) 2016.12.09
[Algorithm] About Insertion Sort  (0) 2016.12.08
[Algorithm] About Bubble Sort !!  (0) 2016.12.08
[Algorithm] About Linear Search  (0) 2016.12.08
[Algorithm] About Binary Search Algorithm.  (0) 2016.12.08
Posted by 시리시안
2016. 12. 8. 16:23


Hello, i am GameDeveloperPlayground.

I am a Korean student and I post it for English practise.

I would appreciate pointing out grammar or typos.


In this posting in Inserting Sort.



About Insertion Sort


Insertion sort is an algorithm that compares all the element of data array with parts of array that have already been sorted from the first to the last.

In the case of Insertion Sort, the first element is already aligned. And start sorting.

Unsorted elements ar insered at the appropriate position relative to the sorted list starting with the last element in the list.

Repeat this operation until all elements ar sorted.



Sorting process


Show you a simple insertion sort example.


5 numbers are given as below, will sort by insertion sort.


4 9 2 5 7


Insertion sort determines that the first element is aligned and starts from the second.


First

4 / □ 2 5 7  | key value = 9

9 is greater than 4 and is located behind 4. □ 2 5 7 

4 / 9 2 5 7 


Second

4 9 / □ 5 7 | key value = 2

2 is less than 9, so it is located in front of 9. □ 9 5 7 

2 is less than 4, so it is located in front of 4. □ 4 9 5 7

2 4 / 9 5 7


Third

2 4 9 / □ 7 | key value = 5

5 is less than 9, so it is located in front of 9. 2 4  9 7

5 is greader than 4, so it is located behind 4. 2 4  9 7

2 4 5 / 9 7


fourth

2 4 5 9 / □ | key value = 7

7 is less than 9, so it is located in front of 9. 2 4 5 □ 9

7 is greater than 5, so it is located behind 5. 2 4 5 □ 9

2 4 5 7 9


Sorting is complete.


(Source : 나무위키 삽입정렬)



Example Code


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void InsertionSort(int arrays[], int length)
{
    int key = -1;
 
    for(int i=1; i<length; ++i)
    {
        key = arrays[i]; // 두번째 값부터.
        int j=i-1;
        for(; j>=0--j)
        {
            if(arrays[j] > key)
            {
                arrays[j+1= arrays[j];
            }
            else
            {
                break;
            }
        }
        arrays[j+1= key;
 
    }
}
cs


It is Simple.



Algorithm analysis


Number of comparisons.


Insertion Sort is from the second element to the first element, than the third element is compared to the second and first.

Of course, if it's already sorted, will not compare.But it is worst case.

0 + 1 + 2 + 3 .... + n-2 + n-1 = n(n-1)/2


So in the worst case, the time complexity is O(N²).


In the best case, the comparison is O(N).




Below is the data I found when I searched for Insertion sort.


Insertion Sort Image Example.

( Source : 위키 백과 : 삽입 정렬 )



Example video of Insertion Sort.

Source ( 유투브 동영상(클릭) )



Thank you

'Programing > Algorithm' 카테고리의 다른 글

[Algorithm] About Quick Sort.  (0) 2016.12.09
[Algorithm] About Select Sort  (0) 2016.12.08
[Algorithm] About Bubble Sort !!  (0) 2016.12.08
[Algorithm] About Linear Search  (0) 2016.12.08
[Algorithm] About Binary Search Algorithm.  (0) 2016.12.08
Posted by 시리시안