Java排序算法

Java排序算法

初始化数组

public static Integer[] getList(int size) {
    Integer[] demoArr = new Integer[size];
    Random random = new Random();
    for (int i = 0; i < size; i++) {
        demoArr[i] = random.nextInt(size);
    }
    return demoArr;
}

交换函数

public static void swapElement(int[] arr, int i, int j) {
	int swapEle = arr[j];
	arr[j] = arr[i];
	arr[i] = swapEle;
}

插入排序

Integer[] demoArr = getList(10);
   for (int i = 0; i < demoArr.length; i++) {
     for (int j = i; j > 0; j--) {
        if (demoArr[j] < demoArr[j - 1]) {
           Integer demo = demoArr[j - 1];
           demoArr[j - 1] = demoArr[j];
           demoArr[j] = demo;
        }
     }
}
for (Integer demo : demoArr) {
	System.out.println(demo);
}

冒泡排序

int[] demoArr = getList(10);
for (int i = 0; i < demoArr.length; i++) {
	for (int j = 0; j < demoArr.length - i - 1; j++) {
		if (demoArr[j] < demoArr[j + 1]) {
			int swapEle = demoArr[j + 1];
			demoArr[j + 1] = demoArr[j];
			demoArr[j] = swapEle;
		}
	}
}
for (Integer demo : demoArr) {
	System.out.println(demo);
}

堆排序

堆排序(heap_sort)：利用堆这种数据结构所设计的一种排序算法。
堆积是一个近似二叉树的结构，并同时满足堆积的性质：子节点的键值或索引总是小于（或者大于）它的父节点。
堆排序的两种方式：
	1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列。
	2. 小顶堆：每个节点的值都小于或或等于其子节点的值，在堆排序算法中用于降序排列。

		public static void main(String[] args) {
	
	        int[] demoArr = getArray(10);
	        for (int i : demoArr) {
	            System.out.print(i + " ");
	        }
	        System.out.println();
	
	        int length = demoArr.length;
	
	        // 堆节点遍历分类，将数组元素分成（做大右小）
	        buildMaxHeap(demoArr, length);
	        
	        for (int i = length - 1; i > 0; i--) {
	
	            swapElement(demoArr, 0, i);
	
	            length --;
	
	            heapify(demoArr, 0, length);
	        }
	
	        for (int i : demoArr) {
	            System.out.print(i + " ");
	        }
	    }

	    private static void buildMaxHeap(int[] arr, int len) {
	        // 建立大顶堆
	        for (int i = (int)Math.floor(len/2); i >= 0; i--) {
	            // 获取最大顶堆，然后进行比对和位置交换
	            heapify(arr, i, len);
	        }
	    }


    	private static void heapify(int[] arr, int i, int len) {

        // 获取大顶堆子节点下最大节点下标（前）
        int left = i * 2 + 1;
        // 获取大顶堆子节点下最大节点下标（后）
        int right = i * 2 + 2;
        // 获取大顶堆下标
        int largest = i;

        // 判断该pre_node元素是否满足位置交换需求，如果满足，则进行交换，并将大顶堆下标改为此元素下标
        if (left < len && arr[left] > arr[largest]) {
            System.out.println("i. " + i + ", left. " + left + ", value. " + arr[left]);
            largest = left;
        }

        // 判断该next_node元素是否满足位置交换需求，如果满足，则进行交换，并将大顶堆下标改为该元素下标
        if (right < len && arr[right] > arr[largest]) {
            System.out.println("i. " + i + ", right. " + right + ", value. " + arr[right]);
            largest = right;
        }

        // 判断子节点是否有符合排序的值，如果有，则进行排序操作，然后再次进行比对和转换
        if (largest != i) {
            System.out.println("largest. " + largest);
            // 交换位置
            swapElement(arr, i, largest);
            // 递归，判断是否交换位置
            heapify(arr, largest, len);
        }
    }

快速排序

基本信息

快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，
在加上快速排序思想---<分治法>也确实实用，因此很多软件公司的笔试面试，
包括想腾讯，微软等知名IT公司都喜欢考，还有大大小小的程序方面的考是如软考，考研中也常常出现快速排序的身影。
快速排序是C.R.A.Hoare与1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)

基本思想

1. 先从数列中取出一个数作为基准数。
2. 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到他的左边。
3. 在对左右区间重复第二步，直到各区间只有一个数。

	/**
     * 快速排序
     * 简单理解为挖坑排序，即设立一个基准数，然后找到大于或小于及等于的数，再将次数放到找到的数之前的位置
     * @param arr 要排序的数组
     * @param startIndex 开始下标
     * @param endIndex 结束下标
     */
    public static void quickSort(int[] arr, int startIndex, int endIndex) {
        // 判断开始下标是否小于结束下标，如果小于，则进行排序处理
        if (startIndex < endIndex) {
            // 开始下标
            int start = startIndex;
            // 结束下标
            int end = endIndex;
            // 基准值
            int baseVal = arr[startIndex];

            // 判断开始下标是否不等于结束下标
            while (start != end) {

                // 从右向左进行比对
                while (start < end && baseVal < arr[end]) {
                    end--;
                }

                // 从左向右进行比对
                while (start < end && baseVal >= arr[start]) {
                    start++;
                }

                // 比对结束后，然后再进行开始坐标与结束坐标进行比对，如果开始下标仍然小于结束下标，则进行位置交换
                if (start < end) {
                    int swapEle = arr[start];
                    arr[start] = arr[end];
                    arr[end] = swapEle;
                }
            }
            // 二次交换，将已经原始开始下标与已处理过得当前开始下标进行元素交换
            int swapEle = arr[start];
            arr[start] = arr[startIndex];
            arr[startIndex] = swapEle;

            // 递归，从左到右再次进行检查和比对
            quickSort(arr, startIndex, start - 1);
            quickSort(arr, start + 1, endIndex);
        }
    }