排序算法

排序算法有很多种， 本文简单说下比较常见的排序算法。

一、简单选择排序

原理：遍历n-1次数据， 每次挑选出剩余元素的最小值， 最后得到一个排好序的数组。

平均复杂度： O(n^2)

二、冒泡排序

原理：像冒泡一样， 相邻两个元素小的往上浮，大的往下符， 两两交换， 一轮下来每次能确定最大值。 

相比选择排序： 它可以提前结束循环， 当一轮下来发现没有元素交换的时候， 这时候数组已经是有序的不需要继续循环处理了。

平均复杂度：O(n^2)

三、归并排序

原理：把数据递归分成两堆， 分别排序，  合并两堆的结果。 

平均复杂度: O(nlogn)

四、快速排序

原理：可以看做归并排序的一种进化。 为了不要合并两堆的结果（合并主要是调整两堆元素的位置），开始时候就已经计算好元素的位置。

平均复杂度：O(nlogn)

相关的代码如下:

package com.my.test;

import java.util.ArrayList;
import java.util.List;

public class Sort {
    
    public void simpleSort(int [] elements) {
        
        int elementsSize = elements.length;
        
        for(int i = 0; i < elementsSize - 1; i++) {
            for(int j = i + 1; j < elementsSize; j++) {
                if(elements[j] < elements[i]) {
                    int tmp = elements[i];
                    elements[i] = elements[j];
                    elements[j] = tmp;
                }
            }
        }
    }
    
    public void bubbleSort(int [] elements) {
        
        int elementsSize = elements.length;
        
        for(int i = 0; i < elementsSize - 1; i++) {
            
            boolean isAlreadyOrdered = true;
            
            for(int j = 0; j < elementsSize - 1 - i ; j++) {
                if(elements[j + 1] < elements[j]) {
                    int tmp = elements[j];
                    elements[j] = elements[j + 1];
                    elements[j + 1] = tmp;
                    isAlreadyOrdered = false;
                }
            }
            
            if(isAlreadyOrdered) {
                break;
            }
        }
    }
    
    public void mergeSort(int [] elements) {
        mergeSortIter(elements, 0, elements.length - 1);
    }
    
    public void mergeSortIter(int [] elements, int beginIndex, int endIndex) {
        if(endIndex <= beginIndex)
            return ;
        int middleIndex = beginIndex + (endIndex - beginIndex) / 2;
        mergeSortIter(elements, beginIndex, middleIndex - 1);
        mergeSortIter(elements, middleIndex + 1, endIndex);
        merge(elements, beginIndex, middleIndex, middleIndex, endIndex);
    }
    
    public void merge(int [] elements, int beginIndex1, int endIndex1, int beginIndex2, int endIndex2) {
        
        List<Integer> tempElements = new ArrayList<Integer>();
        
        int len = endIndex1 - beginIndex1 + endIndex2 - beginIndex2;
        int writeIndex = beginIndex1;
        
        for(int i = 0; i < len; i++) {
            if(beginIndex1 == endIndex1) {
                while(beginIndex2 < endIndex2) {
                    tempElements.add(elements[beginIndex2]);
                    beginIndex2++;
                }
                break;
            } else if(beginIndex2 == endIndex2) {
                while(beginIndex1 < endIndex1) {
                    tempElements.add(elements[beginIndex1]);
                    beginIndex1++;
                }
                break;
            } 
            
            //左边的比较小， 取左边的
            if(elements[beginIndex1] <= elements[beginIndex2]) {
                tempElements.add(elements[beginIndex1]);
                beginIndex1++;
            } else {
                tempElements.add(elements[beginIndex2]);
                beginIndex2++;
            }
        }
        
        for(Integer tempElement: tempElements) {
            elements[writeIndex++] = tempElement;
        }
    }
    
    public void quickSort(int [] elements) {
        quickSortIter(elements, 0, elements.length - 1);
    }
    
    private int partition(int [] elements, int leftIndex, int rightIndex) {
        
        int referValue = elements[leftIndex];
        
        while (true) {
            while (elements[rightIndex] > referValue) {
                rightIndex--;
            }
            
            while (elements[leftIndex] < referValue) {
                leftIndex++;
            }
            
            if (leftIndex >= rightIndex) {
                break;
            }
            
            int temp = elements[leftIndex];
            elements[leftIndex] = elements[rightIndex];
            elements[rightIndex] = temp;
        }
        return leftIndex;
    }
    
    public void quickSortIter(int [] elements, int leftIndex, int rightIndex) {
        
        if(rightIndex <= leftIndex)
            return ;
        
        int partIndex = partition(elements, leftIndex, rightIndex);        
        quickSortIter(elements, leftIndex, partIndex - 1);
        quickSortIter(elements, partIndex + 1, rightIndex);
    }
    
    public static void main(String[] args) {
        int [] elements = {1, 9, 2, 3, 4, 5, 6, 7, 8, 0};
        //List<Integer> elements = Arrays.asList(1, 8, 5, 3, 4, 2, 6, 7, 9);
        Sort sort = new Sort();
        //sort.simpleSort(elements);
        //sort.bubbleSort(elements);
        //sort.mergeSort(elements);
        sort.quickSort(elements);
        for(int element: elements) {
            System.out.println(element);
        }
    }
}