排序算法

稳定性是指相等的数仍然能保证原来的相对位置

1. 冒泡排序

• 算法步骤

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3. 针对所有的元素重复以上的步骤，最后一个元素定好了，不用进行比较了。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

• java代码实现

public class BubbleSort{
   public int[] sort(int[] sourceArray) throws Exception {
          // 1.对 arr 进行拷贝，不改变参数内容
       int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
		 //2.冒泡排序，外层进行n-1次排序
         for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                   flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
       return arr;
    }
}

• 特点

1. 时间复杂度为O(n*n)
2. 稳定排序

2.选择排序

• 算法步骤

1. a[0]和剩余元素比较，找到最小的，放到0位置；
2. a[1]和剩余元素比较（不包括已经排好的a[0]），找到第二小的，放到0位置；
3. 重复，直到所有的均排序完毕。

• java代码实现

//Java 代码实现
 public class SelectionSort  {
 	//1.复制数组
     public int[] sort(int[] sourceArray) throws Exception {
         int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
 
        // 外层总共要经过 N-1 轮比较
         for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            // 先从i+1的元素比较，一直比较到最后一位
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }
}

• 特点

1. 时间复杂度为O(n*n)
2. 不稳定排序

3.插入排序（类似冒泡排序，相邻的比较交换）

• 算法步骤

1. 下标为0的元素已经弄好了，确定要插入的元素（1到（n-1））
2. 调整包括他在内前面的所有元素是有序序列，找到第一个比他大的，然后交换位置（相当于把他插入到了最后一个位置，然后冒泡排序调整前面的为有序序列）

• java代码实现

        // 1.下标为0的位置已经调整好了，外层表示要插入的数的下标，从1到n-1
        //2.插入之前调整他前边所有的数已经是有序的
      for(int i = 1;i<arr.length;i++){
             for(int j = i-1;j>=0&&arr[j]>arr[j+1];j--){
                     swap(arr,j,j+1);
             }
         }
   

• 特点

1.最坏和平均时间复杂度是O(n*n)，最好的情况下时间复杂度是O(n)（前边已经排好序的情况下，直接跳出内层循环，插入的位置正确）
2.稳定排序

4.希尔排序