Java排序 ------ 选择排序

选择排序

算法中最基础的当数排序了,今天整理记录一下Java中的选择排序

这里的排序方式按从小到大讲,由大到小其实就是改变下符号。

选择排序有两种实现方式:
一、简单的选择排序
二、堆排序

因为简单的选择排序比较简单,所以这里先讲它吧。

一、简单的选择排序

简单的选择排序,思想很简单;
①开始找到序列1…. n 中最小的元素,把它和 1 处进行交换;
②然后找到2 …… n 中最小的元素,把它和 2 处进行交换;
③以此类推,可知需要遍历 n - 1 次元素。

代码实现
    public void selectSort(int[] elements){
        int length = elements.length;
        for (int i = 0; i < length - 1  ; i++) { // 利用外层循环控制序列开始的位置
            /*下面就是找到序列 i ...... length 中最小元素的下标*/
            int minIndex = i; 
            for (int j = i + 1; j < length; j++) { 
                if (elements[j] < elements[minIndex]){
                    minIndex = j;
                }
            }

            /*下面是交换位置*/
            if (minIndex != i){
                int temp = elements[minIndex];
                elements[minIndex] = elements[i];
                elements[i] = temp;
            }
        }
    }


二、堆排序

堆排序,堆排序相对就是很复杂了,它涉及到了完全二叉树和有顺序的完成二叉树,也是因为复杂,这种排序方式相当的快,关于各种排序方式的转到博客
Java排序 —— 归并排序 及 排序算法比较图
。 这里先跟大家简单说说完全二叉树和有顺序的完全二叉树

完全二叉树:一种树形结构,节点分为父节点和左、右孩子节点;且从倒数第二层开始以上各层的每个节点都有两个孩子节点,其余节点随意。

有顺序的完全二叉树:一种按大顶堆/小顶堆 排列的完全二叉树。
按小顶堆排序的完全二叉树:父节点必须比子节点小;
按大顶堆排序的完全二叉树:父节点必须比子节点大。

因为我们要实现从小到到大排序,所以这里采用按大顶堆排序;
堆排序的基本思想就是:
1、就序列 [1…..n] 看成是完全二叉树的结构;
2、对完全二叉树按大顶堆进行排序;
3、将排序后的序列的头尾交换数据;
4、然后把 [1…..n-1] 的序列继续看出完全二叉树结构,重新进行大顶堆排序;
5、重复以上过程 n -1 次。

这里有个隐含的条件就是:
数组对应的完全二叉树有这么个关系
父节点:i
左节点:2 * i + 1
右节点:2 * i + 2 //隐含 有右节点就一定有左节点
//由以上关系可以知道,数组从第0个到第length / 2 - 1 个元素才是父节点。

代码实现
    private void heapSort(int[] elements) {
        int length = elements.length;
        for (int i = length; i >= 1; i--) {//长度由于数组头尾元素的交换而递减
            maxHeap(elements, i, 0);//从第一个元素开始排序完全二叉树,实现有顺序的完全二叉树
            swap(elements, 0, i - 1); // 交换数组第一个元素和最后一个元素
        }
    }

    // 对父节点和左、右节点进行排序,实现有顺序的完全二叉树
    private void maxHeap(int[] elements, int heapSize, int index) {
            int largest = index; // 完全二叉树中某个父节点    
            int left = index * 2 + 1; // 某个父节点的左节点
            int right = index * 2 + 2; // 某个父节点的右节点

            //将父节点的值和 比父节点值大的孩子节点的值交换。
            if (left < heapSize/*判读有左节点吗*/ && elements[left] > elements[index])
                largest = left;

            if (right < heapSize /*判读有右节点吗*/&& elements[right] > elements[largest])
                largest = right;

            if (index != largest){ 
                swap(elements, index, largest);         
            }
            if (index <= elements.length / 2 - 1){ // 还是父节点吗
                maxHeap(elements, heapSize, index + 1);//对下一个父节点排序
            }
    }

    private void swap(int[] elements, int left, int right){
        int temp = elements[left];
        elements[left] = elements[right];
        elements[right] = temp;
    }

猜你喜欢

转载自blog.csdn.net/look_Future/article/details/80289937