十大经典排序

十大经典排序

一、10种经典的排序方法

1、选择排序

for(int i = 0; i < length - 1; i++) {
    for(int j = i + 1; j < length; j++) {
	    if(Array[i] > Array[j]) {
		    int num = Array[i];
			Array[i] = Array[j];
			Array[j] = num;
		}
	}
}   

2、插入排序

for(int i = 1; 	i < length; i++) {
    int temp = Array[i];
	int k = i - 1;
	while(k >= 0 && Array[k] > temp) {
	    Array[k + 1] = Array[k];
	    k--;
	}
	Array[k + 1] = temp;
}

3、冒泡排序

for(int i = 0; i< length; i ++) {
    for(int j = 0; j < length - i -1; j++) {
	    if(Array[j + 1] < Array[j]) {
		    temp = Array[j];
			Array[j] = Array[j + 1];
			Array[j + 1] = temp;
		}
	}
}

4、希尔排序(Shell Sort)

int len = array.length;
int temp, gap = len / 2;
while (gap > 0) {
    for (int i = gap; i < len; i++) {
        temp = array[i];
        int preIndex = i - gap;
        while (preIndex >= 0 && array[preIndex] > temp) {
            array[preIndex + gap] = array[preIndex];
            preIndex -= gap;
        }
        array[preIndex + gap] = temp;
    }
    gap /= 2;
}

5、归并排序

public static void MergeSort(int[] array) {
	sort(array, 0, array.length - 1);
}

public static void sort(int[] array, int start, int end) {
	if(start == end) {
		return;
	}
	int mid = start + ((end - start) >> 1);
	sort(array, start, mid);
	sort(array, mid + 1, end);
	merge(array, start, mid, end);
}

public static void merge(int[] array, int start, int mid, int end) {
	int[] temp = new int[end - start + 1];
	int p1 = start, p2 = mid + 1, i = 0;
	while(p1 <= mid && p2 <= end) {
		temp[i++] = array[p1] > array[p2] ? array[p2++] : array[p1++];
	}
	while(p1 <= mid) {
		temp[i++] = array[p1++];
	}
	while(p2 <= end) {
		temp[i++] = array[p2++];
	}
	for(i = 0; i < temp.length; i++) {
		array[start + i] = temp[i];
	}
}

6、快排序

public static void quickSort(int[] array) {
	if(array == null || array.length <= 1) {
		return;
	}
	quickSort(array, 0, array.length - 1);
}

public static void quickSort(int[] array, int start, int end) {
	if(start >= end) {
		return;
	}
	int p1 = start, p2 = end, index = array[p1];
	while(p1 < p2) {
		while(p1 < p2 && array[p2] >= index) { // 向左寻找第一个小于index的数
			p2--;
		}
        if(p1 < p2) {
        	array[p1++] = array[p2];
        }
        while(p1 < p2 && array[p1] <= index) {// 向右寻找第一个大于index的数
        	p1++;
        }
        if(p1 < p2) {
        	array[p2--] = array[p1];
        }
	}
	array[p1] = index;                 // 将基准数填入最后的坑
	quickSort(array, start, p1 - 1);   //递归分治左半部分
	quickSort(array, p1 + 1, end);      //递归分治右半部分
}

7、堆排序

public static void heapSort(int[] array) {
    int length = array.length - 1;
	int beginIndex = (length - 1) >> 1;
	/*
         *  第一步：将数组堆化
         *  beginIndex = 第一个非叶子节点。
         *  从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
         *  叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。
         */
	for(int i = beginIndex; i >= 0; i--) {
	    maxHeapify(i, length);
	}
	/*
    * 第二步：对堆化数据排序
    * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。
    * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。
    * 直至未排序的堆长度为 0。
    */
	for(int j = length; j >= 0; j--) {
	    swap(0,j);
		maxHeapify(0, j - 1);
	}
	private void swap(int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
	
	/**
    * 调整索引为 index 处的数据，使其符合堆的特性。
    * @param index 需要堆化处理的数据的索引
    * @param len 未排序的堆（数组）的长度
    */
	public void maxHeapify(int index, int length) {
	    int left = (index << 1) + 1;        //左节点
		int right = left + 1;               //右节点
		int Max = left;
		if(left > length) {
		    return ;
		}
		if(right <= length && array[left] < array[right]) {
		    Max = right;
		}
		if(array[index] < array[Max]) {
		    swap(Max, Index);
			maxHeapify(Max, length);
		}
	}
}

8、计数排序

public static int[] countSort1(int[] arr){
    if (arr == null || arr.length == 0) {
        return null;
    }
    
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    
    //找出数组中的最大最小值
    for(int i = 0; i < arr.length; i++){
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }
    
    int help[] = new int[max];
    
    //找出每个数字出现的次数
    for(int i = 0; i < arr.length; i++){
        int mapPos = arr[i] - min;
        help[mapPos]++;
    }
    
    int index = 0;
    for(int i = 0; i < help.length; i++){
        while(help[i]-- > 0){
            arr[index++] = i+min;
        }
    }
    
    return arr;
}
public int[] countSort(int[] array) {
    int res = new int[array.length];
	int max = array[0], min = array[0];
	//取得最大和最小值
	for(int a : array) {
	    if(a > max){
		    max = a;
		}
		if(a < min){
		    min = a;
		}
	}
	int[] arrayTest = new int[max - min + 1];
	for(int ia : array) {
	    arrayTest[ia - min] += 1; 
	}
	for (int i = 1; i < arrayTest.length; i++){
	    arrayTest[i] += arrayTest[i - 1];
	}
	
	for(int i = arrayTest.length - 1; i >= 0; i++){
	    int where = array[i] - min;
		int sumAccount = arrayTest[where]--;
		res[sumAccount - 1] = array[i];
	}
	return res;
}

https://www.jianshu.com/p/86c2375246d7
https://blog.csdn.net/OneDeveloper/article/details/88406776

9、桶排序(BucketSort是计数排序的升级版本)

public static void bucketSort(int[] arr){
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for(int i = 0; i < arr.length; i++){
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }
    //桶数
    int bucketNum = (max - min) / arr.length + 1;
    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
    for(int i = 0; i < bucketNum; i++){
        bucketArr.add(new ArrayList<Integer>());
    }
    
    //将每个元素放入桶
    for(int i = 0; i < arr.length; i++){
        int num = (arr[i] - min) / (arr.length);
        bucketArr.get(num).add(arr[i]);
    }
    
    //对每个桶进行排序
    for(int i = 0; i < bucketArr.size(); i++){
        Collections.sort(bucketArr.get(i));
    }
    System.out.println(bucketArr.toString());
    
}

https://www.cnblogs.com/zer0Black/p/6169858.html#3

10、基数排序

请等待梳理
https://blog.csdn.net/zhen921/article/details/80354096