经典排序算法

最新推荐文章于 2021-04-14 23:33:53 发布
最新推荐文章于 2021-04-14 23:33:53 发布
阅读量152 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzm123456lq/article/details/108484439
版权

学习一下前辈的算法
地址1
地址2

在这里插入图片描述

在这里插入图片描述

冒泡排序
选择排序
插入排序
Shell排序
归并排序
快速排序
堆排序
计数排序


冒泡排序 

package ClassicalAlgorithm;

import java.util.Arrays;

public class BubbleSort {
	private static int[] bubbleSort2;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		bubbleSort2 = bubbleSort(s);
		System.out.println(Arrays.toString(bubbleSort2));
	}
	
    /**
     * 1.冒泡排序
     * 平均时间复杂度 O(n^2) 最好时间复杂度O(n) 最差时间复杂度O(n^2)  空间复杂度O(1)
     * In-place: 占用常数内存，不占用额外内存  稳定
     * 步骤1: 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
	 * 步骤2: 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
	 * 步骤3: 针对所有的元素重复以上的步骤，除了最后一个；
	 * 步骤4: 重复步骤1~3，直到排序完成。
     * @param array
     * @return
     */
    public static int[] bubbleSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++)
            for (int j = 0; j < array.length - 1 - i; j++)
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
        return array;
    }

}

选择排序

package ClassicalAlgorithm;

import java.util.Arrays;

public class SelectionSort {
	private static int[] selectionSort;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		selectionSort = selectionSort(s);
		System.out.println(Arrays.toString(selectionSort));
	}
    /**
     * 每趟找出最小值的位置,与第一个数i=0交换,i++,然后在剩下的数中找最小值，再与第i个值交换
     * 2.选择排序
     * 平均时间复杂度 O(n^2) 最好时间复杂度O(n^2) 最差时间复杂度O(n^2) 空间复杂度O(1)
     * In-place: 占用常数内存，不占用额外内存  不稳定
     * @param array
     * @return
     */
    public static int[] selectionSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex]) //找到最小的数
                    minIndex = j; //将最小数的索引保存
            }
           //因为这里有交换，所以不是稳定算法
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
        return array;
    }

}


插入排序 

package ClassicalAlgorithm;

import java.util.Arrays;

public class InsertionSort {
	
	private static int[] insertionSort;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		insertionSort = insertionSort(s);
		System.out.println(Arrays.toString(insertionSort));
	}
    /**
     * 3.插入排序
     * 平均时间复杂度 O(n^2) 最好时间复杂度O(n) 最差时间复杂度O(n^2) 空间复杂度O(1)
     * In-place: 占用常数内存，不占用额外内存  稳定
     * 步骤1: 从第一个元素开始，该元素可以认为已经被排序；
	 * 步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；
	 * 步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置；
	 * 步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
	 * 步骤5: 将新元素插入到该位置后；
	 * 步骤6: 重复步骤2~5。
     * @param array
     * 对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
     * @return
     */
    public static int[] insertionSort(int[] array) {
        if (array.length == 0)
            return array;
        int current;
        for (int i = 0; i < array.length - 1; i++) {
        	//current 当前要插入的数
            current = array[i + 1];
            int preIndex = i;
            //直到找到已排序的元素小于或者等于新元素的位置; 将新元素插入到该位置后;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
        return array;
    }

}

Shell排序

package ClassicalAlgorithm;

import java.util.Arrays;

public class ShellSort {
	private static int[] ShellSort;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		ShellSort = shellSort(s);
		System.out.println(Arrays.toString(ShellSort));
	}
	
    /**
     * 4.希尔排序:缩小增量排序
     * 平均时间复杂度 O(nlog2 n) 最好时间复杂度O(nlog2 n) 最差时间复杂度O(nlog2 n) 空间复杂度O(1)
     * In-place: 占用常数内存，不占用额外内存  不稳定
     * @param array
     * @return
     */
    public static int[] shellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
        	//以gap为间隔组成一个数组，然后对该数组进行插入排序
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
    }

}


归并排序 

package ClassicalAlgorithm;

import java.util.Arrays;

public class MergeSort {
	private static int[] mergeSort;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		mergeSort = mergeSort(s);
		System.out.println(Arrays.toString(mergeSort));
	}
	
    /**
     * 归并排序
     *将已有序的子序列合并，得到完全有序的序列；
     *即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
     * 平均时间复杂度 O(nlog2n) 最好时间复杂度O(nlog2n) 最差时间复杂度O(nlog2 n)  空间复杂度O(n)
     * Out-place: 占用额外内存  稳定
     * @param array
     * @return
     */
    public static int[] mergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(mergeSort(left), mergeSort(right));
    }
    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     *
     * @param left
     * @param right
     * @return
     */
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];
            else
                result[index] = left[i++];
        }
        return result;
    }

}


快速排序 

package ClassicalAlgorithm;

import java.util.Arrays;

public class QuickSort {
	
	private static int[] quickSort;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		quickSort = quickSort(s,0,7);
		System.out.println(Arrays.toString(quickSort));
	}
	
    /**
     * 快速排序方法
     * 平均时间复杂度 O(nlog2n) 最好时间复杂度O(nlog2n) 最差时间复杂度O(n^2)  空间复杂度O(log2n)
     * In-place: 占用常数内存，不占用额外内存  不稳定
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int[] quickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
        int smallIndex = partition(array, start, end);
        if (smallIndex > start)
            quickSort(array, start, smallIndex - 1);
        if (smallIndex < end)
            quickSort(array, smallIndex + 1, end);
        return array;
    }
    /**
     * 快速排序算法——partition
     * 步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；
	 * 步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
	 * 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
	 * 步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        //快慢指针 smallIndex 慢指针 i是快指针
        //i是一直增加的 smallIndex是当遇到的值比基准值小的时候增加
        //当遇到比基准值大的i增加 smallIndex不增加  直到遇到下一个比基准值小于等于的
        //等于是遇到了自身，将其自身和大于自身的交换
        //就将快指针和慢指针的值交换 
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }

    /**
     * 交换数组内两个元素
     * @param array
     * @param i
     * @param j
     */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

}


堆排序 

package ClassicalAlgorithm;

import java.util.Arrays;

/**
 * 步骤1：将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
 * 
 * 步骤2：将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区
 * (R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
 * 
 * 步骤3：由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区
 * (R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，
 * 得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。
 * 不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
 * 
 * @author:廖泽铭
 * @Description: TODO
 * @date 2020-9-9
 */
public class HeapSort {
	private static int[] heapSort;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		heapSort = heapSort(s);
		System.out.println(Arrays.toString(heapSort));
	}
	
    //声明全局变量，用于记录数组array的长度；
    static int len;
    /**
     * 堆排序算法
     * 平均时间复杂度 O(nlog2n) 最好时间复杂度O(nlog2n) 最差时间复杂度O(nlog2 n)  空间复杂度O(1)
     * In-place: 占用常数内存，不占用额外内存  不稳定
     * @param array
     * @return
     */
    public static int[] heapSort(int[] array) {
        len = array.length;
        if (len < 1) return array;
        //1.构建一个最大堆
        buildMaxHeap(array);
        //2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
        while (len > 0) {
            swap(array, 0, len - 1);
            len--;
            adjustHeap(array, 0);
        }
        return array;
    }
    /**
     * 建立最大堆
     *
     * @param array
     */
    public static void buildMaxHeap(int[] array) {
        //从最后一个非叶子节点开始向上构造最大堆
        //for循环这样写会更好一点：i的左子树和右子树分别2i+1和2(i+1)
    	//假设有7个节点，则二叉树3个父节点 len/2+1即偶数个节点会加一
    	//依次遍历这些节点，建立最大堆
        for (int i = (len/2- 1); i >= 0; i--) {
            adjustHeap(array, i);
        }
    }
    /**
     * 调整使之成为最大堆
     *
     * @param array
     * @param i
     */
    public static void adjustHeap(int[] array, int i) {
        int maxIndex = i;
        //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
        if (i * 2+1< len && array[i * 2+1] > array[maxIndex])
            maxIndex = i * 2+1;
        //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
        if (i * 2 + 2 < len && array[i * 2 + 2] > array[maxIndex])
            maxIndex = i * 2 + 2;
        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
        if (maxIndex != i) {
            swap(array, maxIndex, i);
            adjustHeap(array, maxIndex);
        }
    }
    
    /**
     * 交换数组内两个元素
     * @param array
     * @param i
     * @param j
     */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

}

计数排序

package ClassicalAlgorithm;

import java.util.Arrays;

//计数排序
public class CountingSort {
	private static int[] countingSort;
	public static void main(String[] args) {
		int[] s={3,5,2,17,48,19,1,10};
		countingSort = countingSort(s);
		System.out.println(Arrays.toString(countingSort));
	}
    /**
     * 计数排序
     * 最佳情况：T(n) = O(n+k)
	 * 最差情况：T(n) = O(n+k)
	 * 平均情况：T(n) = O(n+k) 空间复杂度O(k)
     * Out-place: 占用额外内存  稳定
     * @param array
     * @return
     */
    public static int[] countingSort(int[] array) {
        if (array.length == 0) return array;
        int bias, min = array[0], max = array[0];
        //找寻最大值和最小值 确定计数范围
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max)
                max = array[i];
            if (array[i] < min)
                min = array[i];
        }
        bias = 0 - min;
        //新建一个范围空间 比如说排序数范围是5-15
        //bucket=new int(11);
        //15就放在bucket(10)的位置  5放在bucket(0)的位置
        int[] bucket = new int[max - min + 1];
        Arrays.fill(bucket, 0);
        for (int i = 0; i < array.length; i++) {
            bucket[array[i] + bias]++;
        }
        int index = 0, i = 0;
        while (index < array.length) {
            if (bucket[i] != 0) {
                array[index] = i - bias;
                bucket[i]--;
                index++;
            } else
                i++;
        }
        return array;
    }
}
lzm990311
关注
专栏目录
lzma算法
m0_52329237的博客
11-08 4375
lzma算法分析 这几天在公司主要在做压缩相关，记录一下所得。 目前业界主流的压缩算法感觉并不多，好用的就Huffman，lz系列，其他的像差分编码，vlq编码，感觉只能做个数据预处理，或者一种小范围的压缩。 lz系列有很多，主要有lz77 lz78 lzma，基本思想是一样的，都是一种字典编码，如，我有一段文本，里面有“abcdefabcde”,那么后面的abcde并没有必要，可以用前面的替代，所以，其实可存储为“abcd65”,6代表offset，5代表length，既用距离当前位置6字节，长度为5的字
lzma算法_十款性能最佳的压缩算法
weixin_39617318的博客
11-20 4433
数据压缩是保留相同或绝大部分数据前提下减小文件大小的过程。它的原理是消除不必要的数据或以更高效的格式重新组织数据。在进行数据压缩时，你可以选择使用有损方法或无损方法。有损方法会永久性地擦除掉一些数据，而无损方法则能保证持有全部的数据。使用哪类方法取决于你要让你的文件保持多大的精准度。本文会为你介绍6种不同的无损数据压缩算法，以及4种基于深度学习的图像/视频压缩算法。6款无损数据压缩算法无...
LZMA解压缩编码算法的使用
Superstarimage
06-01 4866
目录 一、简介 二、使用方法 1.准备库文件 2.开始编码 三、总结 一、简介 博主在项目中遇到了帧数据流解压缩编码的功能需求，在这里对所采用的解压缩编码算法LZMA的背景、性能和使用介绍作一下简介，主要的目的是积累经验，其次是帮助其他有同样需求的同学少走弯路，分享心得。 lzma算法是7z解压缩软件的默认算法，经过博主的查阅资料与测试，主要发现，与其他算法相比较，lzma算法具有很低的压缩率（压缩数据/原始数据），但是解压缩编码的速度很慢。所以如果你对解压缩的时间没有任何要求，可以尝试这种
layui的数据表格+springmvc实现修改数据功能
灰太狼
06-12 1万+
layui的数据表格+springmvc实现修改数据功能包括单元格修改和form表单修改：可以看看： layui的数据表格+springmvc实现数据显示，分页功能 layui的数据表格+springmvc实现搜索功能 layui的数据表格+springmvc实现增加数据功能1.单元格修改：通过ajax传数据js:if(obj.event === 'edit'){ layer.promp...
(六) 图算法
lzm420241的专栏
05-07 9466
第二十二章 图的基本算法             第二十三章 zui
十大经典排序算法堆排序详细图解（通俗易懂）
最新发布
09-26
十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解...
十大经典排序算法（动图演示） - 一像素 - 博客园.mhtml
04-10
通过学习十大经典排序算法（动图演示），你可以了解C语言中的排序方法，对C语言的程序设计会有很大帮助，有助于今后的工作和学习
十大经典排序算法.pdf
12-08
十大经典排序算法是数据结构与算法领域中的基础，它们包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。这些算法分别适用于不同的场景，具有各自的时间复杂度...
十大经典排序算法总结.docx
08-24
《十大经典排序算法总结》 排序算法是计算机科学的基础，其设计思想和效率对软件的性能有着直接影响。本文主要探讨了十种经典的排序算法，包括它们的设计思路、优缺点以及适用场景，帮助我们理解排序算法的核心。 ...
layui后台表格的增删改查
lzm123456的博客
07-23 1万+
先贴下图： 显示用户界面 显示用户前端页面 <%-- Created by IntelliJ IDEA. User: 廖泽铭 Date: 2019/7/22 Time: 11:02 To change this template use File | Settings | File Templates. --%> <%@ page contentType="...
LZW 编解码算法实现与分析
m0_50794483的博客
04-14 568
一、实验简介 1.LZW简介 LZW 是一种无损数据压缩算法，对于GIF、TIFF格式等文件以及较大规模的英文文本的压缩具有良好的效果，一般可以压缩到原来大小的一半。 LZW算法通过建立字典，实现字符重用与编码，适用于source中重复率很高的文本压缩。 2.LZW编码 LZW的编码思想是不断地从字符流中提取新的字符串，通俗地理解为新“词条”，然后用“代号”也就是码字表示这个“词条”。这样一来，对字符流的编码就变成了用码字去替换字符流，生成码字流，从而达到压缩数据的目的 LZW编码是围绕称为词典的
文件系统的无损压缩算法miniLZO
unsv29的专栏
09-27 8485
弄文件系统，为了减少空间，可能需要用到压缩。已有产品用到了LZM算法，用了之后文件大小为原先的1/10。 在网上找了一下，找到了个miniLZO的stm32工程的例子。 相关文章有： （1）几个常用快速无损压缩算法性能比较 （2）STM32移植 MINI LZO2.09压缩算法 下载 （3）LZO官方网站 （4）百度快照 （5）miniLZO压缩库使用注意事项（good,很容易忽视啊！！！)...
SLAM算法
热门推荐
在路上@Amos
08-19 7万+
一、概述 Simultaneous Localization and Mapping (SLAM)原本是Robotics领域用来做机器人定位的，最早的SLAM算法其实是没有用视觉camera的（Robotics领域一般用Laser Range Finder来做SLAM）。本文主要关注基于camera图像做SLAM的算法，即Visual SLAM算法。本文对SLAM和Visual SLAM不做区分...
【数据结构与算法】Dijkstra算法
lzm18064126848的专栏
04-05 341
package com.smart.reflect; import java.io.IOException; import java.util.Scanner; public class MatrixUDG { private int mEdgNum; // 边的数量 private char[] mVexs; // 顶点集合 privat
jqGrid用法及增删改查方法
Dendy之Java小屋
06-06 424
jquery grid是富客户端的，基于XML ， Ajax网格插件的jQuery库。 jqGridView提供专业的解决方案，代表和编辑表格数据在网络上。精心设计的，具有强大的脚本API的，这可编辑网格是很简单的DHTML与XML 的配置，并显示出令人信服的成果与大量数据。现在我现在熟悉一下jquery grid的的使用方法和一些常用的option设置。 1.调用grid jqGrid已经可...
LZM编码
m0_46345648的博客
04-26 662
补充后的LZWDecode函数 void LZWDecode( BITFILE *bf, FILE *fp){ int character; int new_code, last_code;//new_code为课中所讲的C,last_coed为课中所讲的P int phrase_length; unsigned long file_length; file_length = Bits...
算法设计与分析
lzm123456的博客
03-31 613
1.算法的特效 1.有穷性 2.确定性 3.可行性 4.输入 5.输出 2.算法设计 主要有分治法，动态规划法，贪心法，回溯法，分支限界法，概率算法和近似算法。 3.算法分析 时间复杂度和空间复杂度 时间复杂度 不是指程序具体运行时间的多少，而是与语句执行次数成正比关系。 对时间复杂度分析主要采用渐进上界在这里插入图片描述来分析，也就是O(f(n)). O记号定义：给定一个函数g(n),O(g(n...
基于H.ui.Admin UI模板的网站管理后台
kdf123的专栏
08-27 6611
日常开发中，拥有一套漂亮美观的后台HTML模板，将会令网站管理后台锦上添花。客户看着感觉很满意，开发人员也有成就感（不用天天面对着糟糕的界面，心情沮丧）。本次开发项目为一个电商平台，采用了H.ui模板，还是很轻量级的，用起来很简便，不用太多入门知识。
C#编程：经典排序算法实现详解
"C#编程中的几种经典排序算法实现，包括选择排序(Selection Sort)、冒泡排序(Bubble Sort)和快速排序(Quick Sort)。这些算法在不同的场景下有不同的效率表现，对于理解和优化代码性能有重要意义。" C#语言提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值