各种排序算法的多语言实现（c++、java、python）

选择排序

选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。

首先是c++的实现

#include <iostream>
#include <vector>
using namespace std;
void selectsort(vector<int> &nums)
{
    for(int i = 0;i<nums.size();i++)
    {
        int min = i;
        for(int j = i+1;j<nums.size();j++)
        {
            if(nums[j]<nums[min])
                min = j;
        }
        swap(nums[min],nums[i]);
    }
}
int main()
{
    vector<int> test = {5,4,3,2,1};
    selectsort(test);
    for(int i = 0;i<test.size();i++)
        cout<<test[i]<<" ";
    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;i<a.length;i++)
        {
            int min = i;
            for(int j = i+1;j<a.length;j++){
                if(a[j]<a[min])
                    min = 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 <iostream>
#include <vector>
using namespace std;
void maopao(vector<int> &nums)
{
    bool hasSorted = false;
    for(int i = 0;i<nums.size()&&!hasSorted;i++)
    {
        hasSorted = true;
        for(int j = 0; j<nums.size()-i-1;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;i<test.size();i++)
        cout<<test[i]<<' ';
}

java

import java.util.Arrays;

public class Bubble {
    public static void bubble_sort(int [] a)
    {
        boolean hasSorted = false;
        for(int i = 0;i<a.length&&!hasSorted;i++)
        {
            hasSorted = true;
            for(int j = 0;j<a.length-1-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 <iostream>
#include <vector>
using namespace std;

void insert_sort(vector<int> &nums)
{
    for(int i = 1;i<nums.size();i++)
    {
        for(int j = i;j>0;j--)
        {
            if(nums[j]<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;i<test.size();i++)
        cout<<test[i]<<' ';
    return 0;
}

Java

import java.util.Arrays;

public class Insert_sort {
    public static void insert(int [] a)
    {
        for(int i = 1; i<a.length;i++)
        {
            for(int j = i;j>0;j--)
            {
                if(a[j]<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]<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 <iostream>
#include <vector>
using namespace std;


void shell(vector<int> &nums)
{
    int h = 1;
    while(h<nums.size()/3)
        h = 3*h+1;

    while(h>=1)
    {
        for (int i = h;i<nums.size();i++)
            for(int j = i;j>=h;j-=h)
            {
                if(nums[j]<nums[j-h])
                    swap(nums[j],nums[j-h]);
            }
        h = h/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;i<test.size();i++)
        cout<<test[i]<<' ';
}

Java

import java.util.Arrays;

public class Shell_sort {
    public static void shellsort(int a [])
    {
        int h = 1;
        while (h<a.length/3)
            h = 3*h+1;
        while (h>=1)
        {
            for(int i = h;i<a.length;i++)
                for(int j = i;j>=h;j-=h)
                {
                    if(a[j]<a[j-h])
                    {
                        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 <iostream>
using namespace std;
void merge(int arr[], int l, int mid, int r)

{
    int aux[r-l+1];
    for(int i = l; i<=r;i++)
       aux[i-l] = arr[i];

    int i = l;
    int j = mid+1;
    for(int k = l;k<=r;k++)
    {
        if(i > mid)
        {
            arr[k] = aux[j-l];
            j++;
        }
        else if(j>r)
        {
            arr[k] = aux[i-l];
            i++;
        }
        else if(aux[i-l]<aux[j-l])
        {
            arr[k] = aux[i-l];
            i++;
        }
        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<<nums[i]<<" ";
    }
    return 0;
}

快速排序

归并排序将数组分为两个子数组分别排序，并将有序的子数组归并使得整个数组排序；
快速排序通过一个切分元素将数组分为两个子数组，左子数组小于等于切分元素，右子数组大于等于切分元素，将这两个子数组排序也就将整个数组排序了。

C++

#include <iostream>
using namespace std;
int fun(int a[], int l, int r)
{
    int v = a[l];
    int j = l;
    for(int i = l+1; i<=r; i++)
    {
        if(a[i]<v)
        {
            swap(a[j+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<<a[i]<<" ";
    }
    return 0;
}