排序算法总结——Java实现

最新推荐文章于 2023-05-15 16:27:45 发布
最新推荐文章于 2023-05-15 16:27:45 发布
阅读量683 收藏 1
点赞数 2
分类专栏： Java 文章标签： 排序算法 冒泡排序 插入排序 快速排序 归并排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41544550/article/details/95535663
版权

1、冒泡排序

  • 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{5, 7, 2, 9, 4, 1, 0, 5, 7};
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    //冒泡排序
    /**
     * 5,7,2,9,4,1,0,5,7		共需要比较length-1轮
     * 5,7,2,9,4,1,0,5,7
     * 5,2,7,9,4,1,0,5,7
     * 5,2,7,4,1,0,5,7,9
     * 2,5
     */
    public static void bubbleSort(int[] arr) {
        //控制共比较多少轮
        for (int i = 0; i < arr.length - 1; i++) {
            //控制比较的次数
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

2、插入排序

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 将新元素插入到该位置后；
  • 重复步骤2~5。
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[]{5, 3, 2, 8, 5, 9, 1, 0};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    //插入排序
    public static void insertSort(int[] arr) {
        //遍历所有的数字
        for (int i = 1; i < arr.length; i++) {
            //如果当前数字比前一个数字小
            if (arr[i] < arr[i - 1]) {
                //把当前遍历数字存起来
                int temp = arr[i];
                int j;
                //遍历当前数字前面所有的数字
                for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                    //把前一个数字赋给后一个数字
                    arr[j + 1] = arr[j];
                }
                //把临时变量（外层for循环的当前元素）赋给不满足条件的后一个元素
                arr[j + 1] = temp;
            }
        }
    }
}

3、希尔排序

import java.util.Arrays;

public class ShellSort {

    public static void main(String[] args) {
        int[] arr = new int[]{3, 5, 2, 7, 8, 1, 2, 0, 4, 7, 4, 3, 8};
        System.out.println(Arrays.toString(arr));
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shellSort(int[] arr) {
        // 遍历所有的步长
        for (int d = arr.length / 2; d > 0; d /= 2) {
            // 遍历所有有元素
            for (int i = d; i < arr.length; i++) {
                // 遍历本组中所有的元素
                for (int j = i - d; j >= 0; j -= d) {
                    // 如果当前元素大于加上步长后的那个元素
                    if (arr[j] > arr[j + d]) {
                        int temp = arr[j];
                        arr[j] = arr[j + d];
                        arr[j + d] = temp;
                    }
                }
            }

        }
    }

}

4、快速排序

  • 从数列中挑出一个元素，称为 “基准”（pivot）；
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 4, 6, 7, 2, 7, 2, 8, 0, 9, 1};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //把数组中的第0个数字做为标准数
            int stard = arr[start];
            //记录需要排序的下标
            int low = start;
            int high = end;
            //循环找比标准数大的数和比标准数小的数
            while (low < high) {
                //右边的数字比标准数大
                while (low < high && stard <= arr[high]) {
                    high--;
                }
                //使用右边的数字替换左边的数
                arr[low] = arr[high];
                //如果左边的数字比标准数小
                while (low < high && arr[low] <= stard) {
                    low++;
                }
                arr[high] = arr[low];
            }
            //把标准数赋给低所在的位置的元素
            arr[low] = stard;
            //处理所有的小的数字
            quickSort(arr, start, low);
            //处理所有的大的数字
            quickSort(arr, low + 1, end);
        }
    }
}

5、归并排序

归并”的含义是将两个或两个以上的有序序列组合成一个新的有序表。假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到（表示不小于x的最小整数）个长度为2(或者是1)的有序子序列，再两两归并。如此重复，直到得到一个长度为n的有序序列为止。这种排序方法称为2-路归并排序。

import java.util.Arrays;

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 5, 2, 4, 6, 8, 10};
        System.out.println(Arrays.toString(arr));
        mergeSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    //归并排序
    public static void mergeSort(int[] arr, int low, int high) {
        int middle = (high + low) / 2;
        if (low < high) {
            //处理左边
            mergeSort(arr, low, middle);
            //处理右边
            mergeSort(arr, middle + 1, high);
            //归并
            merge(arr, low, middle, high);
        }
    }

    public static void merge(int[] arr, int low, int middle, int high) {
        //用于存储归并后的临时数组
        int[] temp = new int[high - low + 1];
        //记录第一个数组中需要遍历的下标
        int i = low;
        //记录第二个数组中需要遍历的下标
        int j = middle + 1;
        //用于记录在临时数组中存放的下标
        int index = 0;
        //遍历两个数组取出小的数字，放入临时数组中
        while (i <= middle && j <= high) {
            //第一个数组的数据更小
            if (arr[i] <= arr[j]) {
                //把小的数据放入临时数组中
                temp[index] = arr[i];
                //让下标向后移一位；
                i++;
            } else {
                temp[index] = arr[j];
                j++;
            }
            index++;
        }
        //处理多余的数据
        while (j <= high) {
            temp[index] = arr[j];
            j++;
            index++;
        }
        while (i <= middle) {
            temp[index] = arr[i];
            i++;
            index++;
        }
        //把临时数组中的数据重新存入原数组
        for (int k = 0; k < temp.length; k++) {
            arr[k + low] = temp[k];
        }
    }

}

6、选择排序

import java.util.Arrays;

public class SelectSort {

    public static void main(String[] args) {
        int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    //选择排序
    public static void selectSort(int[] arr) {
        //遍历所有的数
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            //把当前遍历的数和后面所有的数依次进行比较，并记录下最小的数的下标
            for (int j = i + 1; j < arr.length; j++) {
                //如果后面比较的数比记录的最小的数小。
                if (arr[minIndex] > arr[j]) {
                    //记录下最小的那个数的下标
                    minIndex = j;
                }
            }
            //如果最小的数和当前遍历数的下标不一致,说明下标为minIndex的数比当前遍历的数更小。
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

}

7、基数排序

import java.util.Arrays;

public class RadixSort {

    public static void main(String[] args) {
        int[] arr = new int[]{23, 6, 189, 45, 9, 287, 56, 1, 798, 34, 65, 652, 5};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void radixSort(int[] arr) {
        //存最数组中最大的数字
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //计算最大数字是几位数
        int maxLength = (max + "").length();
        //用于临时存储数据的数组
        int[][] temp = new int[10][arr.length];
        //用于记录在temp中相应的数组中存放的数字的数量
        int[] counts = new int[10];
        //根据最大长度的数决定比较的次数
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            //把每一个数字分别计算余数
            for (int j = 0; j < arr.length; j++) {
                //计算余数
                int ys = arr[j] / n % 10;
                //把当前遍历的数据放入指定的数组中
                temp[ys][counts[ys]] = arr[j];
                //记录数量
                counts[ys]++;
            }
            //记录取的元素需要放的位置
            int index = 0;
            //把数字取出来
            for (int k = 0; k < counts.length; k++) {
                //记录数量的数组中当前余数记录的数量不为0
                if (counts[k] != 0) {
                    //循环取出元素
                    for (int l = 0; l < counts[k]; l++) {
                        //取出元素
                        arr[index] = temp[k][l];
                        //记录下一个位置
                        index++;
                    }
                    //把数量置为0
                    counts[k] = 0;
                }
            }
        }
    }

}

8、堆排序

import java.util.Arrays;

public class HeapSort {

	public static void heapSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			heapInsert(arr, i);
		}
		int size = arr.length;
		swap(arr, 0, --size);
		while (size > 0) {
			heapify(arr, 0, size);
			swap(arr, 0, --size);
		}
	}

	public static void heapInsert(int[] arr, int index) {
		while (arr[index] > arr[(index - 1) / 2]) {
			swap(arr, index, (index - 1) / 2);
			index = (index - 1) / 2;
		}
	}

	public static void heapify(int[] arr, int index, int size) {
		int left = index * 2 + 1;
		while (left < size) {
			int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
			largest = arr[largest] > arr[index] ? largest : index;
			if (largest == index) {
				break;
			}
			swap(arr, largest, index);
			index = largest;
			left = index * 2 + 1;
		}
	}

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

 

蓦然_
关注
专栏目录
java 冒泡法排序
qq_49956121的博客
08-01 127
以下代码为10位冒泡排序： public static void main(String[] args) { int array[]={2,10,5,9,3,4,6,8,1,7}; for(int i=0;i<array.length;i++){ for(int j=0;j<i;j++){ if(array[i]<array[j]){ int temp=array[i]; array[i]=array[j]; array[j]=tem
经典排序算法——堆排序——Java实现及算法解析
weixin_48610702的博客
04-04 336
堆排序——Java代码实现及算法解析一、前言1. 什么是堆？2. 堆排序的概念二、堆排序的Java代码实现1. 算法思想2. Java代码解析2. 完整代码总结 一、前言 1. 什么是堆？ 堆是一种重要的数据结构，它是一种完全二叉树。堆分为最大堆和最小堆，最大堆任意子树根节点不小于任意子结点，即每一个父节点一定大于其两个左右子节点；最小堆则与之相反，最小堆的根节点不大于任意子结点。底层如果用数组存储数据的话，假设某个元素为序号为 i (Java数组从0开始，i为0到n-1)，如果它有左子树，那么左子树的位
C# 实现冒泡排序
Wilhelm的博客
04-23 6439
C# 实现冒泡排序 过程拆解 假设现有一数组，如下 基本排序代码如下 static void Main(string[] args) { int[] myarray = new int[] { 6, 5, 8, 7, 1, 2, 3, 5 };//替换代码 BaseSort(myarray, 0, 7);//替换代码 for(int i = 0; i < myarray.Length; i++) { Console.Write(myarray
冒泡排序
qq_53502890的博客
05-27 100
冒泡排序 //冒泡排序 public class Test05 { public static void main(String[] args) { int[] arr = new int[]{2, 3, 6, 365, 12, 594, 22, 36, 18}; boolean isflag = true; for (int i = 0; i < arr.length; i++) { for (int j = .
c语言输入10个整数排序（附加冒泡排序）
qq_59335499的博客
08-12 2044
c语言输入10个整数从小到大排序 #include <stdio.h> void main() { int a[10],i,t,min,max,n=10; printf("输入10整数："); for(i = 0; i < n; ++i) scanf("%d",&a[i]); printf("交换前:\n"); for(i = 0; i < n; ++i) printf("%d ",a[i]);
Java排序法(冒泡排序、选择排序、快速排序)
七夏的博客
11-20 1941
public class Java_SortMethod { static int temp; public static void main(String[]args) { int [] arr1 = new int[] {4,8,7,-6,5,0,2,3,9,1,-8,-9}; int [] arr2 = new int[] {4,8,7,-6...
10大排序算法——01冒泡排序（Java实现）
12-21
冒泡排序（Bubble Sort） 冒泡排序也叫起泡排序 冒泡排序的执行流程 1.从头开始比较每一对相邻元素，如果第一个比第二个大，就交换他们的位置。（执行完第一轮，最后的那个元素就是最大的元素） 2.忽略从步骤1中找到...
排序算法-基于Java实现的排序算法之BubbleSort实现.zip
最新发布
03-27
本项目聚焦于一种基础且经典的排序算法——冒泡排序（Bubble Sort），并以Java编程语言作为实现工具。Java是一种广泛使用的面向对象的编程语言，其简洁的语法和丰富的库函数使得实现各种算法变得方便。 冒泡排序是...
排序算法-基于Java实现的排序算法之BogoSort实现.zip
03-27
本资料主要关注一种特殊的排序算法——BogoSort，它是以一种极其随机的方式进行排序的。 **BogoSort** BogoSort，又称为BozoSort或StoogeSort，是一种非常慢的排序算法，它的基本思想是不断地随机打乱数组，直到...
选择排序——Java实现
01-20
算法实现原理 1、选取出 n 条记录中最小的记录与第一条记录进行交换 —— 循环的第一趟 2、选取出除第一条记录以外的 n-1 条记录中最小的记录与第二条记录进行交换 —— 循环的第二趟 3、以此类推直到整个数组全部...
DAY 6 数组
qq_46031627的博客
07-26 121
1.数组 1.1数组的理解： 数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名， 并通过编号的方式对这些数据进行统一管理。 1.2数组相关的概念： * 数组名 * 元素 * 角标、下标、索引 * 数组的长度：元素的个数 1.3.数组的特点： * 1数组是序排列的 * 2数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 * 3创建数组对象会在内存中开辟一整块连续的空间 * 4数组的长度一旦确定，就不能修改。 1.4. 数组的分类： *
算法：八大排序
weixin_47796247的博客
04-15 700
目录 一、冒泡排序 二、简单选择排序 三、堆排序 四、直接插入排序 五、归并排序 六、快速排序 七、希尔排序 八、基数排序 一、冒泡排序 （平均时间复杂度为O(n²)） 从左到右依次俩俩比较，并进行交换，知道最右边最大为止（也可以从大到小） 代码实现： public class array { public static void main(String[] args){ int[] a=n...
数组的常用操作及方法
weixin_48961004的博客
11-28 988
数组的常用操作
Java基础-数组循环综合练习2
qq_52699757的博客
05-15 647
Java基础-数组循环综合练习2
java数组
xx的博客
10-19 1088
java数组
Java基础语法05-数组
小管博客空间站
11-14 447
Java基础语法5 1 数组的概述 1.1 数组的理解-重点 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。 1.2 相关的概念-重点 数组名 元素 下标(或索引) 数组的长度 1.3 数组的特点 数组是有序排列的 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 创建数组对象会在内存中开辟一整块连续的空间 数组的长度一旦确定，就不能修改。 1.4 数组的分类 按照维数：一维数组、二
java数组编程_Java数组的基本操作方法整理
weixin_34513436的博客
02-20 230
Java数组的基本操作方法整理这篇文章主要介绍了Java数组的基本操作方法整理，是Java入门学习中的基础知识，需要的朋友可以参考下数组是具有相同数据类型的一组数据的集合，Java支持多为数组，一维数组的每个基本单元都是基本数据类型的数据，二维数组就是每个基本单元是一维数组的一维数组，以此类推，n维数组的每个基本单元都是n-1为数组的n-1维数组。下面以一维数组为例说明Java数组的用法。1、数组...
Java基础——数组
explorer363的博客
04-18 6996
本篇文章介绍了什么是数组，数组的使用，数组与方法之间的关系，以及通过几个数组联系加深对数组的理解
java数组声明语句代码,Java 数组（学习 Java 编程语言 013-014）
weixin_28938171的博客
03-22 1071
数组存储相同类型的序列。1. 数组声明数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标(index，或称索引)可以访问数组中的每一个值。在声明数组变量时，需要指出数组类型(数据元素类型紧跟 [])和数组变量的名字。一旦创建了数组，就不能再改变它的长度，可以改变单个的数组元素。如果程序运行中需要经常扩展数组的长度，就应该使用另一种数据结构——数组列表(array list)。下面声明了...
七大经典排序算法实现——Java版
"这篇资源主要介绍了7种经典的排序算法，并提供了Java语言的实现代码，包括冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和堆排序。" 在这篇资源中，我们可以深入理解7种不同的排序算法及其特点： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值