程序员必会算法系列--基本排序7个

最新推荐文章于 2024-11-13 17:54:23 发布
最新推荐文章于 2024-11-13 17:54:23 发布
阅读量319 收藏
点赞数
分类专栏： Java算法 文章标签： 算法 程序员
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gladiator_wyj/article/details/61422991
版权

1.冒泡排序

package pers.yijin.sort;

import java.util.Arrays;

/**
 * 冒泡排序 
 * 时间复杂度O(n2)
 * 
 * @author Administrator
 *
 */
public class BubbleSort {
    // 排序算法
    public static int[] bubbleSort(int[] A, int n) {
        long startTime = System.nanoTime();
        // i控制比较次数
        for (int i = 0; i < n; i++) {
            for (int j = n - 2; j >= i; j--) {
                if (A[j + 1] < A[j]) {
                    swap(A, j, j + 1);
                }
            }
        }
        long endTime = System.nanoTime();
        System.out.println("优化前运行时间为："+(endTime-startTime)+"纳秒");
        return A;
    }

    // 排序算法优化
    public static int[] newBubbleSort(int[] A, int n) {
        long startTime = System.nanoTime();
        // i控制比较次数
        boolean flag = true;
        for (int i = 0; i < n && flag; i++) {
            flag = false;
            for (int j = n - 2; j >= i; j--) {
                if (A[j + 1] < A[j]) {
                    swap(A, j, j + 1);
                    flag = true;
                }
            }
        }
        long endTime = System.nanoTime();
        System.out.println("优化后运行时间为："+(endTime-startTime)+"纳秒");
        return A;
    }

    // 交换算法
    private static void swap(int[] arr, int current, int next) {
        int temp = arr[current];
        arr[current] = arr[next];
        arr[next] = temp;
    }

    // 测试
    public static void main(String[] args) {
        int arr[] = { 54, 35, 48, 36, 27, 12, 44, 44, 8, 14, 26, 17, 28 };
        int arr1[] = {54, 35, 48, 36, 27, 12, 44, 44, 8, 14, 26, 17, 28};
        System.out.println(Arrays.toString(BubbleSort.bubbleSort(arr, arr.length)));
        System.out.println("-------------------------------------------------------");
        System.out.println(Arrays.toString(BubbleSort.newBubbleSort(arr1, arr1.length)));
    }
}

2.选择排序

package pers.yijin.sort;

import java.util.Arrays;

/**
 * 选择排序 
 * 时间复杂度O(n2)
 * 
 * @author Administrator
 *
 */
public class SelectionSort {
    public static int[] selectionSort(int A[], int length) {
        int min = -1;
        for (int i = 0; i < length; i++) {
            //初始化最小值的索引为i
            min = i;
            for (int j = i + 1; j < length; j++) {
                if (A[min] > A[j]) {
                    min = j;
                }
            }
            if(min != i){
                swap(A, i, min);
            }
        }
        return A;
    }

    // 交换算法
    private static void swap(int[] arr, int current, int next) {
        int temp = arr[current];
        arr[current] = arr[next];
        arr[next] = temp;
    }

    // 测试
    public static void main(String[] args) {
        int arr[] = { 54, 35, 48, 36, 27, 12, 44, 44, 8, 14, 26, 17, 28 };
        System.out.println(Arrays.toString(SelectionSort.selectionSort(arr, arr.length)));
    }
}

3.插入排序

package pers.yijin.sort;

import java.util.Arrays;

/**
 * 插入排序 
 * 时间复杂度O(n2)
 * 
 * @author Administrator
 *
 */
public class InsertSort {
    // 排序算法
    public static int[] insertSort(int[] A, int n) {
        //空出索引0，认为A[0]是有序的
        for(int i = 1; i < n; i++){
            //依次用A[i]与A[i]左边的值比较，找到插入位置
            for(int j = i; j > 0; j--){
                if(A[j-1] > A[j]){
                    swap(A, j, j-1);
                }
            }
        }
        return A;
    }

    // 交换算法
    private static void swap(int[] arr, int current, int next) {
        int temp = arr[current];
        arr[current] = arr[next];
        arr[next] = temp;  
    }

    // 测试
    public static void main(String[] args) {
        int arr[] = { 54, 35, 48, 36, 27, 12, 44, 44, 8, 14, 26, 17, 28 };
        System.out.println(Arrays.toString(InsertSort.insertSort(arr, arr.length)));
    }
}

4.插入排序的进阶–希尔排序

package pers.yijin.sort;

import java.util.Arrays;

/**
 * 希尔排序 
 * 时间复杂度为O(N*logN)
 * 
 * @author Administrator
 *
 */
public class ShellSort {

    public static int[] shellSort(int arr[], int length) {
        //初始化一个步长
        int step = 1;
        //获得一个最优步长
        while (step < length / 3) {
            step = 3*step +1;
        }
        //根据步长执行插入排序
        while (step >= 1) {
            for (int i = step; i < length ; i++) {
                for (int j = i; j >= step ; j = j - step) {
                    if (arr[j] < arr[j - step]) {
                        swap(arr, j, j - step);
                    }
                }
            }
            //缩小步长划分的数组范围
            step = step / 3;
        }
        return arr;
    }

    // 交换算法
    private static void swap(int[] arr, int current, int next) {
        int temp = arr[current];
        arr[current] = arr[next];
        arr[next] = temp;
    }

    public static void main(String[] args) {
        int arr[] = { 255,64,108,341,217,35,263,272,49,225,229,5,184,119,200,239,126,361,333,58,145,204,322,313,141,95,190,41,5,16,139,212,281,72,302,5,178,156,33,87,116,12,69,253,178,78,95,245,260,218,131,311,175,150,370,164,350,192,373,294,239,325,25,137,147,354,287,169,37,102,232 };
        System.out.println(Arrays.toString(ShellSort.shellSort(arr, arr.length)));
    }

}

5.归并排序

package pers.yijin.sort;

import java.util.Arrays;

/**
 * 归并排序 
 * 时间复杂度O(N*logN)
 * 
 * @author Administrator
 *
 */
public class MergeSort {
    /**
     * 归并操作，将两个有序的子区间归并成一个有序的子区间
     * 
     * @param src
     * @param des
     * @param low
     * @param mid
     * @param high
     */
    private static int[] temp;
    public static void merge(int src[], int low, int mid, int high) {
        // 左边子区间的第一个索引值
        int leftIndex = low;
        // 右边子区间的第一个索引值
        int rightIndex = mid + 1;
        // 辅助数组的第一个索引值
        int startIndex = 0;
        //辅助数组
        temp = new int[high-low+1];
        // 归并操作
        while (leftIndex <= mid && rightIndex <= high) {
            if (src[leftIndex] < src[rightIndex]) {
                temp[startIndex++] = src[leftIndex++];
            } else {
                temp[startIndex++] = src[rightIndex++];
            }
        }
        // 如果左边的区间索引值还没到终点，则把左边区间的值依次赋给辅助数组
        while (leftIndex <= mid) {
            temp[startIndex++] = src[leftIndex++];
        }
        // 如果右边的区间索引值还没到终点，则把右边区间的值依次赋给辅助数组
        while (rightIndex <= high) {
            temp[startIndex++] = src[rightIndex++];
        }
        //把辅助数组里的值赋给目标数组，目标数组的初始下标为传入的最左下标
        for (int i = 0; i < temp.length; i++) {
            src[low+i] = temp[i];
        }
    }

    /**
     * 分别给左右区间排序
     * 
     * @param src
     * @param low
     * @param high
     */
    public static void MSort(int src[], int low, int high) {
        int mid = (low + high) / 2;
        // 递归的结束条件
        if (low == high) {
            return;
        }
        // 给左子区间排序
        MSort(src, low, mid);
        // 给右子区间排序
        MSort(src, mid + 1, high);
        // 归并
        merge(src, low, mid, high);
    }

    /**
     * 归并排序
     * 
     * @param arr
     * @param length
     * @return
     */
    public static void mergeSort(int arr[], int length) {
        MSort(arr, 0, length-1);
    }

    public static void main(String[] args) {
        int arr[] = { 54, 35, 48, 36, 27, 12, 44, 44, 8, 14, 26, 17, 28 };
        MergeSort.mergeSort(arr, arr.length);
        System.out.println(Arrays.toString(arr));
    }

}

6.快速排序

package pers.yijin.sort;

import java.util.Arrays;

/**
 * 快速排序 时间复杂度O(N*logN)
 * 
 * @author Administrator
 *
 */
public class QuickSort {
    /**
     * 划分左右子区间，使左子区间的里的值都小于切分的，使右子区间的里的值都大于切分点。
     * 
     * @param arr
     * @param left
     * @param right
     * @return
     */
    public static int partition(int arr[], int low, int high) {
        // 得到切分点
        int pivot = arr[low];
        // 左右扫描指针
        int left = low+1;
        int right = high;
        while (true) {
            while (arr[left] <= pivot) {
                left++;
                if (left >= high) {
                    break;
                }
            }
            while (arr[right] > pivot) {
                right--;
                if (right == low) {
                    break;
                }
            }
            if (left >= right) {
                break;
            }
            swap(arr, left, right);
        }
        swap(arr, low, right);

        return right;
    }

    /**
     * 递归调用
     * 
     * @param arr
     * @param left
     * @param right
     */
    public static void QSort(int arr[], int low, int high) {
        if (low >= high) {
            return;
        }
        int pivot = partition(arr, low, high);
        QSort(arr, low, pivot - 1);
        QSort(arr, pivot + 1, high);

    }

    /**
     * 快速排序
     * 
     * @param arr
     * @param length
     */
    public static void quickSort(int arr[], int length) {
        QSort(arr, 0, length - 1);
    }

    // 交换算法
    private static void swap(int[] arr, int current, int next) {
        int temp = arr[current];
        arr[current] = arr[next];
        arr[next] = temp;
    }

    public static void main(String[] args) {
        int arr[] = { 14,313,206,53,182,215,169,148,158,272,22,80,176,200,266,301,37,234,174,163,158,158,112,281,86,14,306,137,258,27,247,33,102,5,217,254,286,255,195,234,229,225,296,158,247,42,124,96,292,71,303,144,57,297,315,44,20,111,68,92,181,187,130,167,59,156,240,75,118,184,46,94,74,142,14,313,206,53,182,215,169,148,158,272,22,80,176,200,266,301,37,234,174,163,158,158,112,281,86,14,306,137,258,27,247,33,102,5,217,254,286,255,195,234,229,225,296,158,247,42,124,96,292,71,303,144,57,297,315,44,20,111,68,92,181,187,130,167,59,156,240,75,118,184,46,94,74,142,14,313,206,53,182,215,169,148,158,272,22,80,176,200,266,301,37,234,174,163,158,158,112,281,86,14,306,137,258,27,247,33,102,5,217,254,286,255,195,234,229,225,296,158,247,42,124,96,292,71,303,144,57,297,315,44,20,111,68,92,181,187,130,167,59,156,240,75,118,184,46,94,74,142 };
        quickSort(arr, arr.length);
        System.out.println(Arrays.toString(arr));

    }

}

7.堆排序（代码有问题，只当记录。求指导。。）

package pers.yijin.sort;

import java.util.Arrays;

/**
 * 堆排序 时间复杂度O(NlogN) 提示：使用优先队列构造堆(二叉树)
 * 
 * @author Administrator
 *
 */
public class HeapSort {

    public static int[] heapSort(int[] arr) {
        int size = arr.length -1;
        //只需将堆元素的一半下沉，就能使堆有序
        for (int k = size / 2 -1; k >= 0; k--) {
            sink(arr, k, size);
        }
        while(size > 0){
            //将最大元素与最小元素交换，并把交换后的最大元素脱离
            swap(arr, 0, size--);
            //下沉最小元素，找到第二大元素，继续交换
            sink(arr, 0, size);
        }

        return arr;
    }

    /**
     * 下沉算法，使堆有序
     * @param arr
     * @param k
     * @param size
     */
    private static void sink(int[] arr, int k, int size) {
        while (2 * k +1  <= size) {
            int j = 2 * k + 1;
            if (j < size && arr[j] < arr[j+1]) {
                j++;
            }
            if (arr[k] > arr[j]) {
                break;
            }
            swap(arr, k, j);
            k = j;
        }
    }

    // 交换算法
    private static void swap(int[] arr, int current, int next) {
        int temp = arr[current];
        arr[current] = arr[next];
        arr[next] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {106,167,277,74,146,58,160,201,144,99,146,234,305,337,375,88,64,366,36,227,220,87,163,245,95,128,350,319,129,15,80,326,266,46,216,286,342,150,200,237,299,103,68,126,121,119,149,9,362,210,269,185,262,323,350,27,170,21,110,159,128,328,290,28,253,122,193,176,39,330,260,312,342,27,95,52,163,138,376,358};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

}
「归纳|总结」程序员必知必会的十大排序算法
bigsai
11-26 5256
首发公众号：bigsai 转载请联系 新人原创公众号，求支持一下！ 文章已收录在 我的Github bigsai-algorithm 欢迎star 绪论 身为程序员，十大排序是是所有合格程序员所必备和掌握的，并且热门的算法比如快排、归并排序还可能问的比较细致，对算法性能和复杂度的掌握有要求。bigsai作为一个负责任的Java和数据结构与算法方向的小博主，在这方面肯定不能让读者们有所漏洞。跟着本篇走，带你捋一捋常见的十大排序算法，轻轻松松掌握！ 首先对于排序来说大多数人对排序的概念停留在冒泡排序或者JD.
必知必会的八大排序算法
SUOYUEのBLOG
07-13 232
数据结构与算法是任何程序猿的必修基础课程，日常学习工作中也使用的很多，只是有时候其中用的20%的数据结构和算法太频繁了，以至于没感觉。排序算法十来种，基础必须牢固掌握。......
必会的几种排序算法
MANGOOOOOOO的博客
04-08 290
选择排序#include &lt;stdio.h&gt;int main(){      int a[6] = {2,7,6,1,4,5};      int i, j, t;      int min; //作为最小数的下标      // 外层循环控制轮数，每一轮找到一个最小的数      for (i = 0; i &lt; 5; i++)      {           min = i;...
程序员千万不要学算法！
CSDN学习
08-23 2万+
“程序员必须会算法 ？”   程序员对算法通常怀有复杂情感，算法很重要是共识，但是否每个程序员都必须学算法是主要的分歧点。   很多人觉得像人工智能、数据搜索与挖掘这样高薪的工作才用得上算法，觉得算法深不可测。但是这些其实都不是具体的算法，而是一系列算法的集合。   对初学者来说，为避免片面或抽象地理解算法，可根据几个问题评估自己是否适合学习算法：     学习算法最重要的是什么...
程序员须知：面试中最容易被问到的18个算法题（附答案！）
热门推荐
u011277123的博客
09-25 5万+
原创 IT168企业级 2017-09-20 17:21 算法是比较复杂又基础的学科，每个学编程的人都会学习大量的算法。而根据统计，以下这18个问题是面试中最容易遇到的，本文给出了一些基本答案，供算法方向工程师或对此感兴趣的程序员参考。 1）请简单解释算法是什么？ 算法是一个定义良好的计算过程，它将一些值作为输入并产生相应的输出值。简单来说，它是将输入转换为输出的一系列计
程序员必知的排序算法(一) ----- 冒泡排序
weixin_46030002的博客
08-08 1012
冒泡排序
C语言必学的12个-排序算法.docx
01-15
在快速排序的基本思想中，选择枢轴的方式会影响算法的效率。如果每次都选择第一个元素作为枢轴，当处理已排序或接近排序的数组时，快速排序可能会退化成效率较低的冒泡排序，时间复杂度变为O(n^2)。为了避免这种情况...
【新书速递】程序员必会的40种算法
华章IT官方博客
10-18 2799
算法是计算科学的核心，在求解实际问题的过程中发挥着重要作用。程序员、算法设计师、架构师、数据分析师等信息技术相关从业人员都应学习算法设计基础知识，积累基础算法，掌握典型的机器学习算法、自然...
程序员必会：面试与算法集锦-数据结构与经典问题解析
《程序员编程艺术：面试和算法心得》是一本深入讲解IT编程技巧与面试策略的书籍，特别关注了数据结构和算法的核心内容，以帮助程序员提升技术能力和应对面试挑战。该书分为三个主要部分： 1. **数据结构** - 第一...
Java程序员必会的8种排序算法详解
本文集中讨论了Java中的八大常用排序算法，这些算法是每个开发者必备技能的基础。这些排序算法分为以下几类： 1. **插入排序**： - **直接插入排序**：这种方法通过逐个比较和移动元素，找到合适的位置插入来达到...
程序员必须掌握的算法系列之排序算法
赤兔码
09-21 162
在常见的排序算法中，有几种是程序员必须掌握和深入了解的，它们分别是冒泡排序、插入排序、选择排序、快速排序、归并排序和堆排序。在程序员的职业生涯中，排序算法是十分重要的。冒泡排序、插入排序、选择排序、快速排序、归并排序和堆排序是几种程序员必须掌握的排序算法。除了这些，还有更多的排序算法，比如计数排序、桶排序、基数排序等等。每个排序算法都有其特点和适用场景，掌握这些算法能够帮助程序员更好地解决各种问题。作为一个程序员，不仅要掌握这些排序算法的实现原理和代码实现，还要理解其时间复杂度、空间复杂度和稳定性等特性。
PCA（主成分分析）算法的应用场景
huanfeng_AI的博客
11-09 547
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
STL set
hls0611的博客
11-09 256
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1466
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
0-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
太极生两鱼
11-12 88
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
【数据结构】快排之三路划分
最新发布
2301_79633555的博客
11-13 234
在之前快排是排完序把key放在中间，左边比key值小，右边比key大，跟key相等的值在哪里并没有规定，跟key相等的值可以在左边，也可以在右边。因为假如cur没有遇见比key大的值，right没有--，那么cur与right在相同位置时，并不能确定right所指向的值是否小于key。但是，有些场景下hoae和lomuto（前后指针法）还是适应的不是很好，就是当数组中有大量重复数据时，该场景下性能是有些退化的。cur指向的值与left位置的值进行交换，然后left++，cur++核心思想是把数组中的数据。
算法每日双题精讲——双指针（有效三角形的个数，和为s的俩个数）
A Charmer 的博客
11-09 1264
本文围绕算法中的双指针技巧，详细讲解了 “有效三角形的个数” 和 “和为 s 的俩个数” 两道题目。对于 “有效三角形的个数”，通过排序数组后利用双指针遍历统计满足条件的三元组；“和为 s 的俩个数” 则是先排序，再用双指针找到和为目标值的两个数的下标。文中给出了 C++ 代码实现，并分析了每道题的时间复杂度和空间复杂度，最后强调双指针算法在解决数组问题中的优势，鼓励读者在算法学习中掌握该技巧。
AI 写作（三）文本生成算法：创新与突破（3/10）
小相探索IT世界
11-08 1870
本文深入探讨了 AI 写作中的多种文本生成算法。首先介绍了生成式与判别式模型的区别与特点，包括优化准则、对观察序列的处理、训练复杂度以及支持的训练方式等方面的差异，并对比了它们在 AI 写作中的优缺点。接着详细阐述了长短期记忆网络（LSTM）在文本生成中的应用，包括技术原理与结构、实现步骤与流程以及应用示例与效果。还深入分析了 Transformer 与自注意力机制，介绍了其模型架构与组成、自注意力机制的作用以及在 AI 写作中的重要作用。
以太坊系地址衍生算法分层确定性生成逻辑
J_Lee
11-12 214
以太坊系地址衍生算法分层确定性生成逻辑
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值