java学习总结篇二--3 种简单排序

本篇文章，先从数据结构开始，一边总结，一边反思，寻求最优解。

本文简单温习下最基础的三类算法：选择，冒泡，插入。先定义一个交换数组作为备用：

/**

* 交换数组元素

* @param arr

* @param a

* @param b

*/

public static void swap(int []arr,int a, int b){

arr[a] = arr[a] + arr[b];

arr[b] = arr[a] - arr[b];

arr[a] = arr[a] - arr[b];

}

注意：以下排序均为从小到大排序

1.简单选择排序

选择排序包括简单选择排序和堆排序，这里先介绍简单选择排序。

简单选择排序的基本思想：假设排序表为L[1...n],第i趟排序即从L[i...n]中选择关键字最小的元素与L(i)交换，每一趟排序可以确定一个元素的最终位置，这样经过n-1趟排序就可以使整个排序表有序。

简单选择排序算法的java代码实现如下：

/**

* 简单选择排序

* @param A

* @param n

*/

public static void selectSort(int A[],int n){

        for(int i=0;i<n-1;i++){      //一共进行n-1趟

             int min = i;             //记录最小元素的值

             for(int j=i+1;j<n;j++){  //在A[i...n-1]中选择最小的元素

                  if(A[j]<A[min]){     //更新最小元素位置

min = j;

}

}

             if(min!=i){

                 swap(A,i,min);       //与第i个位置交换

}

}

}

简单选择排序的性能分析如下：

空间效率：仅使用常数个辅助单元，故而空间效率为O(1)。

时间效率：从以上代码可以看出，元素移动的次数很少，但元素间的比较次数与序列的初始状态无关，始终是n(n-1)/2次，所以时间复杂度始终是O(n∧2).

稳定性：在第i趟找到最小元素后，和第i个元素交换，可能会导致第i个元素与其含有相同关键字元素的相对位置发生改变。因此，简单选择排序是不稳定的排序方法。

2.冒泡排序

    冒泡排序是交换排序的一种，交换排序还包括快速排序（以后再介绍）。

冒泡排序的基本思想是，对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序。

冒泡排序算法的java代码实现如下：

/**

* 冒泡排序

* @param A

* @param n

*/

public static void bubbleSort(int A[],int n){

       for(int i=0;i<n-1;i++){

             boolean flag = false;    //表示本趟冒泡是否发生交换的标志

             for(int j=n-1;j>i;j--){  //一趟冒泡过程

                   if(A[j-1]>A[j]){     //若为逆序

                        swap(A,j-1,j);   //交换

flag = true;

}

              if(flag == false){

                   return;          //本趟遍历后没有发生交换，说明表已经有序

}

}

}

}

冒泡排序的性能分析如下：

空间效率：仅使用常数个辅助单元，故而空间效率为O(1)。

时间效率：时间复杂度始终是O(n∧2).（老生常谈了，具体过程就不赘述了）

稳定性：由于当i>j且A[i]=A[j]时,不会交换两个元素，从而冒泡排序是一个稳定的排序方法。

3.直接插入排序

插入排序包括直接插入排序，折半插入排序和希尔排序，这里先介绍直接插入排序。

直接插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。

直接插入排序算法的java代码实现如下：

/**

* 插入排序

*

* @param arr

*/

public static void insertionSort(int[] arr,int n) {

for (int i = 1; i < n; i++) {

int j = i;

while (j > 0 && arr[j] < arr[j - 1]) {

swap(arr,j,j-1);

j--;

}

}

}

直接插入的性能分析如下：

空间效率：仅使用常数个辅助单元，故而空间效率为O(1)。

时间效率：时间复杂度始终是O(n∧2).

稳定性：由于当i>j且A[i]=A[j]时,不会交换两个元素，从而直接插入排序是一个稳定的排序方法。