数据结构中的几种排序算法

1.冒泡排序

原理：

重复地走访过要排序的数列，一次比较两个元素如果他们顺序错误就把他们交换过来。

代码实现：

public class demo {
    void swap(int a[],int i,int j){
        int temp  = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    //冒泡
    void BubbleSort(int a[],int size){
        for(int i=0;i<size;++i){
            for(int j=0;j<size-i-1;++j){
                if(a[j]<a[j+1]){
                    swap(a, j, j+1);
                }
            }
        }
    }
}

2.选择排序

a 首先在未排序序列中找到最小元素，存放到排序序列的起始位置，

b 再从未排序元素中继续寻找最小元素，然后放到排序序列尾

c 依次类推

代码实现：

public class demo {
    //选择排序
    void SelectSort(int a[],int size){
        for(int i=0;i<size-1;++i)
        {
            int min = i;
            for(int j=i+1;j<size-1;++j)
            {
                if(a[j]<a[min])
                    min  = j;
            }
            if(min!=i)
                swap(a,min,i);
        }
    }
    void swap(int a[],int i,int j){
         a[i] = a[i]^a[j];
         a[j] = a[i]^a[j];
         a[i] = a[i]^a[j];
    }
}

稳定性:考虑序列[3 4 4 1],第一次选择1与3交换位置序列变为[1 4 4 3],第二次选择3与第一个4交换位置,此时已是升序不会再交换,原本第一个4却插在了第二个4的后面，因此不稳定

3.快速排序

步骤:

1.选择中心元素

2.重新排列数组，将比中心元素小的放在左边，比中心元素大的放在右边。

3.再次分别为左子部分和右子部分选择了中心元素，并且重复步骤2，子数组被分割，直到每个子数组只有一个元素，至此，该数组已经通过快速排序算法升序排好序了。

代码实现：

public class QuickSort {

public static int partition(int[] array, int low, int high) {
    // 取最后一个元素作为中心元素
    int pivot = array[high];
    // 定义指向比中心元素大的指针，首先指向第一个元素
    int pointer = low;
    // 遍历数组中的所有元素，将比中心元素大的放在右边，比中心元素小的放在左边
    for (int i = low; i < high; i++) {
        if (array[i] <= pivot) {
            // 将比中心元素小的元素和指针指向的元素交换位置
            // 如果第一个元素比中心元素小，这里就是自己和自己交换位置，指针和索引都向下一位移动
            // 如果元素比中心元素大，索引向下移动，指针指向这个较大的元素，直到找到比中心元素小的元素，并交换位置，指针向下移动
            int temp = array[i];
            array[i] = array[pointer];
            array[pointer] = temp;
            pointer++;
        }
        System.out.println(Arrays.toString(array));
    }
    // 将中心元素和指针指向的元素交换位置
    int temp = array[pointer ];
    array[pointer] = array[high];
    array[high] = temp;
    return pointer;
}

public static void quickSort(int[] array, int low, int high) {
    if (low < high) {
        // 获取划分子数组的位置
        int position = partition(array, low, high);
        // 左子数组递归调用
        quickSort(array, low, position -1);
        // 右子数组递归调用
        quickSort(array, position + 1, high);
    }
}

public static void main(String[] args) {
    int[] array = {6,72,113,11,23};
    quickSort(array, 0, array.length -1);
    System.out.println("排序后的结果");
    System.out.println(Arrays.toString(array));
}

}

空间复杂度

O(log n)

4.插入排序

步骤：

a 从第一个元素开始，该元素可以认为已经被排序

b 取出下一个元素 在已经排序的元素序列中从后向前扫描

c 如果该元素(已排序)大于新元素，将该元素移到下一位置

d 重复c步骤直到找到已排序的元素小于或者等于新元素的位置

e 将新元素插入到该位置

f 重复步骤b

代码：

public class demo {
    void Insert(int a[],int size)
    {
        for (int i = 0; i < size; i++) {
            int get = a[i];
            int j = i-1;
            while(j>0&&a[j]>get)
            {
                a[j+1] = a[j];
                j--;
            }
            a[j+1] = get;
        }
    }
}

5.归并排序

采用分治法()

基本思想：

1）将已经有序的子序列合并，得到完全有序的序列，

2）先使每个子序列有序，再使子序列段间有序

3）若将两个有序表合并成一个有序表称为二路归并

6.希尔排序

增量排序，又叫递减增量排序，也是直接插入排序算法的一种高效的改进版本 是不稳定的

基本思想 ：

将元素进行同余分组，比如元素个数有8个，若将其分为d1=4组，即每一个元素的下标进行模3运算，下标{0,4}模4余数都为0为一组，{1,5}余1 为一组，{2,6}余2为一组，{3,7}余3为一组，当然这只是一种逻辑上的划分，并不是物理上对其进行切分。然后在各组内进行直接插入排序，排序完再对其进行分组，一般取d(i+1) = ⌊d(i)/2⌋，此时的话d2=⌊d1/2⌋= 2组，就这样一直分组排序到di = 1并插入排序结束

几种排序算法的比较：