排序算法小节

最新推荐文章于 2024-03-15 00:29:33 发布
最新推荐文章于 2024-03-15 00:29:33 发布
阅读量339 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shadow___h/article/details/111540954
版权

文章目录

冒泡排序

package 冒泡排序;


/**
 * 时间复杂度 ： O(n2)
 * 空间复杂度 ： O(1)
 *  稳定排序
 * */
public class BubbleSort {

    public static void commonSort(int[] nums) {

        for (int i = 0; i < nums.length; i++) {
            for (int j = nums.length-1; j > i; j--) {
                //前者大于后者
                //相邻的进行比较
                if (nums[j] >= nums[j-1]) {
                    int tmp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = tmp;
                }
            }
        }

    }

    // 优化
    public static void goodSort(int[] nums) {

        Boolean flag = true;
        for (int i = 0; i < nums.length && flag; i++) {
            flag = false;
            for (int j = nums.length-1; j > i; j--) {
                // 前者大于后者
                // 相邻的进行比较
                if (nums[j] >= nums[j-1]) {
                    int tmp = nums[j];
                    nums[j] = nums[j-1];
                    nums[j-1] = tmp;
                    flag = true;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {1,2,3,8,7,6,4};
        commonSort(nums);
        //goodSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }


}

堆排序

package 堆排序;

public class HeapSort {
    public static void commonSort(int[] nums) {
        // 1. 建堆
        createHeap(nums);
        // 2. 调整堆
        int size = nums.length - 1;

        for (int i = 0; i < nums.length; i++) {
            int tmp = nums[size];
            nums[size] = nums[0];
            nums[0] = tmp;

            size--;

            shiftDown(nums, size, 0);
        }

    }

    private static void createHeap(int[] nums) {
        // 最后一个非叶子结点开始建堆
        for (int i = nums.length/2 - 1; i >= 0; i--) {
            shiftDown(nums, nums.length, i);
        }
    }

    private static void shiftDown(int[] nums, int length, int i) {
        // 父亲结点
        int parent = i;
        // 获取child
        int child = (parent * 2) + 1;

        // 循环向下调整
        while (child < length) {
            // 判断那个更小 与更小的交换
            if (child + 1 < nums.length && nums[child + 1] < nums[child]) {
                child = child + 1;
            }
            // 将小的向上调整
            // 大的向下调整
            if(nums[child] < nums[parent]) {
                int tmp = nums[child];
                nums[child] = nums[parent];
                nums[parent] = tmp;
            } else {
                break;
            }
            parent = child;
            child = (parent * 2) + 1;
        }
    }

    public static void main(String[] args) {
        int[] nums = {7,3,4,1,5,8,9};
        commonSort(nums);

        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }
}

希尔排序

package 希尔排序;


/**
 * 时间复杂度 最好 O(n) 最坏O(n2) 平均O(n 1.3)
 * 空间复杂度 O(1)
 * 不稳定排序
* */
public class ShellSort {

    public static void commonSort(int[] nums) {
        int gap = nums.length;
        while (gap > 1) {
            helpSort(nums, gap);
            gap = gap / 3;
        }
        helpSort(nums, 1);
    }

    private static void helpSort(int[] nums, int gap) {
        for (int i = 1; i < nums.length; i++) {

            int x = nums[i];
            int c = i - gap;
            for (; c >= 0 && nums[c] > x ; c -= gap) {
                nums[c + gap] = nums[c];
            }
            nums[c + gap] = x;
        }
    }

    public static void main(String[] args) {
        int[] nums = {1,2,3,8,7,6,4};
        commonSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }

}

归并排序

package 归并排序;


/**
 *  时间复杂度 O(nlogn)
 *  空间复杂度 O(n)
 *  稳定排序
* */
public class mergeSort {

    public static void commonSort(int[] nums) {
        helpSort(nums, 0, nums.length);
        // 传进去的是一个左闭右开的数组
    }

    private static void helpSort(int[] nums, int start, int end) {
        if(start >= end - 1) {
            return;
        }
        int mid = (end + start) / 2;

         // 传进去的是一个左闭右开的数组
        helpSort(nums, start, mid);
        helpSort(nums, mid, end);

        merge(nums, start, mid, end);

    }

    // 开始 归并排序
    private static void merge(int[] nums, int start, int mid, int end) {
        int low = start;
        int mid2 = mid;

        int length = end - start;
        int[] array = new int[length];
        int k = 0;

        //
        while (low < mid && mid2 < end) {
            if ( nums[low] <= nums[mid2]) {
                array[k] = nums[low];
                k++;
                low++;
            } else {
                array[k] = nums[mid2];
                mid2++;
                k++;
            }
        }

        while (low < mid) {
            array[k] = nums[low];
            k++;
            low++;
        }

        while (mid2 < end) {
            array[k] = nums[mid2];
            mid2++;
            k++;
        }

        // 将原来的数组写回去
        // 写回去的时候一定加上start  并且长度是小于我们当前新建的归并数据
        for (int i = 0; i < length; i++) {
            nums[i + start] = array[i];
        }
    }

    public static void main(String[] args) {
        int[] nums = {1,2,3,8,7,6,4};
        commonSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }

}

快排

package 快排;

/**
 * 时间复杂度 最坏O(n2) 平均 O(nlogn)
 * 空间复杂度 O(Logn) O(n)
 * 不稳定排序 12344 可能会改变两个数字的相对顺序
 * */

public class QuickSort {

    public static void commonSort(int nums[]) {
        int len = nums.length;
        helpSort(nums, 0, len-1);
    }

    private static void helpSort(int[] nums, int left, int right) {
        if (left >= right) {
            return;
        }
        // 通过 partition 排序
        // 然后 进行获取partition之后的基准值
        // 这个基准值就是从左边 到右边遍历
        int index = partition(nums, left, right);
        // 每一次的partition遍历 都会分开两个数组
        helpSort(nums, left, index);
        helpSort(nums, index + 1, right);
    }

    private static int partition(int[] nums, int start, int end) {
        int value = nums[start];
        int left = start;
        int right =  end;

        while (left < right) {
            // 必须先从后面遍历比较

            while ( (left < right) && nums[right] >= value) {
                right--;
            }
            // 然后再从前面进行遍历比较
            // 然后才可以让获得的基准值是
            while ( (left < right) && nums[left] <= value) {
                left++;
            }

            // 左右两边 进行交换
            swap(nums, left, right);
        }
        // left 和 right 相遇了
        swap(nums, left, start);
        return left;

    }

    private static void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

    public static void main(String[] args) {
        int[] nums = {1,2,3,8,7,6,4};
        commonSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }

}

直接插入排序

package 直接插入排序;


/**
 *  时间复杂度  最好O(n) 最坏O(n2)
 *  空间复杂度  O(1)
 *  稳定
 *  不会改变两个数字的相对顺序
 * */
public class InsertSort {


    // 工作原理就是设置有序区间 然后逐个比较
    // 比较之后扩大有序区间
    public static void commonSort(int nums[]) {
        /**
        *  7, 3, 2, 4, 6, 8
         *  第一次循环  x=nums[1]=3  c=0
         *             nums[c]=7 > 3
         *             nums[c+1]=nums[1]=nums[c]=7
         *       for循环结束 c-- c=-1
         *             nums[0]=3
         *       得到 3，7，2，4，6，8
         *  第二次循环  x=nums[2]=2 c=1
         *             nums[c]=7 > 2
        * */
        for (int i = 1; i < nums.length; i++) {
            // 第一次开始的时候设置有序区间
            // 每一次的比较都是让后一个和前面的有序区间顺序比较
            int x = nums[i]; // 有序区间接下来的一个

            int c = i -1; // 有序区间最后一个

            // 从有序区间的最后后面开始比较 如果比有序区间的最后一个大 直接赋值
            // 如果小的话 进入有序区间 依次进行比较  进行交换
            for (; c >= 0 && nums[c] > x; c--) {
                nums[c + 1] = nums[c];
            }
            nums[c + 1] = x;
        }





        for(int i = 1; i < nums.length; i++) {
            int x = nums[i]; // 第二个
            int c = i-1;  // 第一个

            for (; c >= 0 && nums[i] > x ; c--) {
                nums[c+1] = nums[c];
            }

            nums[c+1] = x;
        }

    }

    public static void main(String[] args) {
        int[] nums = {1,2,3,8,7,6,4};
        commonSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }

}

选择排序

package 选择排序;

/**
 * 时间复杂度 O(n2)
 * 空间复杂度 O(1)
 * 不稳定排序
 * */
public class SelectSort {

    /**
     *  第一个数 和 后面的依次比较 选择出最小的数
     *  然后最小的数和第一个数交换
     *  然后开始第二个数和后面的数开始比较
     * */

    public static void commonSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {

            int max = i;
            // int min = i;
            for (int j = i + 1; j < nums.length; j++) {
            //    if(nums[j] < nums[min]) {
            //        min = j;
            //    }

                // 开始顺序比较 比较那个是剩下的里面最大的
                // 并且取得下面得下标
                if (nums[j] > nums[max]) {
                    max = j;
                }
            }
            // 最终得到的max值不是i的话
            // 就证明要将max下标的数和i下标的数进行交换
            if(max != i) {
                int tmp = nums[i];
                nums[i] = nums[max];
                nums[max] = tmp;
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {1,2,3,8,7,6,4};
        commonSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }
}

稳定排序和不稳定排序

稳定排序 ： 冒泡排序 归并排序 插入排序
不稳定排序：希尔排序 快排 选择排序 堆排

shadow___h
关注
专栏目录
排序算法详解:冒泡排序、选择排序、插入排序、快速排序、希尔排序
qq_48385654的博客
09-05 3617
一、冒泡排序 1.1 冒泡排序基础【必会知识】 冒泡排序是比较基础的排序算法之一，其思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端。整个过程如同气泡冒起，因此被称作冒泡排序。   冒泡排序的步骤是比较固定的： 1 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2 每趟从第一对相邻元素开始，对每一对相邻元素作同样的工作，直到最后一对。 3 针对所有的元素重复以上的步骤，除了已排序过的元素(每趟排序后的最后一个元素)，直到没有任何一对数字需要比较
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
十大经典排序算法详解
yunweigo的博客
05-26 2601
本文转自 《卢明冬的博客》 相关的同学可以关注一下 文章目录排序算法的分析和评价2.十大排序经典算法总览2.1 排序算法的分类 排序算法是《数据结构和算法》中非常基础的算法，但却占据着十分重要的位置，几乎可以说是我们在日常编程代码中使用最频繁的基础算法。本文对常见的十大经典排序算法进行了详细的知识点梳理，从排序思路、动图演示、代码实现、复杂度分析、算法优化等多个方面分别对不同的排序算法进行讲解，内容详实，一篇文章几乎囊括了排序算法所有必知必会的知识点，夸张点说，算得上是 “史上最全” 排序算法讲解。
经典排序算法
萝卜头
01-14 669
说实话直接叫我手撕所有经典的排序算法（插入、选择、冒泡、快排、归并、桶、计数、基数），并分析所有排序算法的最好、最坏、平均时间复杂度，空间复杂度，是否稳定，各排序算法适用的场景… 说实话我不行，水平太菜了… 0. 序言 我将从三个方面来记录学习排序算法： 衡量排序算法的指标是啥 ？ 目前经典排序的算法 各排序算法适用场景 1. 衡量排序算法的指标 1.1 复杂度 复杂度分为时间复杂度和空间...
c语言的排序算法ppt,C语言常见排序算法.ppt
weixin_36241447的博客
05-25 288
C语言常见排序算法.ppt上章回顾,二叉树的定义 树深度的定义 什么样的二叉树是满二叉树 中序遍历的规则,常见排序算法,第六章,预习检查课程目标,本章概述 几种常见排序算法。 本章目标 熟悉常见的查找算法和排序算法 难点 快速排序算法,本章结构,数据结构与算法初步常见的排序算法,6.1 常见的排序算法,冒泡排序 快速排序 直接插入排序 希尔排序 选择排序 堆排序 归并排序,6.1.1 冒泡排序算法...
排序算法详解（八大排序算法的实现）
大米饭的记录册
12-30 1488
文章中讲解了直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序及计数排序这八种常见排序算法的实现，分析了每种排序算法的复杂度，并对每种排序算法的特性做了基本总结。
【数据结构与算法】(12)：插入排序算法：直接插入排序和希尔排序
最新发布
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
03-15 687
直接插入排序思想和过程讲解，希尔排序是如何优化直接插入排序的？
排序算法衍生问题
unber的博客
06-17 72
如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 这个有序对称为 A 的一个逆序对。我们可以使用本教程的归并思想求逆序对的数量。
【数据结构与算法】：插入排序与希尔排序
Quietcoder的博客
03-14 2395
排序的稳定性是指在排序过程中，具有相等键值的元素在排序前后保持相同顺序的特性。简单来说，如果排序前两个相等的元素A和B（A出现在B之前），在排序后A仍然出现在B之前，那么这种排序算法就是稳定的；反之，如果排序后A和B的顺序发生了变化，这种排序算法就是不稳定的。稳定性在某些情况下很重要，尤其是当排序的键值是复合的，即基于多个字段进行排序时。在这种情况下，保持相等元素的初始顺序可能对保持数据的某种有意义的顺序非常关键。
深入理解排序算法(1.0)
Linux内核爱好者
06-14 693
排序是数据结构与算法里面最基础最入门的内容，虽然简单，但是深入研究的话里面还是有很多内容的，今天我们来全面详细的讲一讲各种排序算法的分类、原理、复杂度、稳定性和实现方法。
算法小节（排序）6种 低级到高级
04-01
根据给定的信息，本文将对六种排序算法进行详细的介绍，包括它们的基本概念、工作原理以及应用场景等。这些算法按照复杂度从低级到高级依次为：冒泡排序、插入排序、选择排序、堆排序、希尔排序。由于提供的代码片段...
数据结构与算法（二）排序算法详解及实现：选择排序、插入排序、希尔排序、归并排序、快速排序和堆排序
px597的博客
02-05 523
一、测试模板类 在学习排序算法的过程中，初步写了一个测试用的模板类，类的方法中包括排序的算法（待实现），类中目前只实现了小于比较和交换等基础的功能，源代码如下，后续会根据排序算法的不同，实现在模板类的排序方法里。 //sort1.h #pragma once #include <iostream> template<class T> class arrSort { public: arrSort(T* arr1, int length, bool isSorted = false)
排序算法研究之希尔排序（shell sort）
爱喝舒化奶的博客
01-07 2万+
前面几个小节，我们分别介绍了冒泡排序，插入排序，快速排序 选择排序本节，我们介绍插入排序的改进版的希尔排序。 希尔排序是1959年，Shell发明的，这是第一个突破O(n2)的排序算法，他与直接插入排序不同的是，他会优先比较距离较近的元素。因此，希尔排序又叫做缩小增量排序。 1、算法思想 首先，将待排序的序表分割成若干个形如L[i,i+d,i+2d,…… i+kd]的“特殊”子表，然后分别的进行直...
java中的自定义布局（精确布局）
shadow___h的博客
05-05 2779
Java中的布局方式是由多种的 分别为流式布局，边界布局，网格布局，以及我们经常用的精确布局。 java中的GUI(图形用户界面)分别位于java.awt和java.Swing包中。 我们可以布局一个简单的计算器的界面来了解如何去精确布局 import javax.swing.*; import java.awt.*; public class Cal extends JFrame { ...
顺序表和单链表的区别 以及顺序表和单链表的代码
shadow___h的博客
11-13 1894
链表中顺序表和单链表的区别 存储分配方式的不同 顺序表 一段连续的存储单元一次存储线性表的数据元素 顺序表代码的实现，其本质就是一个数组和最大容量（也就是数组的长度）以及现有的长度。当我们每存储进一个数据的时候，他的现有长度增加，当增加到最大的容量的时候，我们就需要给顺序表扩容。 我们很难把顺序表的空间容量全部利用。 与单链表相比它无须为表中元素之间的逻辑关系增加额外的存储空间 单链表 1. 采用的链式存储结构，用一组任意的存储单元存放线性表 2. 就是我们添加了一个引用，这个引用中存放了下
用java实现一个简单的图书管理系统
shadow___h的博客
04-12 1760
首先我们需要实现有关书的两个类 package Book; public class Book { private String name;//名字 private String price;//价格 private String author;//作者 private boolean isBorrow;//是否借出 public Book() { ...
不用递归方法的树的遍历
shadow___h的博客
04-27 1134
package src2; import java.util.Stack; public class BuildTree { static class Node { public char val; public Node left; public Node right; public Node(char val) {...
二叉树的简单理解
shadow___h的博客
11-15 991
二叉树 二叉树的定义 ：二叉树是由n个节点的有限集合，该集合可以为空集，或者由一个根界定和两棵互不相交的，分别称为根节点的左子树和右子树的二叉树组成。我就可以把他理解为每一个点最多可以连三个点，但根节点最多只能连两个点。 二叉树一般是具有五种形态：空二叉树，只有一个根结点，根结点只有左子树，根结点只有右子树，根结点有左子树又有右子树。但是这个不重要。 我们要清楚的了解什么是完全二叉树和满二叉树 满二叉树 可以就是说所有的分支结点都存在左子树和右子树，并且所有的叶子都在同一层上,如图所示 完全二叉树 就是从
双向链表的实现（带头傀儡节点）
shadow___h的博客
04-02 544
代码有注释 class ListNode { public int val; public ListNode prev; public ListNode next; public ListNode() { } public ListNode(int val) { this.val = val; } } publi...
Java版常用排序算法详解与实例
- 文档共分为两个部分（一、二），每部分包含多个小节，每个小节详细讲解一种排序算法，并配以实例代码。 总结来说，这篇文档是一份实用的学习资料，涵盖了Java中常用的排序算法，并提供了详细的源码示例，适合想...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值