精华内容
下载资源
问答
  • 选择排序概念选择排序(Selection sort)是一种简单直观的排序算法。它工作原理如下。首先在未排序序列中找到最小()元素,存放排序序列起始位置,然后,再从剩余未排序元素中继续寻找最小()元素,...

    66929035ea0d5667c34add5a9efd5dea.png

    选择排序的概念

    选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

    选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上,则它不会被移动。选择排序每次交换一对元素,它们当中至少有一个将被移到其最终位置上,因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中,选择排序属于非常好的一种。

    Java代码如下:

    import java.util.Arrays;
    import java.util.Scanner;
    
    //输入一个长度未知的数组并对其进行选择排序
    public class SelectionSort {
    
        public static void main(String[] args) {
            int arr[] =arrayList();
            selectionSort(arr);
            
            System.out.println("从小到大排序后为:"+Arrays.toString(arr));
        }
    
        //输入一个长度未知的数组
        public static  int[] arrayList() {
            System.out.println("请输入一个数组,字符之间用“,”隔开");
            System.out.println("请输入:");
            Scanner sc=new Scanner(System.in);
            String[] nums = null;
            nums = sc.nextLine().split(",");
            int arr[]=new int[nums.length];
            for(int i=0;i<arr.length;i++){
                arr[i]=Integer.valueOf(nums[i]);
            }
            System.out.println("您输入的数组为:"+Arrays.toString(arr));
            return arr;
        }
    
        //选择排序算法
        public static void selectionSort(int[] arr) {
            int min, temp;
            for (int i = 0; i < arr.length; i++) {
                // 初始化未排序序列中最小数据数组下标
                min = i;
                for (int j = i+1; j < arr.length; j++) {
                    // 在未排序元素中继续寻找最小元素,并保存其下标
                    if (arr[j] < arr[min]) {
                        min = j;
                    }
                }
                // 将未排序列中最小元素放到已排序列末尾
                temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }

    运行结果如下:

    5814aa511d3e47433b644f3cebcc9f97.png

    选择排序图解:

    abc23f1e291fbe41ecba8cf6114136cd.png

    选择排序的时间复杂度

    cce958010f6e5c99e1f77e53915ed10c.png
    展开全文
  • 冒泡排序(Bubble Sort)是啥?来源百度百科:冒泡排序是一种简单的排序算法。...通俗理解简单说,如果我们想将一个数组从小到大排列,我们可以这样做:1.首先可以将数组最大值移动到最后面。2.再将...

    9a04ef5a66a3fd8eb6f4441a1261d718.png

    冒泡排序(Bubble Sort)是啥?

    来源百度百科:
    冒泡排序是一种简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素已经排序完成。

    通俗理解

    简单的说,如果我们想将一个数组从小到大排列,我们可以这样做:
    1.首先可以将数组的最大值移动到最后面。
    2.再将次大值移动到倒数第二位。
    3.以此类推,直到将所有数排列好。

    那冒泡排序是怎么实现上述操作的呢?我们来看下算法描述

    算法描述

    假设我们有数组arr
    1.令j为0,arr[j]和arr[j+1]比较,使这两个元素的较大值在排在后面,即若arr[j]>arr[j+1],两数交换位置,若arr[j]<arr[j+1],不换。

    2.不管换与不换,j++。

    3.此时的arr[j]和arr[j+1]再进行比较,重复上述操作直到j=arr.length-1(这是整个排序过程的第一轮排序,即将整个数组中的最大值移动到最后面,所以这一轮排序是在j=arr.length-2的时候停止)

    4.第一轮结束后我们接着进行第二轮,即将次大值移动到数组的倒数第二个位置。那么这一轮结束的标志就是j=arr.length-3

    5.接着进行第三轮,第四轮...直到第二小的数排好序(你想啊,我们将其他数都排好了,最后一个肯定就是最小值啦)所以我们一共要进行arr.length-1轮排序。

    6.每一轮排序结束的标志是j=arr.length-1-i。

    动图演示

    图片来源网络,侵删

    345b215ce31dbfdb6d359cab3e818dcb.gif

    代码实现

    public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[] { 2, 8, 7, 9, 4, 1, 5, 0 };
        bubbleSort(arr);
    }
    
    public static void bubbleSort(int[] arr) {
        //控制多少轮
        for (int i = 1; i < arr.length; i++) {
        //控制每一轮的次数
            for (int j = 0; j <= arr.length -1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j + 1]; 
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    
        }
    }
    

    以上就是我个人对冒泡排序的一些理解,如果有错误的地方欢迎大家指正我的公众号:Java小部落

    我的个人博客:http://www.fangjiaxian.cn

    展开全文
  • 1.冒泡排序通过待排序的序列从前往后依次比较相邻元素,若发现逆序则两两交换,直到下一趟排序下来没有进行交换,说明排序完成冒泡排序每一趟会确定一个最大值(默认从小到大)import java.util.Arrays;p...

    Java常见七种排序算法以及实现

    最近学习一些排序算法,怕自己以后忘记就打算整理起来供自己复习

    萌新一枚学习Java没多久,以下仅供参考。如有错误希望大佬指正,欢迎大家在评论区交流探讨。

    1.冒泡排序

    通过待排序的序列从前往后依次比较相邻的元素,若发现逆序则两两交换,直到下一趟排序下来没有进行交换,说明排序完成

    冒泡排序每一趟会确定一个最大值(默认从小到大)

    import java.util.Arrays;

    public class BubbleSort {

    public static void main(String[] args) {

    int array[] = {10,9,2,-3,6,8,1,-6,-5,4};

    for (int i = 0; i < array.length ; i++) { //循环每一趟排序

    for (int j = 0; j < array.length-1-i ; j++) {

    // 每一趟排序的数据交换

    // 由于array[j]是和array[j+1]比较,防止数据越界这里array.length要减一

    int temp = 0;

    if (array[j]>array[j+1]){

    temp = array[j+1];

    array[j+1] = array[j];

    array[j] = temp;

    }

    }

    }

    // 两种方法输出

    // 1.格式化输出,需import,之后的代码演示全用格式化输出

    System.out.println(Arrays.toString(array));

    // 2.for循环输出

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

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

    }

    }

    }

    2.选择排序

    第一趟排序是从array[0]到array[array.length-1]找到一个最小值array[n]与array[0]进行交换,第一趟排序是从array[1]到array[array.length-1]找到一个最小值array[n]与array[1]进行交换,直到排序完成

    选择排序每一趟排序会确定一个最小值(默认从小到大)

    以下是三种不同的代码实现

    import java.util.Arrays;

    public class SelectSortDemo01 {

    public static void main(String[] args) {

    int array[] = {10,9,2,-3,6,8,1,-6,-5,4};

    for (int i = 0; i < array.length-1 ; i++) {

    for (int j = 1+i; j < array.length; j++) {

    // 此算法与冒泡排序的算法类似,只不过冒泡算法的每一趟排序是两两比较,这个是第一个数与每一个数比较

    int temp = 0;

    if (array[i] > array[j]){

    temp = array[j];

    array[j] = array[i];

    array[i] = temp;

    }

    }

    }

    System.out.println(Arrays.toString(array));

    }

    }

    import java.util.Arrays;

    public class SelectSortDemo02 {

    public static void main(String[] args) {

    int array[] = {10,9,2,-3,6,8,1,-6,-5,4};

    int temp = 0;

    for (int j = 0; j

    for (int i = 1; (i+j)< array.length ; i++) {

    //此算法与上面一个大同小异,也实现了相同的效果,可以根据自己的思维选择一个合适的算法

    if (array[j] > array[i+j]) {

    temp = array[i+j];

    array[i+j] = array[j];

    array[j] = temp;

    }

    }

    }

    System.out.println(Arrays.toString(array));

    }

    }

    12345678910111213141516171819

    public class SelectSortDemo02 {

    public static void main(String[] args) {

    int array[] = {10,9,2,-3,6,8,1,-6,-5,4};

    for (int i = 0; i < array.length-1 ; i++) {

    // 与前面两种方法不同的是此算法直接先假定每一趟排序的第i个数的数值最小,提取当前下标i,

    // 方便每一趟排序与第i个数据进行交换

    // 这样也更容易理解

    int min = array[i];

    int minIndex = i;

    for (int j = 1 + i; j < array.length; j++) {

    if (min > array[j] ){

    // 说明假定的最小值并不是最小的,需要重置min,此时只需赋值,不需要交换

    // 让其循环结束直到赋值到最小值

    min = array[j];

    minIndex = j;

    }

    }

    // 将最小值放在arr[0],交换

    if (minIndex != j) {

    array[minIndex] = arr[j];

    array[j] = min;

    }

    }

    System.out.println(Arrays.toString(array));

    }

    }

    123456789101112131415161718192021222324252627

    3.插入排序

    假如有n个数,第一趟排序就是比较前两个数将它们排好(默认从小到大),然后在来一个数比较他们三个再排好

    可以理解为斗地主的摸牌,先摸了两张J和K,要把J放在K的前面,在摸一张6要放在J和K的前面,在摸一张10就要放在6和J之间,排摸完了就相当于排序结束

    import java.util.Arrays;

    public class InsertSortDemo01 {

    public static void main(String[] args) {

    int[] array = {5, 2, -1, 4, 7};

    for (int i = 1; i < array.length; i++) {

    // 与选择排序第三种类似,先定义一个待插入的数据和插入的位置,便于之后赋值

    int insertVal = array[i];

    // 为了将待插入的数插入到array[i]的前一个位置

    int insertIndex = i - 1;

    // 待插入的位置必须大于等于0,保证数组不越界

    while (insertIndex >= 0 && insertVal < array[insertIndex]) {

    // 直接赋值不用交换数据

    array[insertIndex + 1] = array[insertIndex];

    // 为了让第i个数与前面的数都进行比较然后赋值,前面有条件不用但不用担心数组越界

    insertIndex--;

    }

    // insertIndex + 1 = i 说明第i轮已经有序

    if (insertIndex + 1 != i) {

    array[insertIndex + 1] = insertVal;

    }

    }

    System.out.println(Arrays.toString(array));

    }

    }

    1234567891011121314151617181920212223242526

    4.希尔排序

    希尔排序相当于对插入排序进行优化,是一种缩小增量排序

    希尔排序第一趟按照arraylength\2进行分组,每组分别进行直接插入排序,第二趟按照arraylength\2\2进行分组,每组分别进行直接插入排序,直到增量减至为一,整个文件恰好被分为一组

    以下是两种不同的代码实现

    import java.util.Arrays;

    // 交换法,此实现方法速度是很慢,

    // 因为插入排序比较之后直接移位,而此类方法一遇到逆序就会发生交换,

    // 交换法与冒泡排序类似,不停的交换效率很低

    public class ShellSortDemo02 {

    public static void main(String[] args) {

    int array[] = {10,9,2,-3,6,8,1,-6,-5,4};

    int temp = 0;

    for (int len = array.length/2; len > 0;len/=2) {

    // 循环每一次分组

    for (int i = len; i < array.length; i++) {

    // 遍历各组的所有元素,有len组

    for (int j = i - len; j >= 0; j -= len) {

    if (array[j] > array[j + len]) {

    temp = array[j];

    array[j] = array[j + len];

    array[j + len] = temp;

    }

    }

    }

    }

    System.out.println(Arrays.toString(array));

    }

    }

    12345678910111213141516171819202122232425

    import java.util.Arrays;

    public class ShellSortDemo03 {

    // 对交换式的希尔排序进行优化,采用移位法

    // 当需要插入的数是最小数时,后移的次数明显增多,所以使用分组插入排序会大大的提高效率

    public static void main(String[] args) {

    int[] array = {10, 9, 2, -3, 6, 8, 1, -6, -5, 4};

    // 仍然使用增量len,并逐步缩小增量

    for (int len = array.length / 2; len > 0; len /= 2) {

    // 逐个对其所在的组进行直接插入排序

    for (int i = len; i < array.length; i++) {

    int j = i;

    int temp = array[j];

    if (array[j] < array[j - len]) {

    while (j-len >= 0 && temp < array[j - len]) {

    // 移动,与直接插入排序不同的是这个是间距len之间的数据移位,而直接插入排序是两两移位

    array[j] = array[j - len];

    j -=len;

    }

    // 当退出while循环后,就给temp找到了插入的位置

    array[j] = temp;

    }

    }

    }

    System.out.println(Arrays.toString(array));

    }

    }

    123456789101112131415161718192021222324252627

    快速排序是一种对冒泡排序的改进,第一趟排序以中间的一个数为基准,将数组中比他小的数放在此数的左边,比他大的数放在此数的右边,第二趟排序以第一趟排好的左右的中间一个数为基准,在分别重复上面操作

    import java.util.Arrays;

    public class QuickSortDemo01 {

    public static void main(String[] args) {

    int array[] = {10,9,2,-3,6,8,1,-6,-5,4};

    quickSort(array,0,array.length-1);

    System.out.println(Arrays.toString(array));

    }

    public static void quickSort(int a[],int l,int r){

    if(l>=r)

    return;

    int i = l; int j = r; int key = a[(l+r)/2];

    // 选择第一个数为key,我们数组中间的数为例

    while(i

    while(i=key)

    // 从右向左找第一个小于key的值,找到了,j就前移

    j--;

    // 如果a[j]

    if(i

    a[i] = a[j];

    i++;

    }

    while(i

    // 从左向右找第一个大于key的值,找到了i就后移

    i++;

    // 如果a[i]>key值,a[i]会放到后面的a[j]同时j会前移

    if(i

    a[j] = a[i];

    j--;

    }

    }

    //i == j

    a[i] = key;

    quickSort(a, l, i-1);//递归调用

    quickSort(a, i+1, r);//递归调用

    }

    }

    12345678910111213141516171819202122232425262728293031323334353637383940

    6.归并排序

    归并算法的核心思想就是分解在合并,也就是分治,分解可以采用递归,设一个数组最右边的元素索引为low,最左边的元素的索引为height,中间元素索引为(low+height)/2,每一次分解可以发现当low==height的时候,整个数组被分解成每一个元素,合并就是将两个有序归并段归并为一个有序的归并段,直到有序为止

    import java.util.Arrays;

    public class MergeSortDemo01 {

    //合并函数

    public static void merge(int[] array,int low,int mid,int height){

    int s1 = low;

    int s2 = mid+1;

    int[] ret = new int[height-low+1];

    int i = 0;//表示ret数组的下标

    while (s1<=mid && s2<=height){

    if (array[s1]<=array[s2]){

    ret[i++] = array[s1++];

    }else{

    ret[i++] = array[s2++];

    }

    }

    while (s1<=mid){

    ret[i++] = array[s1++];

    }

    while (s2<=height){

    ret[i++] = array[s2++];

    }

    for (int j=0;j

    array[low+j] = ret[j];

    }

    }

    public static void mergeSort(int[]array,int low,int height){

    if (low>=height){

    return;

    }

    int mid = (low+height)/2;

    mergeSort(array,low,mid);//递归分解左半部分

    mergeSort(array,mid+1,height);//递归分解右半部本

    merge(array,low,mid,height);//合并操作

    }

    public static void main(String[] args) {

    int array[] = {10,9,2,-3,6,8,1,-6,-5,4};

    System.out.println(Arrays.toString(array));

    mergeSort(array,0,array.length-1);

    System.out.println(Arrays.toString(array));

    }

    }

    1234567891011121314151617181920212223242526272829303132333435363738394041424344

    7.基数排序

    本质上是将整数按位数切割成不同的数字,然后按每个位数分别比较,基数排序又叫桶子法

    定义10个编号为0~9一维数组,找到每个数的个位数分别放在对应编号的数组中,然后再将十位数取出分别放在对应编号的数组中,直到取到最高位就变为有序

    基数排序是效率最高的稳定性排序法

    import java.util.Arrays;

    public class RadixSortDemo01 {

    public static void main(String[] args) {

    int array[] = {10, 99, 2, 457, 6, 83, 16, 96, 25, 48};

    radixSort(array);

    }

    //基数排序算法

    public static void radixSort(int[] arr) {

    int max = arr[0];

    // 假设第一个数是最大数

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

    if (arr[i] > max) {

    max = arr[i];

    }

    }

    int maxLength = (max + " ").length();

    // 定义一个二维数组,表示10个桶,每一个桶是一个一维数组用于存放数据

    // 为了防止放入数的时候,数据溢出,则每个一维数组的大小定位arr.length

    int[][] bucket = new int[10][arr.length];

    // 为了记录每个桶中,实际存放了多少数据,我们定义一个一维数组,我们定义一个一维数组记录各个桶每次放入的数据个数

    int[] bucketCounts = new int[10];

    for (int k=0,n=1;k

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

    // 取出每个元素的个位

    int digitOfElement = arr[i] / n % 10;

    // 放入到对应的桶中

    bucket[digitOfElement][bucketCounts[digitOfElement]] = arr[i];

    // 每放一个数据此桶的中的数据就要加一

    bucketCounts[digitOfElement]++;

    }

    // 按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)

    int index = 0;

    // 遍历每一个桶并将桶中数据放入原数组

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

    // 如果桶中有数据我们才放入到原数组

    if (bucketCounts[i] != 0) {

    for (int j = 0; j < bucketCounts[i]; j++) {

    // 取出元素放入到arr

    arr[index++] = bucket[i][j];

    }

    }

    // 第轮处理后需要将每一个bucketCounts[i] = 0;

    bucketCounts[i] = 0;

    }

    System.out.println("第"+(k+1)+"轮排序 arr =" + Arrays.toString(arr));

    }

    }

    }

    展开全文
  • *Java常用排序算法从小到大) (1)##冒泡排序## 特点:效率低,实现简单。 思想:将序列中所有元素两两比较,将最大放在最后面。将剩余序列中所有元素两两比较,将最大放在最后面。重复第二步,直到只剩下一...

    *Java常用排序算法(从小到大)

    (1)##冒泡排序##
    特点:效率低,实现简单。
    思想:将序列中所有元素两两比较,将最大的放在最后面。将剩余序列中所有元素两两比较,将最大的放在最后面。重复第二步,直到只剩下一个数。
    32 43 23 13 5
    32 43 23 13 5
    32 23 43 13 5
    32 23 13 43 5
    32 23 13 5 43
    23 32 13 5 43
    23 13 32 5 43
    23 13 5 32 43
    13 23 5 32 43
    13 5 23 32 43
    5 13 23 32 43
    public static void bubbleSort(int []arr) {
    int[] arr = {12,23,34,56,56,56,78};
    for(int i =0;i<arr.length-1;i++) {
    for(int j=0;j<arr.length-i-1;j++ ) {//-1为了防止溢出
    if(arr[j]>arr[j+1]) {
    int temp = arr[j];
    arr[j]=arr[j+1];
    arr[j+1]=temp;
    }
    }
    }
    }
    (2)##选择排序##
    特点:效率低,容易实现。
    思想:它的工作原理是每一次从待排序的数据元素中选出最小的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到已排序序列的末尾。以此类推,直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
    32 43 23 13 5
    5 32 43 23 13
    5 13 32 43 23
    5 13 32 23 43
    public static void selectSort(int[]a){
    int minIndex=0;
    int temp=0;
    if((anull)||(a.length0))
    return;
    for(int i=0;i<a.length;i++)
    {
    minIndex=i;//无序区的最小数据数组下标
    for(int j=i+1;j<a.length;j++)
    {
    //在无序区中找到最小数据并保存其数组下标
    if(a[j]<a[minIndex])
    {
    minIndex=j;
    }
    }
    //将最小元素放到本次循环的前端
    temp=a[i];
    a[i]=a[minIndex];
    a[minIndex]=temp;
    }
    }
    (3)##插入排序##
    特点:效率低,容易实现。
    思想:有一个已经有序的数据序列,要求在这个已经排好的数据序列中插入一个数,但要求插入后此数据序列仍然有序,这个时候就要用到一种新的排序方法——插入排序法
    32 43 23 13 5
    34 43
    23 34 43
    13 23 34 43
    5 13 23 34 43
    public void zjinsert (Redtype r[],int n)
    {
    int I,j;
    Redtype temp;
    for (i=1;i<n;i++)
    {
    temp = r[i];
    j=i-1;
    while (j>-1 &&temp.key<r[j].key)
    {
    r[j+1]=r[j];
    j–;
    }
    r[j+1]=temp;
    }
    }
    (4)##快速排序##
    特点:高效,时间复杂度为nlogn。
    思绪:选择第一个数为p,小于p的数放在左边,大于p的数放在右边。递归的将p左边和右边的数都按照第一步进行,直到不能递归。
    32 43 23 13 5
    23 13 5 32 43
    13 5 23 32 43
    5 13 23 32 43
    public void quickSort(int array[], int low, int high) {// 传入low=0,high=array.length-1;
    int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。
    if (low < high) {
    p_pos = low;
    pivot = array[p_pos];
    for (i = low + 1; i <= high; i++)
    if (array[i] > pivot) {
    p_pos++;
    t = array[p_pos];
    array[p_pos] = array[i];
    array[i] = t;
    }
    t = array[low];
    array[low] = array[p_pos];
    array[p_pos] = t;
    // 分而治之
    quickSort(array, low, p_pos - 1);// 排序左半部分
    quickSort(array, p_pos + 1, high);// 排序右半部分
    }

    展开全文
  • 一、冒泡排序冒泡排序是一种简单的排序算法。它重复地走访过要排序数列,...冒泡排序示例:冒泡排序算法实现如下:【排序后,数组从小到大排列】/** 冒泡排序* 比较相邻元素。如果第一个比第二个大,就交换他...
  • 经典排序算法在面试中占有很大的比重,也是基础,为了未雨绸缪,在寒假里整理并用Python实现了七大经典排序算法,包括冒泡排序,插入排序,选择排序,希尔排序,归并排序,快速排序,堆排序。希望能帮助有需要的...
  • Java排序算法

    2018-08-24 11:59:52
    冒泡排序 ... * 比较相邻的元素,在此使用从小到大的顺序 * 没轮询一轮,最大的元素会在交换到最后的为止,所以下一次不在排最后一个元素 * @param source 要排序的数组 */ public void bubb...
  • //main方法(增加main方法是为了验证结果),main方法是java程序入口方法,jvm在运行时首先查找main方法 public static void main(String[] args) { //实例化类new一个对象 QuickSort str = ...
  • java排序算法

    2018-10-29 10:56:55
    首先,为什么叫冒泡这个名字呢,我想应该是它排起序来就像像一个一个泡泡得往上冒吧,这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端,从小到大的排序就是每一轮拍完就把最大的一个排到最后面...
  • 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。...如果你想了解更多关于java的知识,可以点击:java教程这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”数列的顶...
  • 然后在进行其他数比较,比较原理相同,完成比较后,序列数会从左到右从小到大排列;原始数据:9 8 10 7 6 0 11第一轮循环:比较数据(9 8 10 7 6 0 11)8 9 10 7 6 0 11 (第1次比较,交换)8 9 10 7 6 0 11 ...
  • 题目:冒泡算法,输入10个数字,按照从小到大的顺序排序 package cn.oop.program; /** * 题目:冒泡算法,输入10个数字,按照从小到大的顺序排序 * @author 温暖wk * 2018.8.16 */ import java.util....
  • 最简单的排序算法:选择排序法:在上一次线性查找法来了个算法开篇,介绍了线性查找法简单算法,这次继续夯实基础,而排序就是算法中非常基础又非常重要算法,如题所示,这里先来学习最最简单的排序算法----...
  • 版权声明 本文原创作者:元芳,...其排序的基本思想就是:从头遍历待排序的数据元素序列,依次比较相邻两个元素的大小,如果前面的大,则交换他们的位置,一步步的讲序列转换成有序并且是从小到大的顺序的序列。 ...
  • 冒泡排序冒泡排序是一种简单的排序算法。它重复地走访过要排序数列,...冒泡排序示例:冒泡排序算法实现如下:【排序后,数组从小到大排列】/*** 冒泡排序* 比较相邻元素。如果第一个比第二个大,就交换他们...
  • 选择排序 所谓选择排序就是在未排序的数中...下面是从小到大进行排序方式 public class TwoSelectionSort { public static void selectionSort(int[] arr) { if ((arr.length < 2) || (Objects.isNull(ar...
  • 插入排序 所谓插入排序就是从无序区域中选一个数插入到有序区域...下面是从小到大进行排序 public class ThreeInsertionSort { public static void insertionSort(int[] arr) { if ((arr.length < 2) |...
  • 一直想理解一下基本的排序算法,最近正好在搞java所以就一并了(为了便于理解,这儿都是以从小到大排序为目的)冒泡排序也就是比较连续两个值,如果前面一个值大于后面一个值,则交换。时间复杂度为O(n*n),是稳定...
  • List排序1、使用Collectionssort(List list)方法对List集合进行从小到大排序/*** 使用Collectionssort(List list)方法对List集合进行从小到大排序*/@Testpublic voidlistDefaultSort() {List list = new ...
  • Java排序算法之快速排序

    万次阅读 2018-12-17 17:46:35
    快速排序,顾名思义,速度快;其时间复杂度为(NlogN),那么它是如何运作来实现高速排序的呢?先讲一下它基本原理:  (1)寻找到一个枢纽元,也就是在... (3)然后对左右重复上述两步,即可实现从小到大排序;  ...
  • 一、选择排序的原理(默认排序从小到大): 原理:每一趟从待排序的记录中选出最小元素,顺序放在已排好序序列最后,直到全部记录排序完毕。第i趟简单选择排序是指通过n-i次关键字比较,从n-i+1个记录中选出...
  • 这里我们的排序是默认排成从小到大的顺序的: 思路: 依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,...
  • 那么我就用一个例子来给讲解下:-----举一个例子:给定一数组{ 9 , 5, 3, 4,6},并对这个数组排序从小到大)。 首先是第一轮(第一个“位置元素”和后面位置元素依次比较):过程是{ 5, 9, 3, 4, 6}---{ 3...
  • 临近数字两两进行比较,按照从小到大或者从大到小顺序进行交换, 这样一趟过去后,最大或最小数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,因此冒泡排序需要n-1趟  复杂度: ...
  • 堆排序堆排序(Heapsort)是指利用堆这种数据结构所设计一种排序...需要从小到大排序则构建成最大堆;需要从大到小排队则构建成最小堆。2.循环删除堆顶元素,替换到二叉堆末尾,调整堆产生新堆顶。动图演示​ ...
  • 1、首先对数组的前两个数据进行从小到大的排序。 2、接着将第3个数据与排好序的两个数据比较,将第3个数据插入合适的位置。 3、然后,将第四个数据插入已经排好序的前3个数据中。 4、不断重复上述过程,直到把...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 739
精华内容 295
关键字:

从小到大的java排序算法

java 订阅