디렉토리
첫째, 삽입 정렬
(1) 직접 삽입 정렬
삽입 후 최초 정렬의 제 1 부분을 완료하고, 다른 부분은 요소 삽입되는 상기 어레이의 모든 요소 (요소 제외 삽입 될) 것을 정렬 어레이는 두 부분으로 나눌 수 : 알고리즘 생각 소자. 제 1 부분의 두 부분이 다시 수행으로 분할 상기 정렬.
여기서 기본 도착 [0] 배수 시퀀스 부, [J]를, 언 = 도착 [J - 1] 수가 뒤에서부터 앞으로 이송의 수보다 작은 경우 정렬되는 전류를 나타내고, 그 다음 후방으로 이동 도착 [J]를 = 온도가 상기 삽입 위치에 해당하는 값을 나타낸다.
int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
int gap = 1,i,j;
int temp;
int len = arr.length;
for(i = 1;i < len;i++){
temp = arr[i];
for(j = i;j >= 1&&arr[j - 1] > temp;j -= 1){
arr[j] = arr[j - 1];
}
arr[j] = temp;
}| 평균 시간 복잡도 |
최상의 경우 |
최악의 경우 |
우주의 복잡성 |
| O (n²) |
O (N) |
O (n²) |
O (1) |
2, 힐 정렬
이진 각 갭 후 감소되고, 상술 한 동작 사이클;시 갭 = 1은 직접적인 삽입을 사용하여, 전체 어레이는 정렬의 정렬 직접 삽입하는 방법을 사용하여 각 그룹의 요소를 다음 단계에서 패킷의 간격을 정렬 할 정렬. )
실제로 직접 삽입 정렬 공정을 나타내는 힐 정렬 단계는 갭 된 두 개의 값이 1과 비교된다. 이것은 직접 삽입 정렬에 대한 최적화이다.
int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
int gap = 1,i,j;
int temp;
int len = arr.length;
while(gap < len /3){
gap = gap * 3 + 1;
}
for(;gap > 0; gap /= 3){
for(i = gap ; i < len;i++){
temp = arr[i];
for(j = i;j >= gap && arr[j - gap]> temp;j -= gap){
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
| 평균 시간 복잡도 |
최상의 경우 |
최악의 경우 |
우주의 복잡성 |
| O (nlog2 않음) |
O (nlog2 않음) |
O (nlog2 않음) |
O (1) |
둘째, 선택 정렬
1, 간단한 선택 정렬
이 알고리즘은 비교적 간단 가장 작은 값을 매번 찾아, 그리고 그의 이전의 첫 번째 첨자 1, 2 ..... arr.length-1 교환 저장.
int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
for(int i = 0;i < arr.length - 1;i++){
int min = i;
for(int j = i + 1;j < arr.length;j++){
if(arr[j] < arr[i]){
min = j;
}
}
if(min != i){
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}| O (n²) |
O (n²) |
O (n²) |
O (1) |
2, 힙 정렬
상단은 큰 힙입니다 더미에 모든 첫 번째 배열의 첫 번째. 그런 다음 각 다시, 상위 요소 heapify를 큰 위로 더미를 복용 통과. 전체 순서.
public static void main(String[] args) {
// int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
int[] arr = {2,5,3,1,10,4};
heap_sort(arr,arr.length);
for(int k = 0;k < arr.length;k++){
System.out.print(arr[k] + " ");
}
}
//通过堆排序，输出
public static void heap_sort(int[] arr,int len){
build_heapify(arr,len);
for(int i = len - 1;i >= 0; i--){
swap(arr,i,0);
heapify(arr,i,0);
}
}
//构建整个堆，每一个堆节点
public static void build_heapify(int[] arr,int len){
int last_node_index = len - 1;
int parent_index = (last_node_index - 1) / 2;
for(int i = parent_index;i >= 0;i--){
heapify(arr,len,i);
}
}
//对单个堆进行排序
public static void heapify(int []arr,int len,int i){
if(i >= len)
return ;
int left = i * 2 + 1;
int right = i * 2 + 2;
int max = i;
if(left < len && arr[max] < arr[left])
max = left;
if(right < len &&arr[max] < arr[right])
max = right;
if(max != i){
swap(arr,max,i);
heapify(arr,len,max);
}
}
public static void swap(int[] arr,int x,int y){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}| 평균 시간 복잡도 |
최상의 경우 |
최악의 경우 |
우주의 복잡성 |
| O (nlog2n) |
O (nlog2n) |
O (nlog2n) |
O (1) |
셋째, 교환 정렬
1, 거품 정렬
이 알고리즘은 마지막 위치에 상대적으로 간단하고 직접적인 최대 버블 링입니다.
for(int i = arr.length;i >= 0;i--){
for(int j = 0;j < i&& j + 1 < i;j++){
if (arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}| 평균 시간 복잡도 |
최상의 경우 |
최악의 경우 |
우주의 복잡성 |
| O (n²) |
O (N) |
O (n²) |
O (1) |
2, 빠른 정렬
빠른 정렬 버블 정렬이 아이디어의 최적화가이다 : 참조 값을 선택, 참조 값의 왼쪽은 그 값보다 적은 권리보다됩니다.
public static void quick_sort(int[] arr ,int low,int high){
if(arr.length < 0 || low > high)
return ;
int left = low;
int right = high;
//保存基准值
int temp = arr[left];
while(left < right){
//从后向前找到比基准小的元素
while(left < right && arr[right] >= temp){
right--;
}
arr[left] = arr[right];
//从前往后找到比基准大的元素
while(left < right && arr[left] <= temp){
left++;
}
arr[right] = arr[left];
}
arr[left] = temp;
quick_sort(arr,low,left - 1);
quick_sort(arr,left + 1,high);
}| O (nlog₂n) |
O (nlog₂n) |
O (n²) |
(재귀 분할 버전 대신) O (1) |
넷째, 병합 정렬
생각 :
. ① 각각의 인접한 두 개의 시퀀스 번호 (/ 2 N) 서열을 조작하는 층을 병합, 두 정렬 된 요소들을 포함하고 각각 서열;
. ② 상기 시퀀스가 다시 형성하도록 병합 A (N / 4) 층 시퀀스 네 개의 요소를 각각 포함하는 서열;
③. 단계를 반복은 ②, 모든 요소 정렬 될 때까지.
public static int[] mergingSort(int[] arr){
if(arr.length <= 1)
return arr;
int num = arr.length >> 1;
int[] arrLeft = Arrays.copyOfRange(arr,0,num);
int[] arrRight = Arrays.copyOfRange(arr,num,arr.length);
return mergeTwoArray(mergingSort(arrLeft),mergingSort(arrRight));
}
public static int[] mergeTwoArray(int[] arr1,int[] arr2){
int[] result = new int[arr1.length + arr2.length];
int i = 0,j = 0, k = 0;
while(i < arr1.length && j < arr2.length){
if(arr1[i] < arr2[j]){
result[k++] = arr1[i++];
}else{
result[k++] = arr2[j++];
}
}
while(i < arr1.length){
result[k++] = arr1[i++];
}
while(j < arr2.length){
result[k++] = arr2[j++];
}
return result;
}다섯째, 기수 정렬
생각의 버킷 종류의 사용
public static void radixSort(int[] arrays){
int max = findMax(arrays);
//遍历位数
for(int i = 1;max / i > 0;i *= 10){
int[][] buckets = new int[arrays.length][10];
//获取每一位数字(个、十、百、千位...分配到桶子里)
for(int j = 0;j < arrays.length;j++){
int num = (arrays[j] / i) % 10;
//将其放入桶子里
buckets[j][num] = arrays[j];
}
//回收桶子里的元素
int k = 0;
for(int j = 0;j < 10;j++){
for(int y = 0;y < arrays.length;y++){
if(buckets[y][j]!=0){
arrays[k++] = buckets[y][j];
}
}
}
}
}
public static int findMax(int[] arrays){
int max = 0;
for(int i = 0;i < arrays.length;i++){
if(arrays[i] > max){
max =arrays[i];
}
}
return max;
}
