基本排序算法总结

参考博客：传送门

目录

各排序时间复杂度

冒泡排序

选择排序

插入排序

希尔算法

堆排序

---

各排序时间复杂度

冒泡排序

	/**
	     * 冒泡排序
	     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
	     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  
	     * 针对所有的元素重复以上的步骤，除了最后一个。
	     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 
     * @param numbers 需要排序的整型数组
     */
	public static void bubbleSort(int[] numbers){
		int temp = 0;
		int size = numbers.length;
		for(int i = 0 ; i < size-1; i ++) {
			for(int j = 0 ;j < size-1-i ; j++){
			    if(numbers[j] > numbers[j+1]) {
				    temp = numbers[j];
				    numbers[j] = numbers[j+1];
				    numbers[j+1] = temp;
			    }
			}
		}
	}

选择排序

基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

	/**
	     * 选择排序算法
	     * 在未排序序列中找到最小元素，存放到排序序列的起始位置  
	     * 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。 
	     * 以此类推，直到所有元素均排序完毕。 
     * @param numbers
     */
	public static void selectSort(int[] numbers) {
		int size = numbers.length; //数组长度
		int temp = 0 ; //中间变量
		
		for(int i = 0 ; i < size ; i++) {
			int k = i;   //待确定的位置
			//选择出应该在第i个位置的数
			for(int j = size -1 ; j > i ; j--) {
				if(numbers[j] < numbers[k]) {
				    k = j;
				}
			}
			//交换两个数
			temp = numbers[i];
			numbers[i] = numbers[k];
			numbers[k] = temp;
		}
	}

插入排序

基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。

	/**  
	     * 插入排序
	     * 从第一个元素开始，该元素可以认为已经被排序
	     * 取出下一个元素，在已经排序的元素序列中从后向前扫描 
	     * 如果该元素（已排序）大于新元素，将该元素移到下一位置  
	     * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置  
	     * 将新元素插入到该位置中  
	     * 重复步骤2  
     * @param numbers  待排序数组
     */  
	public static void insertSort(int[] numbers) {
		int size = numbers.length;
		int temp = 0 ;
		int j =  0;
		
		for(int i = 0 ; i < size ; i++) {
		    temp = numbers[i];
		    //假如temp比前面的值小，则将前面的值后移
		    for(j = i ; j > 0 && temp < numbers[j-1] ; j --) {
		    	numbers[j] = numbers[j-1];
		    }
		    numbers[j] = temp;
		}
	}

希尔算法

	/**希尔排序的原理:
	 * 根据需求，如果你想要结果从大到小排列，
	 * 它会首先将数组进行分组，然后将较大值移到前面，较小值移到后面，
	 * 最后将整个数组进行插入排序，这样比起一开始就用插入排序减少了数据交换和移动的次数，
	 * 可以说希尔排序是加强版的插入排序
	 * 拿数组5, 2, 8, 9, 1, 3，4来说，数组长度为7，当increment为3时，数组分为两个序列 5，2，8和9，1，3，4，
	 * 第一次排序，9和5比较，1和2比较，3和8比较，4和比其下标值小increment的数组值相比较
	 * 此例子是按照从大到小排列，所以大的会排在前面，第一次排序后数组为9, 2, 8, 5, 1, 3，4
	 * 第一次后increment的值变为3/2=1,此时对数组进行插入排序，
	 *实现数组从大到小排
	 */

	public static void shellSort(int[] data) {
		int j = 0;
		int temp = 0;
		//每次将步长缩短为原来的一半
		for (int increment = data.length / 2; increment > 0; increment /= 2) {
			for (int i = increment; i < data.length; i++) {
			    temp = data[i];
			    for (j = i; j >= increment; j -= increment) {
			    	//如想从小到大排只需修改这里
				    if(temp > data[j - increment]) {   
				        data[j] = data[j - increment];
				    } else {
				        break;
				    }
			    } 
			    data[j] = temp;
			}
		}
	}

堆排序

/**
 * 堆排序
 * 从序列最后一个元素开始建堆（到第2个元素停止），然后不断跟第 1 个元素交换位置。
 * 建堆：从当前节点的父节点开始（往前不断遍历“父节点”）；
 * 当此节点存在子节点时，从两个（或一个 ）子节点中找到最大的下标。
 * 然后跟当前父节点交换位置，再把当前最大子节点的下标设置成当前父节点不断循环，
 * 直到当前父节点的值是最大的时候退出while循环。
 * 
 * @param args
 */
public static void main(String[] args) {
    int[] a={49,38,65,97,76,13,27,49,78,34,12,64};
    int arrayLength=a.length;  
    //循环建堆  
    for(int i=0;i<arrayLength-1;i++){  
        //建堆  
        buildMaxHeap(a,arrayLength-1-i);  
        //交换堆顶和最后一个元素  
        swap(a,0,arrayLength-1-i);  
        System.out.println(Arrays.toString(a));  
    }  
}
//对data数组从0到lastIndex建大顶堆
public static void buildMaxHeap(int[] data, int lastIndex){
     //从lastIndex处节点（最后一个节点）的父节点开始 
    for(int i=(lastIndex-1)/2;i>=0;i--){
        //k保存正在判断的节点 
        int k=i;
        //如果当前k节点的子节点存在  
        while(k*2+1<=lastIndex){
            //k节点的左子节点的索引 
            int biggerIndex=2*k+1;
            //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
            if(biggerIndex<lastIndex){  
                //若果右子节点的值较大  
                if(data[biggerIndex]<data[biggerIndex+1]){  
                    //biggerIndex总是记录较大子节点的索引  
                    biggerIndex++;  
                }  
            }  
            //如果k节点的值小于其较大的子节点的值  
            if(data[k]<data[biggerIndex]){  
                //交换他们  
                swap(data,k,biggerIndex);  
                //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值  
                k=biggerIndex;  
            }else{  
                break;  
            }  
        }
    }
}
//交换
private static void swap(int[] data, int i, int j) {  
    int tmp=data[i];  
    data[i]=data[j];  
    data[j]=tmp;  
} 

堆是一种队列结构

最小堆：堆顶元素最小

插入：从最后插入一个元素，然后查其父节点自底向上对堆进行调整。

删除：由于其结构特点，只能从堆顶删除元素，因此删除后需要对堆进行自顶向下的调整。

---

快速排序 和 归并排序 见“小白的算法笔记本”

---

如有错误或不合理的地方，敬请指正~

加油！！