排序算法总结与java实现

默认假设从小到大排序~

 

1.选择排序 

基本思想就是第i次选择出第i小的，放在第i个位置。

随着 i 逐渐增大，比较的次数越来越少，比较次数是固定的： 1 + 2 + 3 + …. + n = n * (n + 1) / 2  由此可以推出，选择排序的时间复杂度和空间复杂度分别为 O(n² ) 和 O(1) （选择排序只需要一个额外空间用于数组元素交换）。

java代码：

// 选择排序法，效率 O（n²）,适用于排序小列表。
static void selectSortArray() {
int min_index = Integer.MIN_VALUE;
for (int i = 0; i < a.length; i++) {
min_index = i;
for (int j = i; j < a.length; j++) {
if (a[j] < a[min_index]) {
min_index = j;
}
}
int temp = a[i];
a[i] = a[min_index];
a[min_index] = temp;
}
}

2.插入排序

基本思想就是假设第i个前面i-1个都已经排好序了，将第i个插入前面有序的列表中合适的地方。

java代码：

// 插入排序，最佳效率O（n）；最糟效率O（n²）与冒泡、选择相同，适用于排序小列表 。若列表基本有序，则插入排序比冒泡、选择更有效率。

static void InsertSortArray() {
for (int i = 1; i < a.length; i++)// 循环从第二个数组元素开始，因为arr[0]作为最初已排序部分
{
int temp = a[i];// temp标记为未排序第一个元素
int j = i - 1;
while (j >= 0 && a[j] > temp)/* 将temp与已排序元素从小到大比较，寻找temp应插入的位置 */
{
a[j + 1] = a[j];
j--;
}
a[j + 1] = temp;
}
}

3.冒泡排序

冒泡排序基本思想是每次循环将“最轻的”像冒泡一样浮到水面上。

实现方法很简单，两层 for 循环，里层循环中判断相邻两个元素是否逆序，是的话将两个元素交换，外层循环一次，就能将数组中剩下的元素中最小的元素“浮”到最前面，所以称之为冒泡排序。

static void bubbleSortArray() {
int length = a.length;

for (int i = 0; i < length; i++) {

boolean haveExchange = false;//内层循环如果为false就可以结束迭代了
for (int j = length - 1; j > i; j--) {
if (a[j] < a[j - 1]) {
haveExchange = true;
int temp = a[j];
a[j] = a[j - 1];
a[j - 1] = temp;
}
}
if (haveExchange = false) {
return;
}
}
}

 

4.希尔排序

希尔排序的基本思想是将一个大的数组“分而治之”，希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大。

static void shellSortArray() {
  for (int incr = 3; incr < 0; incr--)// 增量递减，以增量3，2，1为例
  {
   for (int L = 0; L < (a.length - 1) / incr; L++)// 重复分成的每个子列表
   {
    for (int i = L + incr; i < a.length; i += incr)// 对每个子列表应用插入排序
    {
     int temp = a[i];
     int j = i - incr;
     while (j >= 0 && a[j] > temp) {
      a[j + incr] = a[j];
      j -= incr;
     }
     a[j + incr] = temp;
    }
   }
  }
 }