1. Tri à bulles
-
Principe: Dans un intervalle désordonné, en comparant des nombres adjacents, faites remonter le plus grand nombre jusqu'à la fin de l'intervalle désordonné et continuez ce processus jusqu'à ce que le tableau soit ordonné dans son ensemble.
-
Stabilité (stable)
1. Une séquence stable peut devenir une séquence instable
2. Une séquence stable ne peut pas devenir stable; -
Complexité spatiale: O (1)
-
Complexité temporelle: meilleur cas O (n); pire cas O (n ^ 2)
//冒泡排序
public static void bubbleSort(int[] arr){
for (int i = 0;i < arr.length-1;i++){
//控制冒泡次数
for(int j = 0;j < arr.length-1-i;j++){
if (arr[j] > arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
2. Tri rapide
- Principe:
1. Sélectionnez un nombre de l'intervalle à trier comme pivot;
2. Partition: parcourez tout l'intervalle à trier, et placez une valeur plus petite que le repère (qui peut contenir égal) à gauche de la valeur de référence , et comparez La valeur de référence la plus grande (qui peut inclure des valeurs égales) est placée sur le côté droit de la valeur de référence;
3. En utilisant l'idée de division et de conquête, les cellules gauche et droite sont traitées de la même manière jusqu'à la longueur entre les cellules == 1, ce qui signifie qu'il est dans l'ordre. Ou la longueur entre les cellules == 0, ce qui signifie qu'il n'y a pas de données. - Stabilité (instable)
1. Un tri stable peut devenir un tri instable;
2. Une personne intrinsèquement instable ne peut pas devenir stable;
- Complexité spatiale: O (log2n)
- Complexité temporelle: Degré: O (n * logn)
//快速排序
public static void quicksort(int[] arr){
quick(arr,0,arr.length-1);
}
//排序
public static void quick(int[] arr,int low,int high){
if(low > high){
return;
}
//par是基准
int par = parttion(arr,low,high);
quick(arr,low,par-1);
quick(arr,par+1,high);
}
//划分函数
public static int parttion(int[] arr,int start,int end){
//申请一个tmp空间用来放基准的值(基准一般选择的是边上的值)
int tmp = arr[start];//这里取的是最左边的值，那么一会就先从最右边开始找[end]位置
while(start < end){
while(start < end && arr[end] >= tmp){
end--;
}
//到了这里，从while出来有俩种情况，不满足start < end或者不满足arr[end] >= tmp
if (start >= end){
//arr[start] = tmp;
break;//直接退出，因为已经遍历完毕
}else{
//else就是arr[end] < tmp
arr[start] = arr[end];
}
while(start < end && arr[start] <= tmp){
start++;
}
//到了这里，同样从while出来有俩种情况，不满足start < end或者不满足arr[start] <= tmp
if (start > end){
//arr[end] = tmp;
break;
}else{
arr[end] = arr[start];
}
}
arr[start] = tmp;
return start;//返回基准移动到位置，这样基准的左边全小于它，右边全都大于它
3. Test de résultat
public class TestSort {
//冒泡排序
public static void bubbleSort(int[] arr){
for (int i = 0;i < arr.length-1;i++){
//控制冒泡次数
for(int j = 0;j < arr.length-1-i;j++){
if (arr[j] > arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
//快速排序
public static void quicksort(int[] arr){
quick(arr,0,arr.length-1);
}
//排序
public static void quick(int[] arr,int low,int high){
if(low > high){
return;
}
//par是基准
int par = parttion(arr,low,high);
quick(arr,low,par-1);
quick(arr,par+1,high);
}
//划分函数
public static int parttion(int[] arr,int start,int end){
//申请一个tmp空间用来放基准的值(基准一般选择的是边上的值)
int tmp = arr[start];//这里取的是最左边的值，那么一会就先从最右边开始找[end]位置
while(start < end){
while(start < end && arr[end] >= tmp){
end--;
}
//到了这里，从while出来有俩种情况，不满足start < end或者不满足arr[end] >= tmp
if (start >= end){
//arr[start] = tmp;
break;//直接退出，因为已经遍历完毕
}else{
//else就是arr[end] < tmp
arr[start] = arr[end];
}
while(start < end && arr[start] <= tmp){
start++;
}
//到了这里，同样从while出来有俩种情况，不满足start < end或者不满足arr[start] <= tmp
if (start > end){
//arr[end] = tmp;
break;
}else{
arr[end] = arr[start];
}
}
arr[start] = tmp;
return start;//返回基准移动到位置，这样基准的左边全小于它，右边全都大于它
}
//测试main方法
public static void main(String[] args) {
//冒泡排序
int[] arr3 = {
7,4,9,34,0,8,5,22,55,6,12,33,56,89,77};
bubbleSort(arr3);
System.out.print("冒泡排序结果: ");
for (int i = 0;i < arr3.length;i++){
System.out.print(arr3[i]+" ");
}
//快速排序
int[] arr5 = {
7,4,9,34,0,8,5,22,55,6,12,33,56,89,77};
quicksort(arr5);
System.out.print("快速排序结果: ");
for (int i = 0;i < arr5.length;i++){
System.out.print(arr5[i]+" ");
}
}
