各种排序算法的多语言实现（c++、java、python）
选择排序
选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
首先是c++的实现
#include int min = i;
for(int j = i+1;jif(nums[j]int main()
{
vector<int> test = {5,4,3,2,1};
selectsort(test);
for(int i = 0;icout<" ";
return 0;
} Java版本
import java.lang.reflect.Array;
import java.util.Arrays;
public class Select_sort {
public static void selectsort(int [] a){
for(int i = 0;iint min = i;
for(int j = i+1;jif(a[j]int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
public static void main(String[] args)
{
int a[] = {49,38,65,97,76};
selectsort(a);
System.out.println(Arrays.toString(a));
}
} python版本
def select_sort(a):
for i in range(0,len(a)-1):
index = i
for j in range(i+1,len(a)):
if a[index] > a[j]:
index = j
a[i],a[index] = a[index],a[i]
return a
if __name__ == '__main__':
a = [3,4,5,1,2,6,9,0,8]
select_sort(a)
print(a)冒泡排序
通过从左到右不断交换相邻逆序的相邻元素，在一轮的交换之后，可以让未排序的元素上浮到最右侧，是的右侧是已排序的。在一轮交换中，如果没有发生交换，就说明数组已经是有序的，此时可以直接退出
c++
#include true;
for(int j = 0; j1;j++)
{
if(nums[j+1]>nums[j])
{
hasSorted = false;
swap(nums[j+1],nums[j]);
}
}
}
}
int main()
{
vector<int> test = {3,2,5,4,1};
maopao(test);
for(int i = 0;icout<' ';
} java
import java.util.Arrays;
public class Bubble {
public static void bubble_sort(int [] a)
{
boolean hasSorted = false;
for(int i = 0;itrue;
for(int j = 0;j1-i;j++)
{
if(a[j]>a[j+1])
{
hasSorted = true;
int temp;
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
public static void main(String[] args)
{
int a[] = {49,38,65,97,76};
bubble_sort(a);
System.out.println(Arrays.toString(a));
}
}
python
def bubble(a):
for i in range(len(a)):
for j in range(len(a)-1-i):
if(a[j]>a[j+1]):
a[j],a[j+1] = a[j+1],a[j]
return a
if __name__ == '__main__':
a = [2,4,3,5,7,6,8]
bubble(a)
print(a)插入排序
插入排序从左到右进行，每次都将当前元素插入到左侧已经排序的数组中，使得插入之后左部数组依然有序。
第 j 元素是通过不断向左比较并交换来实现插入过程：当第 j 元素小于第 j - 1 元素，就将它们的位置交换，然后令 j 指针向左移动一个位置，不断进行以上操作。
C++
#include for(int j = i;j>0;j--)
{
if(nums[j]1])
swap(nums[j],nums[j-1]);
}
}
}
int main()
{
vector<int> test = {3,2,4,6,5,1};
insert_sort(test);
for(int i = 0;icout<' ';
return 0;
} Java
import java.util.Arrays;
public class Insert_sort {
public static void insert(int [] a)
{
for(int i = 1; ifor(int j = i;j>0;j--)
{
if(a[j]1])
{
int temp;
temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
}
}
public static void main(String[] args)
{
int a[] = {49,38,65,97,76};
insert(a);
System.out.println(Arrays.toString(a));
}
}
Python
def insertsort(a):
for i in range(1,len(a)):
j = i
while j>0:
if a[j]1]:
a[j],a[j-1] = a[j-1],a[j]
j = j-1
return a
if __name__ == '__main__':
a = [5,7,4,3,1,3]
print(insertsort(a)) 希尔排序
对于大规模的数组，插入排序很慢，因为它只能交换相邻的元素，每次只能将逆序数量减少 1。
希尔排序的出现就是为了改进插入排序的这种局限性，它通过交换不相邻的元素，每次可以将逆序数量减少大于 1。
希尔排序使用插入排序对间隔 h 的序列进行排序。通过不断减小 h，最后令 h=1，就可以使得整个数组是有序的。
C++
#include 3)
h = 3*h+1;
while(h>=1)
{
for (int i = h;ifor(int j = i;j>=h;j-=h)
{
if(nums[j]3;
}
}
int main()
{
vector<int> test = {2,3,4,5,6,7,9,8,6,4,32,12,45,67,89,76,32,21};
shell(test);
for(int i = 0;icout<' ';
} Java
import java.util.Arrays;
public class Shell_sort {
public static void shellsort(int a [])
{
int h = 1;
while (h3)
h = 3*h+1;
while (h>=1)
{
for(int i = h;ifor(int j = i;j>=h;j-=h)
{
if(a[j]int temp;
temp = a[j];
a[j] = a[j-h];
a[j-h] = temp;
}
}
h = h/3;
}
}
public static void main(String[] args)
{
int a[] = {49,38,65,97,76,12,32,24,11,34,56,72,46,28};
shellsort(a);
System.out.println(Arrays.toString(a));
}
} 归并排序
归并排序的思想是将数组分成两部分，分别进行排序，然后归并起来。
Java版
import java.util.Arrays;
public class Mergesort {
private static Comparable[] aux;
private static void merge(Comparable[] a, int l, int m, int r)
{
int i = l;
int j = m+1;
for(int k = l;k<=r;k++)
{
aux[k] = a[k];
}
for(int k = l;k<=r;k++)
{
if(i>m)
{
a[k] = aux[j];
j++;
}
else if(j>r)
{
a[k] = aux[i];
i++;
}
else if(aux[i].compareTo(a[j]) <= 0)
{
a[k] = aux[i];
i++;
}
else
{
a[k] = aux[j];
j++;
}
}
}
public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}
public static void sort(Comparable[] a,int l, int r)
{
if(l>=r)
return;
int mid = (l+r)/2;
sort(a,l,mid);
sort(a,mid+1,r);
merge(a,l,mid,r);
}
public static void main(String[] args)
{
Comparable[] a = {49,38,65,97,76,12,32,24,11,34,56,72,46,28};
sort(a);
System.out.println(Arrays.toString(a));
}
}C++
#include else
{
arr[k] = aux[j-l];
j++;
}
}
}
void fun(int arr[], int l, int r)
{
if(l>=r)
return;
int mid = (l+r)/2;
fun(arr,l,mid);
fun(arr,mid+1,r);
merge(arr,l,mid,r);
}
void mergeSort(int arr[], int n)
{
fun(arr, 0, n-1);
}
int main()
{
int nums[] = {1,3,4,5,2,7,8,10,9,6};
mergeSort(nums,10);
for(int i = 0;i<10;i++)
{
cout<" ";
}
return 0;
} 快速排序
归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。
C++
#include 1],a[i]);
j++;
}
}
swap(a[j],a[l]);
return j;
}
void quicksort(int a[], int l, int r)
{
if(l>=r)
return;
int d = fun(a,l,r);
quicksort(a,l,d-1);
quicksort(a,d+1,r);
}
void quickSort(int a[], int n)
{
quicksort(a,0,n-1);
}
int main()
{
int a[5] = {2,1,4,5,3};
quickSort(a,5);
for(int i = 0;i<5;i++)
{
cout<" ";
}
return 0;
}