# Version number

```
version: 1.0.1
```

# algorithm-sort

```
This is a simple about front end sort algorithm plugin !
```

## Operation command

Name |
Command |
Chinese Explanation |

Bubble Sort |
Sort Bubble |
冒泡排序 |

Selection Sort |
Sort Selection |
选择排序 |

Insertion Sort |
Sort Insertion |
插入排序 |

Shell Sort |
Sort Shell |
希尔排序 |

Merge Sort |
Sort Merge |
归并排序 |

Quick Sort |
Sort Quick |
快速排序 |

Heap Sort |
Sort Heap |
堆排序 |

Counting Sort |
Sort Counting |
计数排序 |

Bucket Sort |
Sort Bucket |
桶排序 |

Radix Sort |
Sort Radix |
基数排序 |

Arr Repeat |
Arr Repeat |
数组去重 |

## Demo Picture

## Document

#zh-cn

#### Bubble Sort

```
Principle:
Bubble sorting is a simple sorting algorithm.
It repeatedly visits the columns to be sorted,
compares two elements at a time,
and swaps them if their order is wrong.
The work of visiting a sequence is repeated until no exchange is needed,
that is to say,
the sequence has been sorted.
The algorithm's name comes from the fact that smaller elements float
slowly to the top of the sequence by swapping.
```

#### Selection Sort

```
Principle:
Selection-sort is a simple and intuitive sorting algorithm.
Its working principle:
first, find the smallest (big) element in the unordered sequence,
store it at the beginning of the ordered sequence,
then continue to find the smallest
(big) element from the remaining unordered elements,
and then put it at the end of the ordered sequence.
By analogy,
until all elements are sorted.
```

#### Insertion Sort

```
Principle:
The algorithm description of Insertion-Sort is a
simple and intuitive sorting algorithm.
Its working principle is
to construct an ordered sequence,
scan backward and forward in the ordered sequence,
find the corresponding position and insert it into the unordered data.
In the implementation of insertion sorting,
in-place sorting is usually used
(that is, sorting using only the extra space of O (1).
Therefore, in the process of scanning backwards and forwards,
it is necessary to move the sorted elements backwards
step by step repeatedly to provide insertion space for
the latest elements.
```

#### Shell Sort

```
Principle:
The core of Hill sort is the setting of interval sequence.
It can not only set the interval sequence in advance,
but also dynamically define the interval sequence.
The algorithm for dynamically defining interval
sequences was proposed by Robert Sedgewick,
co-author of Algorithms (4th edition).
```

#### Merge Sort

```
Principle:
Merge sorting is an effective sorting algorithm based on merge operation.
This algorithm is a very typical application of Divide and Conquer.
Merge sort is a stable sort method.
By merging the existing ordered subsequences,
a completely ordered sequence can be obtained, that is,
each subsequence is ordered first,
and then the subsequence segments are ordered.
If two ordered tables are merged into one ordered table,
it is called 2-path merging.
```

#### Quick Sort

```
Principle:
The basic idea of quick sorting is that the records to be sorted are
separated into two separate parts by one-time sorting,
in which the keywords of one part of the records are
smaller than those of the other,
so the two parts of the records can be sorted separately to
achieve the order of the whole sequence.
```

#### Heap Sort

```
Principle:
Heapsort is a sort algorithm designed by using heap as data structure.
The heap is a nearly complete binary tree structure,
and it satisfies the heap property at the same time: that is,
the key value or index of the child node is always
less than (or greater than) its parent node.
```

#### Counting Sort

```
Principle:
Counting sort is a stable sorting algorithm.
The counting sort uses an additional array C,
where the number of elements whose median value of the array
A to be sorted equals the number of elements of I. Then
the elements in A
are arranged in the correct position according to the
array C. It can only sort integers.
```

#### Bucket Sort

```
Principle:
The principle of Bucket sort:
Assuming that the input data obeys uniform distribution,
the data is divided into a limited number of buckets,
and each bucket is sorted separately (it is possible to use
other sorting algorithms or to continue using bucket sort recursively).
```

#### Radix Sort

```
Principle:
The cardinal sorting is sorted first according to the low position,
and then collected;
then sorted by the high position,
and then collected;
and then analogized to the highest position.
Sometimes some attributes are prioritized, first by low priority,
then by high priority.
The final order is high priority first,
high priority same low priority first.
The cardinal sorting is based on
sorting separately and collecting separately,
so it is stable.
```

## Pulg run

```
Visual Studio Code Search algorithm sort biaov
```

## My plug down address

algorithm-sort

## Warning

Note that this project is not actively maintained anymore.
This is still an incomplete particle effect.
Due to its limited technical knowledge, we expect the subsequent updates.
You can use it as long as you download it.