java 7 实例_Java 7大常见排序方法实例详解

最新推荐文章于 2023-03-29 20:24:59 发布
最新推荐文章于 2023-03-29 20:24:59 发布
阅读量120 收藏
点赞数
文章标签： java 7 实例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35884854/article/details/114064947
版权
本文介绍了多种排序算法的实现，包括直接插入排序、冒泡排序、快速排序、选择排序、堆排序、归并排序和最低位优先基数排序。通过对比次数、交换次数和执行时间展示了每种算法的性能特点，如时间复杂度和空间复杂度，并指出它们在稳定性方面的差异。这些排序算法在实际编程中各有优劣，适用于不同的场景。
摘要由CSDN通过智能技术生成

直接插入排序

import java.util.HashMap;

public class InsertSort {

private static int contrastCount = 0;//对比次数

private static int swapCount = 0;//交换次数

public static void main(String[] args) {

System.out.println("直接插入排序：\n 假设前面的序列都已经排序好了，把后面未排序的数往已排好序的序列内插入,时间复杂度O(n^2),空间复杂度O(1)，稳定排序");

HashMap hashMap = new HashMap();

init(hashMap);//初始化

System.out.println("初始序列为：");

print(hashMap, 0);//打印

insert(hashMap);//排序

}

/**

* 初始化函数

* @param hashMap

*/

private static void init(HashMap hashMap) {

hashMap.put(0, null);//第一位置空

hashMap.put(1, 0);

hashMap.put(2, 5);

hashMap.put(3, 11);

hashMap.put(4, 12);

hashMap.put(5, 13);

hashMap.put(6, 4);

hashMap.put(7, 1);

hashMap.put(8, 5);

hashMap.put(9, 8);

hashMap.put(10, 6);

hashMap.put(11, 4);

hashMap.put(12, 8);

}

/**

* 进行插入排序

* @param hashMap 待排序的表

*/

private static void insert(HashMap hashMap){

System.out.println("开始插入排序：");

int i,j;

//排序开始时间

long start = System.currentTimeMillis();

for(i=2; i

冒泡排序

import java.util.HashMap;

/**

* 冒泡排序

* @author HHF

* 2014年3月19日

*/

public class BubbleSort {

private static int contrastCount = 0;//对比次数

private static int swapCount = 0;//交换次数

public static void main(String[] args) {

System.out.println("冒泡排序：\n 第一轮使最大值沉淀到最底下，采用从头开始的两两比较的办法，如果i大于i++则交换，下一次有从第一个开始循环，比较次数减一，然后依次重复即可,"

+ "\n 如果一次比较为发生任何交换，则可提前终止，时间复杂度O(n^2),空间复杂度O(1)，稳定排序");

HashMap hashMap = new HashMap();

init(hashMap);//初始化

System.out.println("初始序列为：");

print(hashMap, 0);//打印

bubble(hashMap);//排序

}

/**

* 初始化函数

* @param hashMap

*/

private static void init(HashMap hashMap) {

hashMap.put(0, null);//第一位置空

hashMap.put(1, 10);

hashMap.put(2, 5);

hashMap.put(3, 11);

hashMap.put(4, 12);

hashMap.put(5, 13);

hashMap.put(6, 4);

hashMap.put(7, 1);

hashMap.put(8, 5);

hashMap.put(9, 8);

hashMap.put(10, 6);

hashMap.put(11, 4);

hashMap.put(12, 8);

}

/**

* 进行冒泡排序

* @param hashMap 待排序的表

*/

private static void bubble(HashMap hashMap){

System.out.println("开始冒泡排序：");

//排序开始时间

long start = System.currentTimeMillis();

boolean swap = false;//是否发生交换

int count = 1;//只为了计数

for(int i=1; ihashMap.get(j+1)){//需要发生交换j 和 j+1

hashMap.put(0, hashMap.get(j));

hashMap.put(j, hashMap.get(j+1));

hashMap.put(j+1, hashMap.get(0));

swap = true;

contrastCount++;//发生一次对比

swapCount++;//发生一次交换

swapCount++;//发生一次交换

swapCount++;//发生一次交换

}

contrastCount++;//跳出if还有一次对比

}

print(hashMap, count++);

if(!swap)

break;

}

//排序结束时间

long end = System.currentTimeMillis();

System.out.println("结果为：");

print(hashMap, 0);//输出排序结束的序列

hashMap.clear();//清空

System.out.print("一共发生了 "+contrastCount+" 次对比\t");

System.out.print("一共发生了 "+swapCount+" 次交换\t");

System.out.println("执行时间为"+(end-start)+"毫秒");

}

/**

* 打印已排序好的元素

* @param hashMap 已排序的表

* @param j 第j趟排序

*/

private static void print(HashMap hashMap, int j){

if(j != 0)

System.out.print("第 "+j+" 趟：\t");

for(int i=1; i

快速排序

import java.util.HashMap;

public class QuickSort {

private static int contrastCount = 0;//对比次数

private static int swapCount = 0;//交换次数

public static void main(String[] args) {

System.out.println("快速排序：\n 任取一个数作为分界线，比它小的放到左边，比它大的放在其右边，然后分别对左右进行递归,时间复杂度O(nLgn),空间复杂度O(n)，不稳定排序");

HashMap hashMap = new HashMap();

init(hashMap);//初始化

System.out.println("初始序列为：");

print(hashMap, 0, 0);//打印

System.out.println("开始快速排序：");

//排序开始时间

long start = System.currentTimeMillis();

quick(hashMap, 1, hashMap.size()-1);//排序

//排序结束时间

long end = System.currentTimeMillis();

System.out.println("结果为：");

print(hashMap, 0, 0);//输出排序结束的序列

hashMap.clear();//清空

System.out.print("一共发生了 "+contrastCount+" 次对比\t");

System.out.print("一共发生了 "+swapCount+" 次交换\t");

System.out.println("执行时间为"+(end-start)+"毫秒");

System.out.println("(注：此输出序列为代码执行过程的序列， 即先左边递归 再 右边递归， 而教科书上的递归序列往往是左右同时进行的结果，特此说明)");

}

/**

* 初始化函数

* @param hashMap

*/

private static void init(HashMap hashMap) {

hashMap.put(0, null);//第一位置空

hashMap.put(1, 10);

hashMap.put(2, 5);

hashMap.put(3, 11);

hashMap.put(4, 12);

hashMap.put(5, 13);

hashMap.put(6, 4);

hashMap.put(7, 1);

hashMap.put(8, 5);

hashMap.put(9, 8);

hashMap.put(10, 6);

hashMap.put(11, 4);

hashMap.put(12, 8);

}

/**

* 进行快速排序

* @param hashMap 待排序的表

* @param low

* @param high

*/

static int count = 1;

private static void quick(HashMap hashMap, int low, int high){

if(low hashMap, int low, int high){

hashMap.put(0, hashMap.get(low));//选择一个分界值 此时第low位元素内的值已经无所谓被覆盖了

swapCount++;//发生一次交换

while(lowhashMap.get(low)){//开始从左往右走 直到有不对的数据 或者 到头了

low++;

contrastCount++;//发生一次对比

}

if(low hashMap, int j, int k){

if(j != 0)

System.out.print("第 "+j+" 趟：(分界线为"+k+")\t");

for(int i=1; i

直接选择排序

import java.util.HashMap;

public class SelectionSort {

private static int contrastCount = 0;//对比次数

private static int swapCount = 0;//交换次数

public static void main(String[] args) {

System.out.println("选择排序：\n 每次选择最小的，然后与对应的位置处元素交换,时间复杂度O(n^2),空间复杂度O(1)，不稳定排序");

HashMap hashMap = new HashMap();

init(hashMap);//初始化

System.out.println("初始序列为：");

print(hashMap, 0, 0);//打印

select(hashMap);//排序

}

/**

* 初始化函数

* @param hashMap

*/

private static void init(HashMap hashMap) {

hashMap.put(0, null);//第一位置空

hashMap.put(1, 10);

hashMap.put(2, 5);

hashMap.put(3, 11);

hashMap.put(4, 12);

hashMap.put(5, 13);

hashMap.put(6, 4);

hashMap.put(7, 1);

hashMap.put(8, 5);

hashMap.put(9, 8);

hashMap.put(10, 6);

hashMap.put(11, 4);

hashMap.put(12, 8);

}

/**

* 进行选择排序

* @param hashMap 待排序的表

*/

private static void select(HashMap hashMap){

System.out.println("开始选择排序：");

//排序开始时间

long start = System.currentTimeMillis();

int count = 1;//只为统计执行次数

for(int i=hashMap.size()-1; i>1; i--){//需要循环查询的次数 最后一个元素不用考虑

int k = i;//记录本次查找序列最大值的下标 初始为该数应该要放的位置

for(int j=1; j

堆排序

import java.util.HashMap;

public class HeapSort {

private static int contrastCount = 0;//对比次数

private static int swapCount = 0;//交换次数

private static int printCount = 1;//执行打印次数

public static void main(String[] args) {

System.out.println("堆排序：\n 首先建立一个堆(方法是首先把序列排成二叉树，然后从下往上，从右往左使得每一个小子树中的父节点大于子节点，然后从上往下，从左往右记录堆入序列),"

+ "\n 然后把堆的根节点和最底下 的孩子节点交换，整理堆，再重复交换，整理，时间复杂度O(nlgn),空间复杂度O(1)，不稳定排序");

HashMap hashMap = new HashMap();

init(hashMap);//初始化

System.out.println("初始序列为：");

print(hashMap, 0);//打印

heap(hashMap);//排序

}

/**

* 初始化函数

* @param hashMap

*/

private static void init(HashMap hashMap) {

hashMap.put(0, null);//第一位置空

hashMap.put(1, 10);

hashMap.put(2, 5);

hashMap.put(3, 11);

hashMap.put(4, 12);

hashMap.put(5, 13);

hashMap.put(6, 4);

hashMap.put(7, 1);

hashMap.put(8, 5);

hashMap.put(9, 8);

hashMap.put(10, 6);

hashMap.put(11, 4);

hashMap.put(12, 8);

}

/**

* 进行堆排序

* @param hashMap 待排序的表

*/

private static void heap(HashMap hashMap){

System.out.println("开始建堆：");

//排序开始时间87

long start = System.currentTimeMillis();

for(int i=(hashMap.size()-1)/2; i>=1; i--){//开始建堆

sift(hashMap, i, hashMap.size()-1);//把所有的节点调好位置即可以

}

System.out.println("建堆成功");

for(int j=hashMap.size()-1; j>=1; j--){//每次都把第一个元素与最后一个未排序的交换 然后再调整第一个节点即可

hashMap.put(0, hashMap.get(1));

hashMap.put(1, hashMap.get(j));

hashMap.put(j, hashMap.get(0));

sift(hashMap, 1, j-1);//剩下要排序的数位为j-1

swapCount++;//发生一次交换

swapCount++;//发生一次交换

swapCount++;//发生一次交换

}

//排序结束时间

long end = System.currentTimeMillis();

System.out.println("结果为：");

print(hashMap, 0);//输出排序结束的序列

hashMap.clear();//清空

System.out.print("一共发生了 "+contrastCount+" 次对比\t");

System.out.print("一共发生了 "+swapCount+" 次交换\t");

System.out.println("执行时间为"+(end-start)+"毫秒");

}

/**

* 把第i位的元素移动到合适位置 与其子孩子的最大值比较 如果有发生交换 则继续往下比较

* @param hashMap

* @param i 待移动的数下标

* @param n 表示要查找的范围 从1到n个

*/

private static void sift(HashMap hashMap, int i, int n){

int j = 2*i;//j为i的左孩子

hashMap.put(0, hashMap.get(i));//当前被待排序的数

while(j<=n){//如果有左孩子的

if(hashMap.containsKey(j+1) && hashMap.get(j) hashMap, int j){

if(j != 0)

System.out.print("第 "+j+" 趟：\t");

for(int i=1; i

归并排序

import java.util.HashMap;

public class MergeSort {

private static int contrastCount = 0;//对比次数

private static int swapCount = 0;//交换次数

private static int printCount = 1;//只为统计执行次数

public static void main(String[] args) {

System.out.println("归并尔排序：\n 先将数据分为n组，然后没两组开始合并，相邻两个合并为一个新的有序队列，重复合并直到整个队列有序,时间复杂度O(nlgn),空间复杂度O(n)，稳定排序");

HashMap hashMap = new HashMap();//未排序

HashMap hashMapNew = new HashMap();//已排序

hashMapNew.put(0, null);//第一位置空

init(hashMap);//初始化

System.out.println("初始序列为：");

print(hashMap, 0);//打印

System.out.println("开始归并尔排序：");

//排序开始时间

long start = System.currentTimeMillis();

merge(hashMap, hashMapNew, 1, hashMap.size()-1);//排序

//排序结束时间

long end = System.currentTimeMillis();

System.out.println("结果为：");

print(hashMapNew, 0);//输出排序结束的序列

hashMap.clear();//清空

System.out.print("一共发生了 "+contrastCount+" 次对比\t");

System.out.print("一共发生了 "+swapCount+" 次交换\t");

System.out.println("执行时间为"+(end-start)+"毫秒");

System.out.println("(注：此输出序列为代码执行过程的序列， 即先左边递归 再 右边递归， 而教科书上的递归序列往往是左右同时进行的结果，特此说明)");

}

/**

* 初始化函数

* @param hashMap

*/

private static void init(HashMap hashMap) {

hashMap.put(0, null);//第一位置空

hashMap.put(1, 10);

hashMap.put(2, 5);

hashMap.put(3, 11);

hashMap.put(4, 12);

hashMap.put(5, 13);

hashMap.put(6, 4);

hashMap.put(7, 1);

hashMap.put(8, 5);

hashMap.put(9, 8);

hashMap.put(10, 6);

hashMap.put(11, 4);

hashMap.put(12, 8);

}

/**

* 进行归并尔排序

* @param hashMap 待排序的表

* @param hashMapNew 已排序的表

*/

private static void merge(HashMap hashMap, HashMap hashMapNew, int low, int high){

if(low == high){

hashMapNew.put(low, hashMap.get(low));

swapCount++;//发生一次交换

}else{

int meddle = (int)((low+high)/2);//将这一序列数均分的中间值

merge(hashMap, hashMapNew, low, meddle);//继续对左边的序列递归

merge(hashMap, hashMapNew, meddle+1, high);//对右边的序列递归

mergeSort(hashMap, hashMapNew, low, meddle, high);//把相邻的序列组合起来

for(int i=low; i<=high; i++){//将已经排好序的hashMapNew【low，high】覆盖hashMap【low，high】以便进入下一次的递归归并

hashMap.put(i, hashMapNew.get(i));

swapCount++;//发生一次交换

}

}

}

/**

* 进行归并尔排序 把【low，meddle】和【meddle+1，high】和并为一个有序的hashMapNew【low,high】

* @param hashMap 待排序的表

* @param hashMapNew 已排序的表

* @param low 低位

* @param meddle 中位

* @param high 高位

*/

private static void mergeSort(HashMap hashMap, HashMap hashMapNew, int low, int meddle, int high){

int k = low;

int j = meddle+1;

while(low<=meddle && j<=high){//两个序列组合成一个序列 从小到达的顺序

if(hashMap.get(low) < hashMap.get(j)){

hashMapNew.put(k++, hashMap.get(low++));//放入合适的位置

}else{

hashMapNew.put(k++, hashMap.get(j++));//放入合适的位置

}

contrastCount++;//发生一次对比

swapCount++;//发生一次交换

}

//如果有一方多出来了 则直接赋值

while(low<=meddle){

hashMapNew.put(k++, hashMap.get(low++));//放入合适的位置

swapCount++;//发生一次交换

}

while(j<=high){

hashMapNew.put(k++, hashMap.get(j++));//放入合适的位置

swapCount++;//发生一次交换

}

print(hashMapNew, printCount++);

}

/**

* 打印已排序好的元素

* @param hashMap 已排序的表

* @param j 第j趟排序

*/

private static void print(HashMap hashMap, int j){

if(j != 0)

System.out.print("第 "+j+" 趟：\t");

for(int i=1; i

最低位优先基数排序

/**

* 最低位优先基数排序

* @author HHF

*

*/

public class LSDSort {

private static int contrastCount = 0;//对比次数

private static int swapCount = 0;//交换次数

private static int printCount = 1;//只为统计执行次数

public static void main(String[] args) {

System.out.println("最低位优先基数排序：\n 按个位、十位、百位排序，不需要比较，只需要对数求余然后保存到相应下标的二维数组内，然后依次读取，每一进制重复依次 ,时间复杂度O(d(n+rd)),空间复杂度O(n+rd)，稳定排序");

int[] data = { 173, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100 };

System.out.println("初始序列为：");

print(data, 0);//打印

LSD(data, 3);

}

public static void LSD(int[] number, int d) {// d表示最大的数有多少位

int k = 0;//number的小标

int n = 1;//当比较十位的时候 n=10 比较百位的时候 n=100 用来吧高位降低方便求余数

int m = 1;//正在比较number中数据的倒数第几位

int[][] temp = new int[10][number.length];// 数组的第一维表示可能的余数0-9 二维依次记录该余数相同的数

int[] order = new int[10];// 数组orderp[i]用来表示该位的余数是i的数的个数

//排序开始时间

long start = System.currentTimeMillis();

while (m <= d) {//d=5则比较五次

for (int i = 0; i < number.length; i++) {//把number中的数按余数插入到temp中去

int lsd = ((number[i] / n) % 10);//求得该数的余数

temp[lsd][order[lsd]] = number[i];//保存到相应的地方

order[lsd]++;//该余数有几个

swapCount++;//发生一次交换

}

for (int i = 0; i < 10; i++) {//将temp中的数据按顺序提取出来

if (order[i] != 0)//如果该余数没有数据则不需要考虑

for (int j = 0; j < order[i]; j++) {//有给余数的数一共有多少个

number[k] = temp[i][j];//一一赋值

k++;

swapCount++;//发生一次交换

}

order[i] = 0;//置零，以便下一次使用

}

n *= 10;//进制+1 往前走

k = 0;//从头开始

m++;//进制+1

print(number, printCount++);

}

//排序结束时间

long end = System.currentTimeMillis();

System.out.println("结果为：");

print(number, 0);//输出排序结束的序列

System.out.print("一共发生了 "+contrastCount+" 次对比\t");

System.out.print("一共发生了 "+swapCount+" 次交换\t");

System.out.println("执行时间为"+(end-start)+"毫秒");

}

/**

* 打印已排序好的元素

* @param data 已排序的表

* @param j 第j趟排序

*/

private static void print(int[] data, int j){

if(j != 0)

System.out.print("第 "+j+" 趟：\t");

for (int i = 0; i < data.length; i++) {

System.out.print(data[i] + " ");

}

System.out.println();

}

}

本篇文章希望能帮助到您

Taraus zhang
关注
Java 7大常见排序方法实例详解
08-30
本篇文章将深入解析Java中常见的七种排序方法，包括直接插入排序、希尔排序、冒泡排序、选择排序、快速排序、归并排序以及堆排序。 1. 直接插入排序（直接插入排序） 直接插入排序是一种简单的排序方法，它将未排序...
详解Java常用排序算法（10种，含演示动画）
最新发布
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 2万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
十大排序（含java代码）
qq_62928039的博客
03-29 9827
十大排序算法详解：包括冒泡排序、选择排序、快速排序、插入排序、计数排序、希尔排序、归并排序、桶排序、堆排序、基数排序
【数据结构与算法】Java实现七大排序算法汇总
冲击大厂之路!!!
10-22 2199
凿壁偷光，8000字总结Java实现七大排序算法！
jdk7中Arrays.sort()和Collections.sort()排序方法使用注意
shadow_zed的博客
05-25 6731
1. 为什么写这篇文章 这篇文章的根源是在产品中发现了一个诡异的bug：只能在产品环境下重现，在我的本地开发环境无法重现，而双方的代码没有任何区别。最后用remotedebug的方法找到异常所在： Exception in thread "main"Java.lang.IllegalArgumentException: Comparison method violates i
jdk7对list进行排序（按照list中entity的某个属性比如age）
马晓璐 技术与杂谈
01-24 4323
之前面试的时候被问过，这个问题，如果对list进行排序，jdk是有自己封装对方法的，只是一直没有这个需求，所以一直没用过，这里记录一下。 public static class user { private String name; private int age; public int getAge(){ return age; } publ
Java静态方法和实例方法区别详解
08-31
Java中的静态方法和实例方法是面向对象编程中的两种基本方法类型，它们在使用和功能上有着显著的区别。首先，我们来看看它们的主要差异： 1. 调用方式： - 静态方法：可以通过类名直接调用，无需创建对象，如 `...
Java8 Comparator排序方法实例详解
08-25
Java8 Comparator排序方法实例详解 Java8 Comparator排序方法实例详解是Java8中的一种排序方法，它提供了一些静态方法，方便我们进行排序操作。Comparator是一个函数式接口，提供了compare、equals、naturalOrder、...
java 算法之冒泡排序实例详解
08-29
由于它需要进行多次的元素比较和交换，所以在处理大数据量的排序时，效率相对较低。尽管如此，冒泡排序对于理解排序算法的基本原理和逻辑流程非常有帮助，也是学习其他更高级排序算法的基础。 此外，冒泡排序还可以...
java 中基本算法之希尔排序的实例详解
08-29
Java希尔排序算法详解 希尔排序（Shell Sort）是一种高效的排序算法，它是插入排序的一种改进版本。该算法因DL．Shell于1959年提出而得名。希尔排序是非稳定排序算法。 基本思想： 希尔排序的基本思想是将要排序...
7大排序算法详解文档及java代码实现（可直接运行）
05-23
7大排序算法详解文档，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序。附带java代码实现，可以直接运行。
java中Collections.sort排序函数用法详解
09-01
本篇文章主要介绍了java中Collections.sort排序函数用法详解，非常具有实用价值，需要的朋友可以参考下。
Java常见排序算法
Meng
07-10 2443
目录1、归并排序2、堆排序3、基数排序4、冒泡排序5、希尔排序6、快速排序7、插入排序8、选择排序1、基本思想归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。2、代码实现1、基本思想堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(
Java7大排序总结
Stephen_curry_66的博客
04-17 1377
冒泡排序 基本思想：通过比较相邻的元素，每一趟找到一个最大值放到放到最后 public static void bubbleSort(int[] arr){ boolean flag=true; for(int i=0;i<arr.length&&flag;i++){ flag=false;//如果内循环if条件不满足...
Java常用排序算法
qq_63983125的博客
10-17 1410
Java常用排序算法
java常用的8种排序方法
贾世鑫的博客
09-13 1万+
1.直接插入排序 经常碰到这样一类排序问题：把新的数据插入到已经排好的数据列中。 将第一个数和第二个数排序，然后构成一个有序序列将第三个数插入进去，构成一个新的有序序列。 对第四个数、第五个数……直到最后一个数，重复第二步。 如何写写成代码： 首先设定插入次数，即循环次数，for(int i=1;i设定插入数和得到已经排好序列的最后一个数的位数。inser
七大排序算法java实现
pihaishen的专栏
04-07 614
/** * 1.插入排序算法 * @param int[]  未排序数组 * @return int[]  排完序数组 *  * 插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序， * 本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位， * 为元素 x “腾位置”，
java常用的算法_java常用的7大排序算法汇总
weixin_39844481的博客
02-12 184
这段时间闲了下来，就抽了点时间总结了下java中常用的七大排序算法，希望以后可以回顾！1.插入排序算法插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，***将 k 对应的元素值赋为 x ，一般情况下，插入排序...
java7大排序算法
小红帽的博客
06-21 372
1、冒泡排序 package lizicong; import java.util.Scanner; public class BubbleSort { /* * 属于交换排序；稳定 * 排序原理：相邻的两个元素依次比较，相互交换 * 时间复杂度：最好o(n)，最差o(n^2),平均o(n^2) * 辅助空间：o(1) * */ public void bubb
Java实现的八大排序算法详解与实例
本文档深入探讨了Java实现的八种常见排序算法，对于理解基础的排序原理和提高编程技能具有重要意义。首先，我们来详细了解两种排序算法： 1. 直接插入排序： - 直接插入排序是一种简单直观的排序方法，其基本思想...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值