Java数组常用排序算法实例小结

本文实例讲述了Java数组常用排序算法。分享给大家供大家参考,具体如下:

1、冒泡排序法

SortArray_01.java

public class SortArray_01 {
    public static void main(String args[]) {
        int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55, 66, 22 };
        // 创建一个初始化的一维数组array
        System.out.println("未排序的数组:");
        for (int i = 0; i < array.length; i++) {
            // 遍历array数组中的元素
            System.out.print(" " + array[i]);
            // 输出数组元素
            if ((i + 1) % 5 == 0)
                // 每5个元素一行
                System.out.println();
        }
        int mid; // 定义一个中间变量,起到临时存储数据的作用
        for (int i = 0; i < array.length; i++) {
            // 执行冒泡排序法
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[i]) {
                    mid = array[i];
                    array[i] = array[j];
                    array[j] = mid;
                }
            }
        }
        System.out.println("\n使用冒泡法排序后的数组:");
        for (int i = 0; i < array.length; i++) {
            // 遍历排好序的array数组中的元素
            System.out.print(" " + array[i]);
            // 输出数组元素
            if ((i + 1) % 5 == 0)
                System.out.println();
            // 每5个元素一行
        }
    }
}

运行结果:

未排序的数组:
 14 5 86 4 12
 3 21 13 11 2
 55 66 22
使用冒泡法排序后的数组:
 2 3 4 5 11
 12 13 14 21 22
 55 66 86

2、数组递增排序

SortArray_02.java

import java.util.Arrays;
import java.util.Random;
public class SortArray_02 {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] array = new int[15];
        // 声明数组
        System.out.println("没有使用sort方法前的数组:");
        for (int i = 0; i < array.length; i++) {
            // 利用随机数随意产生15个0~20之间的随机数
            array[i] = rd.nextInt(20);
            // 给array数组赋值
            System.out.print(" " + array[i]);
            if ((i + 1) % 5 == 0)
                System.out.println();
        }
        Arrays.sort(array);
        // 对array数组进行升序排序
        System.out.println("\n使用sort方法后的数组:");
        for (int i = 0; i < array.length; i++) {
            // 将array数组中的数据输出
            System.out.print(" " + array[i]);
            if ((i + 1) % 5 == 0)
                System.out.println();
        }
    }
}

运行结果:

没有使用sort方法前的数组:
 13 12 11 18 11
 11 17 13 11 8
 1 0 9 18 3

使用sort方法后的数组:
 0 1 3 8 9
 11 11 11 11 12
 13 13 17 18 18

3、快速排序法

SortArray_03.java

public class SortArray_03 {
    public static void main(String args[]) {
        int[] intArray = { 12, 11, 45, 6, 8, 43, 40, 57, 3, 20, 15, 88, 23 };
        System.out.println("排序前的数组:");
        for (int i = 0; i < intArray.length; i++) {
            System.out.print(" " + intArray[i]);
            // 输出数组元素
            if ((i + 1) % 5 == 0)
                // 每5个元素一行
                System.out.println();
        }
        System.out.println();
        int[] b = quickSort(intArray, 0, intArray.length - 1);
        // 调用quickSort
        System.out.println("使用快迅排序法后的数组:");
        for (int i = 0; i < b.length; i++) {
            System.out.print(" " + b[i]);
            if ((i + 1) % 5 == 0)
                // 每5个元素一行
                System.out.println();
        }
    }
    public static int getMiddle(int[] array, int left, int right) {
        int temp;
        // 进行一趟快速排序,返回中心点位置
        int mid = array[left];
        // 把中心置于a[0]
        while (left < right) {
            while (left < right && array[right] >= mid)
                right--;
            temp = array[right];
            // 将比中心点小的数据移动到左边
            array[right] = array[left];
            array[left] = temp;
            while (left < right && array[left] <= mid)
                left++;
            temp = array[right];
            // 将比中心点大的数据移动到右边
            array[right] = array[left];
            array[left] = temp;
        }
        array[left] = mid;
        // 中心移到正确位置
        return left; // 返回中心点
    }
    public static int[] quickSort(int[] array, int left, int right) {// 快速排序法
        if (left < right - 1) {
            // 如果开始点和结点没有重叠的时候,也就是指针没有执行到结尾
            int mid = getMiddle(array, left, right);
            // 重新获取中间点
            quickSort(array, left, mid - 1);
            quickSort(array, mid + 1, right);
        }
        return array;
    }
}

运行结果:

排序前的数组:
 12 11 45 6 8
 43 40 57 3 20
 15 88 23
使用快迅排序法后的数组:
 3 6 8 11 12
 20 15 23 40 43
 45 88 57

4、选择排序法

SortArray_04.java

public class SortArray_04 {
    public static void main(String args[]) {
        int[] array = { 14, 5, 86, 4, 12, 3, 51, 13, 11, 2, 32, 6, 45, 34 };
        // 创建一个初始化的一维数组array
        int keyValue; // 表示最小的元素值
        int index; // 表示最小的元素值的下标
        int temp; // 中间变量
        System.out.println("未排序的数组:");
        for (int i = 0; i < array.length; i++) {
            // 遍历array数组中的元素
            System.out.print(" " + array[i]);
            // 输出数组元素
            if ((i + 1) % 5 == 0)
                // 每5个元素一行
                System.out.println();
        }
        for (int i = 0; i < array.length; i++) {
            // 使用选择排序法的核心
            index = i;
            keyValue = array[i];
            for (int j = i; j < array.length; j++)
                if (array[j] < keyValue) {
                    index = j;
                    keyValue = array[j];
                }
            temp = array[i];
            array[i] = array[index];
            array[index] = temp;
        }
        System.out.println("\n使用选择排序法后的数组:");
        for (int i = 0; i < array.length; i++) {
            // 遍历排好序的array数组中的元素
            System.out.print(" " + array[i]);
            // 输出数组元素
            if ((i + 1) % 5 == 0)
                System.out.println();
            // 每5个元素一行
        }
    }
}

运行结果:

未排序的数组:
 14 5 86 4 12
 3 51 13 11 2
 32 6 45 34
使用选择排序法后的数组:
 2 3 4 5 6
 11 12 13 14 32
 34 45 51 86

PS:这里再为大家推荐一款关于排序的演示工具供大家参考:

在线动画演示插入/选择/冒泡/归并/希尔/快速排序算法过程工具:
http://tools.jb51.net/aideddesign/paixu_ys

更多关于java算法相关内容感兴趣的读者可查看本站专题:《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

(0)

相关推荐

  • Java基于分治法实现的快速排序算法示例

    本文实例讲述了Java基于分治法实现的快速排序算法.分享给大家供大家参考,具体如下: package cn.nwsuaf.quick; /** * 随机产生20个数,并对其进行快速排序 * * @author 刘永浪 * */ public class Quick { /** * 交换函数,实现数组中两个数的交换操作 * * @param array * 待操作数组 * @param i * 交换数组的第一个下标 * @param j * 交换数组的第二个下标 */ public static

  • java 中归并排序算法详解

    java 中归并排序算法详解 归并排序算法,顾名思义,是一种先分再合的算法,其算法思想是将要排序的数组分解为单个的元素,每个元素就是一个单个的个体,然后将相邻的两个元素进行从小到大或从大到小的顺序排序组成一个整体,每个整体包含一到两个元素,然后对相邻的整体继续"合"并,因为每个整体都是排过序的,因而可以采用一定的算法对其进行合并,合并之后每个整体包含三到四个元素,继续对相邻的整体进行合并,直到所有的整体都合并为一个整体,最终得到的整体就是将原数组进行排序之后的结果. 对于相邻的整体,其

  • java实现的各种排序算法代码示例

    折半插入排序 折半插入排序是对直接插入排序的简单改进.此处介绍的折半插入,其实就是通过不断地折半来快速确定第i个元素的 插入位置,这实际上是一种查找算法:折半查找.Java的Arrays类里的binarySearch()方法,就是折半查找的实现,用 于从指定数组中查找指定元素,前提是该数组已经处于有序状态.与直接插入排序的效果相同,只是更快了一些,因 为折半插入排序可以更快地确定第i个元素的插入位置 代码: package interview; /** * @author Administrat

  • Java分治归并排序算法实例详解

    本文实例讲述了Java分治归并排序算法.分享给大家供大家参考,具体如下: 1.分治法 许多有用的算法在结构上是递归的:为了解决一个给定的问题,算法一次或多次递归地调用其自身以解决紧密相关的若干子问题.这些算法典型地遵循分治法的思想:将原问题分解为几个规模较小但类似于原问题的子问题,递归地求解这些子问题,然后再合并这些子问题的解来建立原问题的解. 分治模式在每层递归时都有三个步骤: (1)分解原问题为若干子问题,这些子问题是原问题的规模较小的实例. (2)解决这些子问题,递归地求解各子问题.然而,

  • Java堆排序算法详解

    堆是数据结构中的一种重要结构,了解"堆"的概念和操作,可以帮助我们快速地掌握堆排序. 堆的概念 堆是一种特殊的完全二叉树(complete binary tree).如果一棵完全二叉树的所有节点的值都不小于其子节点,称之为大根堆(或大顶堆):所有节点的值都不大于其子节点,称之为小根堆(或小顶堆). 在数组(在0号下标存储根节点)中,容易得到下面的式子(这两个式子很重要): 1.下标为i的节点,父节点坐标为(i-1)/2: 2.下标为i的节点,左子节点坐标为2*i+1,右子节点为2*i+

  • Java语言字典序排序算法解析及代码示例

    字典序法就是按照字典排序的思想逐一产生所有排列. 在数学中,字典或词典顺序(也称为词汇顺序,字典顺序,字母顺序或词典顺序)是基于字母顺序排列的单词按字母顺序排列的方法. 这种泛化主要在于定义有序完全有序集合(通常称为字母表)的元素的序列(通常称为计算机科学中的单词)的总顺序. 对于数字1.2.3......n的排列,不同排列的先后关系是从左到右逐个比较对应的数字的先后来决定的.例如对于5个数字的排列 12354和12345,排列12345在前,排列12354在后.按照这样的规定,5个数字的所有的

  • Java排序算法之归并排序简单实现

    算法描述:对于给定的一组记录,首先将每两个相邻的长度为1的子序列进行归并,得到 n/2(向上取整)个长度为2或1的有序子序列,再将其两两归并,反复执行此过程,直到得到一个有序序列. package sorting; /** * 归并排序 * 平均O(nlogn),最好O(nlogn),最坏O(nlogn);空间复杂度O(n);稳定;较复杂 * @author zeng * */ public class MergeSort { public static void merge(int[] a,

  • 快速排序算法在Java中的实现

    快速排序的原理:选择一个关键值作为基准值.比基准值小的都在左边序列(一般是无序的),比基准值大的都在右边(一般是无序的).一般选择序列的第一个元素. 一次循环:从后往前比较,用基准值和最后一个值比较,如果比基准值小的交换位置,如果没有继续比较下一个,直到找到第一个比基准值小的值才交换.找到这个值之后,又从前往后开始比较,如果有比基准值大的,交换位置,如果没有继续比较下一个,直到找到第一个比基准值大的值才交换.直到从前往后的比较索引>从后往前比较的索引,结束第一次循环,此时,对于基准值来说,左右两

  • Java数组常用排序算法实例小结

    本文实例讲述了Java数组常用排序算法.分享给大家供大家参考,具体如下: 1.冒泡排序法 SortArray_01.java public class SortArray_01 { public static void main(String args[]) { int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55, 66, 22 }; // 创建一个初始化的一维数组array System.out.println("未排序的数组:&quo

  • PHP常用排序算法实例小结【基本排序,冒泡排序,快速排序,插入排序】

    php三种基础算法:冒泡,插入和快速排序法 $array = array(2,3,5,6,9,8,1); //冒泡排序思想,前后元素比较 function sort_bulldle($array){ $num = count($array); for($i=0; $i<$num; $i++){ $tmp = $array[$i]; for ($j=$i-1; $j>=0; $j--) { if ($tmp < $array[$j]) { $arr[$j+1] = $arr[$j]; $a

  • Python实现的几个常用排序算法实例

    前段时间为准备百度面试恶补的东西,虽然最后还是被刷了,还是把那几天的"战利品"放点上来,算法一直是自己比较薄弱的地方,以后还要更加努力啊. 下面用Python实现了几个常用的排序,如快速排序,选择排序,以及二路并归排序等等. 复制代码 代码如下: #encoding=utf-8import randomfrom copy import copy def directInsertSort(seq): """ 直接插入排序 """

  • Java常用排序算法及性能测试集合

    现在再回过头理解,结合自己的体会, 选用最佳的方式描述这些算法,以方便理解它们的工作原理和程序设计技巧.本文适合做java面试准备的材料阅读. 先附上一个测试报告: Array length: 20000bubbleSort : 766 msbubbleSortAdvanced : 662 msbubbleSortAdvanced2 : 647 msselectSort : 252 msinsertSort : 218 msinsertSortAdvanced : 127 msinsertSor

  • c语言5个常用的排序算法实例代码

    1.插入排序 基本思想:插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置,直到全部插入完毕. void insertSort(vector<int>& nums) { int k = 0; for (int i = 0; i < nums.size(); ++i) { int temp = nums[i]; int j = i; for (; j > 0 && temp < nums[j-1]; --j) nums[j] =

  • 10个python3常用排序算法详细说明与实例(快速排序,冒泡排序,桶排序,基数排序,堆排序,希尔排序,归并排序,计数排序)

    我简单的绘制了一下排序算法的分类,蓝色字体的排序算法是我们用python3实现的,也是比较常用的排序算法. Python3常用排序算法 1.Python3冒泡排序--交换类排序 冒泡排序(Bubble Sort)也是一种简单直观的排序算法. 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来. 走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端. 作为最简单的排序算法

  • Java的Arrays.sort()方法排序算法实例分析

    暂时网上看过很多JDK8中Arrays.sort的底层原理,有些说是插入排序,有些说是归并排序,也有说大于域值用计数排序法,否则就使用插入排序...其实不全对.让我们分析个究竟: // Use Quicksort on small arrays if (right - left < QUICKSORT_THRESHOLD) { //QUICKSORT_THRESHOLD = 286 sort(a, left, right, true); return; } 数组一进来,会碰到第一个阀值QUICK

  • Java多种经典排序算法(含动态图)

    算法分析 一个排序算法的好坏,一般是通过下面几个关键信息来分析的,下面先介绍一下这几个关键信息,然后再将常见的排序算法的这些关键信息统计出来. 名词介绍 时间复杂度:指对数据操作的次数(或是简单的理解为某段代码的执行次数).举例:O(1):常数时间复杂度:O(log n):对数时间复杂度:O(n):线性时间复杂度. 空间复杂度:某段代码每次执行时需要开辟的内存大小. 内部排序:不依赖外部的空间,直接在数据内部进行排序: 外部排序:数据的排序,不能通过内部空间来完成,需要依赖外部空间. 稳定排序:

  • 浅谈Java常见的排序算法

    目录 一.直接插入排序 二. 希尔排序 三.冒泡排序 四.快速排序 五.选择排序(Selection Sort) 六.堆排序 七.归并排序 一.直接插入排序 基本思想: 将一个记录插入到已排序的有序表中,使插入后的表仍然有序 对初始关键字{49 38 65 97 76 13 27 49}进行直接插入排序 package Sort; //插入排序 public class InsertSort { public static void main(String[] args) { int [] ar

  • PHP实现常用排序算法的方法

    本文主要介绍了一些常用的排序算法,以及PHP的代码实现等,希望对您能有所帮助. 本文来自于awaimai.com,由火龙果软件Luca编辑推荐. 作为phper,一般接触算法的编程不多. 但基本的排序算法还是应该掌握. 毕竟算法作为程序的核心,算法的好坏决定了程序的质量. 本文将依次介绍一些常用的排序算法,以及PHP实现. 1 快速排序 快速排序是由东尼·霍尔发展的一种排序算法. 在平均状况下,排序 n 个项目要Ο(n log n)次比较. 在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见

随机推荐