经典数据结构排序算法之Java实现

一、冒泡排序

算法分析：

(1)由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数

(2)冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，每进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

(3)时间复杂度

1、如果我们的数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。

2、如果很不幸我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

综上所述：冒泡排序总的平均时间复杂度为：O(n2) ,时间复杂度和数据状况无关。

/*冒泡排序*/
public class BubbleSort {
    public static void main(String[] args) {

        int arr[] = new int[]{1,5,6,2,9,7,8,4,3};
        bubbleSort(arr);
    }

    public static void bubbleSort(int arr[]){
        /*控制比较多少轮*/
        for (int i = 0; i < arr.length - 1; i++) {
            /*控制比较的次数*/
            for (int j=0;j<arr.length-1-i;j++){
                if(arr[j] >arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
}

二、直接插入排序

代码实现：

    //插入排序【稳定】
    public static int[] insertSort(int arr[]){
        for (int i = 1; i < arr.length ; i++) {
            for (int j = i; j > 0 ; j--) {
                if(arr[j] < arr[j-1]){
                    int temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }else {
                    break;
                }
            }
        }
        return arr;
    }

三、快速排序

原理:
   快速排序,说白了就是给基准数据找其正确索引位置的过程.
   如下图所示,假设最开始的基准数据为数组第一个元素23,则首先用一个临时变量去存储基准数据,即tmp=23;然后分别从数组的两端扫描数组，设两个指示标志:low指向起始位置，high指向末尾.
  
首先从后半部分开始，如果扫描到的值大于基准数据就让high减1,如果发现有元素比该基准数据的值小(如上图中18<=tmp)，就将high位置的值赋值给low位置 ,结果如下:
然后开始从前往后扫描,如果扫描到的值小于基准数据就让low加1,如果发现有元素大于基准数据的值(如上图46=>tmp)，就再将low位置的值赋值给high位置的值,指针移动并且数据交换后的结果如下:

然后再开始从后向前扫描,原理同上,发现上图11<=tmp,则将high位置的值赋值给low位置的值,结果如下:

然后再开始从前往后遍历,直到low=high结束循环,此时low或high的下标就是基准数据23在该数组中的正确索引位置.如下图所示.

  这样一遍走下来,可以很清楚的知道,其实快速排序的本质就是把基准数大的都放在基准数的右边,把比基准数小的放在基准数的左边,这样就找到了该数据在数组中的正确位置。然后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。
  

代码实现：

    public static void quickSort(int[] arr,int low,int high){
        int i,j,key;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        key = arr[low];

        while (i<j) {
            //先看右边，依次往左递减
            while (arr[j] > key && i<j) {
                j--;
            }
            if(i < j){
                arr[i] = arr[j];
                i++;
            }
            //再看左边，依次往右递增
            while (arr[i] < key &&i<j) {
                i++;
            }
            if(i < j){
                arr[j] = arr[i];
                j--;
            }
        }
        //此刻跳出循环说明 i=j，i下标左边的数比i下标对应的数小，右边的数比i对应的数大，递归调用快排
        //替换基准值
        arr[i] = key;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }

四、简单选择排序

选择排序的基本思想是：每一趟（例如第i趟）在后面的 n-i+1 个待排序元素中选取关键字最小的元素，作为有序子序列的第i个元素，直到第 n-1 趟做完，待排序元素只剩下一个，就不用再选了。

代码实现：

    //选择排序【不稳定】跳着比，交换
    public static int[] selectSort(int arr[]){
        for (int i = 0; i < arr.length - 1; i++) {
            int minIdx = i;
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[j] < arr[minIdx]){
                    minIdx = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIdx];
            arr[minIdx] = temp;
        }
        return arr;
    }

五、希尔排序

按照增量对数据进行分组，对每一组进行直接插入排序，每一趟排完后增量减半。

代码实现：

public class ShellSort {

    public static void main(String[] args) {

        int arr[] = new int[]{2,5,6,8,9,7,4,3,1,0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int arr[]){

        //遍历所有步长
        for(int d=arr.length/2; d>0; d/=2){
            //遍历所有的元素
            for (int i = d; i < arr.length; i++) {
                //如果当前数字比前d个数字小
                if(arr[i] < arr[i-d]){
                    //把当前数字存起来
                    int temp = arr[i];
                    int j;
                    for(j=i-d;j>=0;j-=d){
                        if(arr[j] > temp){
                            //把前一个数字赋给后一个数字
                            arr[j+d] = arr[j];
                        }else {
                            break;
                        }
                    }
                    //把临时遍历(外层for循环的当前元素)赋值给不满足条件的后一个元素
                    arr[j+d] = temp;
                }
            }
            System.out.println(d);
            System.out.println(Arrays.toString(arr));
        }
    }
}

六、堆排序

(1) 定义heapify操作
(2)构建堆：从最后一个父节点到根节点不断heapify
(3)堆排序：将根节点和最后一个节点交换，"砍掉"最后一个节点，并对根节点再次heapify

public class HeapSort {
    public static void main(String[] args) {
        int[] tree = new int[]{2,5,10,1,3,4};
        heap_sort(tree,tree.length);
        for(int i : tree){
            System.out.print(i + " ");
        }
    }

    public static void heapify(int[] tree, int n, int i){
        if(i >= n) return;
        int c1 = 2 * i + 1;
        int c2 = 2 * i + 2;
        int max = i;
        if(c1 < n && tree[c1] > tree[max]){
            max = c1;
        }
        if(c2 < n && tree[c2] > tree[max]){
            max = c2;
        }
        if(max != i){
            swap(tree,max,i);
            heapify(tree,n,max);
        }
    }

    public static void buildHeap(int[] tree,int n){
        //从最后一个父节点开始---> 0 一直heapify
        int last_node = n - 1;
        int last_parent = (last_node - 1) / 2;
        for (int i = last_parent; i >= 0; i--) {
            heapify(tree,n,i);
        }
    }

    public static void heap_sort(int[] tree,int n){
        buildHeap(tree,n);
        for (int i = n-1; i >= 0 ; i--) {
            //最后一个节点和根节点(编号为0)交换
            swap(tree,i,0);
            //交换完成后继续对根节点树化操作
            heapify(tree,i,0);
        }
    }

    private static void swap(int[] tree, int i, int j) {
        int temp = tree[i];
        tree[i] = tree[j];
        tree[j] = temp;
    }
}

参考文献：排序算法