常用排序算法笔记

冒泡排序

冒泡排序(Bubble Sort)也是一种简单直观的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

/**
 * @Classname Main
 * @Description 冒泡排序实现
 * @Date 2020/7/15 10:51
 * @Created by  yang.zhao
 */
public class Main {
    //1.比较相邻的元素如果第一个元素比第二个元素大就进行一次交换
    //2.依次向后重复进行比较,最后的元素一定是最大的数。
    //3.依次进行刚才的操作直到数组变的有序
    /**
     * @param a 需要交换的数组
     * @param i 交换位置1
     * @param j 交换位置2
     * @Description 交换两个节点的数字位置
     */
    public static void swap(int a[], int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    public static void bubbleSort(int a[]){
        for(int i=0;ia[j+1]){
                    swap(a,j,j+1);
                }
            }
        }
    }

    public static void main(String[] args) {
        int arr[] = {3,4,6,2,11,1,4, 6, 8, 5, 9};
        bubbleSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.err.println(arr[i]);
        }

    }
}

选择排序

选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

重复第二步,直到所有元素均排序完毕。

/**
 * @Classname Main
 * @Description 选择排序实现
 * @Date 2020/7/15 10:51
 * @Created by  yang.zhao
 */
public class Main {

    /**
     * @param a 需要交换的数组
     * @param i 交换位置1
     * @param j 交换位置2
     * @Description 交换两个节点的数字位置
     */
    public static void swap(int a[], int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     * @param a 待排序的数组
     * @Description 选择排序
     */
    public static void selectionSort(int a[]) {
        for (int i = 0; i < a.length; i++) {
            int miniPosition = i;
            for (int j = i + 1; j < a.length; j++) {
                if(a[j]

快速排序递归实现

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较,但这种状况并不常见。事实上,快速排序通常明显比其他 Ο(nlogn) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)

  1. 从数列中挑出一个元素,称为 “基准”(pivot);
  2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
  3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;

代码实现如下:

/**
 * @Classname Main
 * @Description 快速排序实现
 * @Date 2020/7/15 10:51
 * @Created by  yang.zhao
 */
public class Main {
    /**采用分治的方法对其进行排序,步骤如下:
     * 1.先从数列中取出一个数作为基准数。
     * 2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。
     * 3.再对左右区间重复第二步,直到各区间只有一个数。
     */

    /**
     * @param a 需要我们进行填数的数组
     * @param l 基准数所在初始位置
     * @param r 查找开始的初始位置
     * @Description 进行一次的数字的移动和对应位置的填充。
     */
    public static int moveAndFill(int[] a, int l, int r) {
        int i = l;
        int j = r;
        //我们按照填充的位置去尝试从数组中取出第一个数字。
        int x = a[i];
        while (i < j) {
            //既然我们的右区间要比X大,那么我们从右查找将小于X的数字放在左面,填充a[i]的空位。------找比x小的值放在左面
            for (; i < j && a[j] >= x; j--) {
                //通过从j开始向i方向循环,查找到一个小于x的数字为止,获取数组的位置j。
            }
            if (i < j) {//找到的j的位置必须在i的右面,如果在i的左面则已经满足了我们定义的i左小右大的条件,此时的赋值就没有意义。
                //将找到的j对应的数字a[j] 赋值到我们的i的位置上如下:
                a[i] = a[j];
                //i继续向右查找
                i++;
            }
            // ----------------------------------------------------------------------

            //同理我们从左查找将大于x的数字放在右面,填充a[j]的空位------找比x大的数字放在右面填上上一步a[j]的坑
            for (; i < j && a[i] < x; i++) {
                //通过从i开始向j方向循环,查找到一个小于x的数字为止,获取数组的位置j。
            }
            if (i < j) {
                a[j] = a[i];
                j--;
            }
        }
        //当这一次的填坑过程结束,我们将被移动到右侧的原来的i所在的坑,填入我们最开始的基准数x。
        a[i] = x;
        //返回一个我们计算出来的新的基准位置,方便下一次填坑使用。
        return i;
    }

    /**
     * @param a 待排序数组
     * @param l 基准数所在位置
     * @param r 第一次查找开始的位置
     * @Description 快速排序实现
     */
    public static void quickSort(int a[], int l, int r) {
        if (l < r) {
            //进行一次移动填充。
            int i = moveAndFill(a, l, r);
            //通过递归的方式对左区间进行一次划分并填充。
            quickSort(a, l, i - 1);
            //同理对右区间再进行一次划分并填充。
            quickSort(a, i + 1, r);
        }
    }


    public static void main(String[] args) {
        int a[] = {1, 7, 4, 3, 2, 10, 6, 5, 8, 9};
        quickSort(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.printf("%d", a[i]);

        }
        System.out.println();
    }
}

堆排序实现

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法:

大顶堆:每个节点的值都大于或等于其子节点的值,在堆排序算法中用于升序排列;

小顶堆:每个节点的值都小于或等于其子节点的值,在堆排序算法中用于降序排列;

/**
 * @Classname Main
 * @Description 堆排序实现
 * @Date 2020/7/15 10:51
 * @Created by  yang.zhao
 */
public class Main {
    //1.构造初始堆。将给定无序序列构造成一个大顶堆
    //2.交换堆首元素和堆尾元素
    //3.排除最后一个最大的元素重新构建堆,并交换。

    /**
     * @param a 需要交换的数组
     * @param i 交换位置1
     * @param j 交换位置2
     * @Description 交换两个节点的数字位置
     */
    public static void swap(int a[], int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }

    /**
     * @param a     需要构建的数组
     * @param start 起始位置
     * @param end   结束位置
     * @Description 构建一个大顶堆  父节点 大于或等于两个子节点
     */
    public static void maxHeapify(int a[], int start, int end) {
        //父节点位置
        int parent = start;
        //左孩子位置
        int child = parent * 2 + 1;
        while (child <= end) {//在数组大小范围内进行排序
            if (child + 1 <= end && a[child] < a[child + 1]) {
                //对于两个子节点取最大的,即左孩子大 取 左孩子  左孩子小 child++取右孩子
                child++;
            }
            if (a[parent] > a[child]) {
                //父节点大于最大的子节点,满足我们的要求,函数退出。
                return;
            }
            //如果 父节点小于等于最大的子节点,那么我们需要交换一下节点的数字,并继续在子节点上进行交换操作。
            swap(a, parent, child);
            parent = child;
            child = parent * 2 + 1;

        }
    }

    public static void heapSort(int a[]) {
        //获取a的长度
        int len = a.length;
        for (int i = len / 2 - 1; i >= 0; i--) {// i第一个非叶子结点 即 arr.length/2-1,从左到右 从下到上进行移动。
            //获取一个大顶堆,堆首元素为当前的最大元素。
            maxHeapify(a, i, len - 1);
        }
        for (int i = len - 1; i > 0; i--) {
            //将堆顶元素与末尾元素进行交换,使得末尾元素在当前堆中最大。
            swap(a, 0, i);
            //在剩下的元素中继续构建最大堆,不断的将最大的元素放到当前堆的末尾。
            maxHeapify(a, 0, i - 1);
        }
    }

    public static void main(String[] args) {
        int arr[] = {4, 6, 8, 5, 9};
        heapSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.err.println(arr[i]);
        }

    }

你可能感兴趣的:(数据结构与算法,排序算法,算法,排序算法)