java的几种经典排序算法

排序算法大致有直接插入排序、折半插入排序、Shell排序、归并排序、直接选择排序、堆排序、冒泡排序、快速排序、桶式排序、基数排序等这些种,各个算法都有其优异性,大家不妨自己看看。下面贴上每个算法的简单讲解和实现:

1.直接选择排序(DirectSelectSort):其关键就是对n个数据要进行n-1趟比较,每趟比较的目的就是选择出本趟比较中最小的数据,并将选择出的数据放在本趟中的第一位。实现如下:

[java] view plaincopy

  1. <span style="font-size:18px;">public class DirectSelectSort {
  2. //排序方法
  3. public static void directSelectSort(int[] data){
  4. int minData = 0;
  5. int index = 0;
  6. //进行n-1趟比较
  7. for(int i=0; i<data.length-1; i++){
  8. minData = data[i];
  9. index = i;
  10. for(int j=i+1; j<data.length; j++){
  11. if(minData > data[j]){
  12. minData = data[j];
  13. index = j;
  14. }
  15. }
  16. //一趟比较完后,交换一次
  17. data[index] = data[i];
  18. data[i] = minData;
  19. }
  20. }
  21. public static void main(String args[]){
  22. int data[] = {22,34,12,32,50,67,43,32};
  23. System.out.print("排序前:");
  24. for(int i=0; i<data.length; i++){
  25. System.out.print(data[i]+" ");
  26. }
  27. System.out.println();
  28. directSelectSort(data);
  29. System.out.print("排序后:");
  30. for(int i=0; i<data.length; i++){
  31. System.out.print(data[i]+" ");
  32. }
  33. }
  34. }</span>

2.堆排序(HeapSort):先说下堆的概念,假设有n个数据元素的序列k0,k1,k2,k3,...,kn-1,当且仅当满足下列关系时,可以将这组数据称为小顶堆,即ki <= k2i+1且 ki<= k2i+2(其中i=0,2,4,...,(n-1)/2);或者,满足如下关系成为大顶堆,即ki >= k2i+1且 ki >= k2i+2(其中i=0,2,...,(n-1)/2)。如果将堆排成一棵完全二叉树,则小顶堆的特点是:树中所有节点的值都小于其左右节点的值,且根节点的值最小;而大顶堆相反。堆排序的关键在于:1.建堆(大顶堆或小顶堆)2.拿堆的根节点和最后一个节点交换。

[java] view plaincopy

  1. <span style="font-size:18px;">public class HeapSort{
  2. public static void heapSort(int[] data){
  3. //循环建堆
  4. for(int i=0; i<data.length-1; i++){
  5. buildMaxHeap(data, data.length-1-i);
  6. //交换栈顶和最后一个元素
  7. swap(data, 0, data.length-1-i);
  8. }
  9. }
  10. public static void buildMaxHeap(int[] data, int lastIndex){
  11. //从最后一个节点的父节点开始
  12. for(int i=(lastIndex-1)/2; i>=0; i--){
  13. //保存当前正在判断的节点
  14. int k = i;
  15. //如果当前k节点的子节点存在
  16. while(k*2+1 <= lastIndex){
  17. int biggerIndex = 2*k+1;
  18. if(biggerIndex < lastIndex){
  19. if(data[biggerIndex] < data[biggerIndex+1]){
  20. biggerIndex++;
  21. }
  22. }
  23. if(data[k] < data[biggerIndex]){
  24. //交换
  25. swap(data, k, biggerIndex);
  26. k = biggerIndex;
  27. }else{
  28. break;
  29. }
  30. }
  31. }
  32. }
  33. public static void swap(int[] data, int i, int j){
  34. int temp = data[i];
  35. data[i] = data[j];
  36. data[j] = temp;
  37. }
  38. public static void main(String[] args){
  39. int data[] = {22,34,12,32,50,67,43,32};
  40. System.out.print("排序前:");
  41. for(int i=0; i<data.length; i++){
  42. System.out.print(data[i]+" ");
  43. }
  44. System.out.println();
  45. heapSort(data);
  46. System.out.print("排序后:");
  47. for(int i=0; i<data.length; i++){
  48. System.out.print(data[i]+" ");
  49. }
  50. }
  51. }</span>

3. 冒泡排序(BubbleSort):冒泡排序是最简单的排序算法之一,实现起来也比较简单,其原理就是进行n-1趟比较并交换,小数往上冒,大数往下沉,经过n-1趟之后形成了有序的数列。

[java] view plaincopy

  1. <span style="font-size:18px;">public class BubbleSort {
  2. public static void bubbleSort(int[] data){
  3. for(int i=0; i<data.length-1; i++){
  4. for(int j=0; j<data.length-i-1; j++){
  5. if(data[j] > data[j+1]){
  6. int temp = data[j];
  7. data[j] = data[j+1];
  8. data[j+1] = temp;
  9. }
  10. }
  11. }
  12. }
  13. public static void main(String[] args){
  14. int data[] = {22,34,12,32,50,67,43,32};
  15. System.out.print("排序前:");
  16. for(int i=0; i<data.length; i++){
  17. System.out.print(data[i]+" ");
  18. }
  19. System.out.println();
  20. bubbleSort(data);
  21. System.out.print("排序后:");
  22. for(int i=0; i<data.length; i++){
  23. System.out.print(data[i]+" ");
  24. }
  25. }
  26. }
  27. </span>

4.快速排序(QuickSort): 快速排序死对 冒泡排序的一种改进,基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

[java] view plaincopy

  1. <span style="font-size:18px;">public class QuickSort {
  2. public static void quickSort(int[] data, int start, int end){
  3. if(start < end){
  4. //以第一个元素为分界值
  5. int middleNum = data[start];
  6. int i = start;
  7. int j = end + 1;
  8. while(true){
  9. //找到大于分界值的元素的索引或者已经到了end处
  10. while(i<end && data[++i] <= middleNum);
  11. //找到小于分界值的元素的索引或者已经到了start处
  12. while(j>start && data[--j] >= middleNum);
  13. if(i < j){
  14. //交换
  15. int temp = data[i];
  16. data[i] = data[j];
  17. data[j] = temp;
  18. }else{
  19. break;
  20. }
  21. }
  22. int temp = data[start];
  23. data[start] = data[j];
  24. data[j] = temp;
  25. //递归左子序列
  26. quickSort(data, start, j-1);
  27. //递归右子序列
  28. quickSort(data, j+1, end);
  29. }
  30. }
  31. public static void main(String[] args){
  32. int data[] = {22,34,12,32,50,67,43,32};
  33. System.out.print("排序前:");
  34. for(int i=0; i<data.length; i++){
  35. System.out.print(data[i]+" ");
  36. }
  37. System.out.println();
  38. quickSort(data, 0, data.length-1);
  39. System.out.print("排序后:");
  40. for(int i=0; i<data.length; i++){
  41. System.out.print(data[i]+" ");
  42. }
  43. }
  44. }
  45. </span>

5.直接插入排序(DirectInsertSort):直接插入排序的思路很简单,就是依次将带排序的数据元素按其关键字排序的大小插入前面的有序序列。

[java] view plaincopy

    1. <span style="font-size:18px;">public class DirectInsertSort {
    2. public static void directInsertSort(int[] data){
    3. for(int i=1; i<data.length; i++){
    4. for(int j=0; j<i; j++){
    5. if(data[i] < data[j]){
    6. //保存插入元素
    7. int temp = 0;
    8. temp = data[i];
    9. //将要插入元素位置后的元素依次往后移
    10. for(int m=i; m>j; m--){
    11. data[m] = data[m-1];
    12. }
    13. //插入元素
    14. data[j] = temp;
    15. }
    16. }
    17. }
    18. }
    19. public static void main(String[] args){
    20. int data[] = {22,34,12,32,50,67,43,32};
    21. System.out.print("排序前:");
    22. for(int i=0; i<data.length; i++){
    23. System.out.print(data[i]+" ");
    24. }
    25. System.out.println();
    26. directInsertSort(data);
    27. System.out.print("排序后:");
    28. for(int i=0; i<data.length; i++){
    29. System.out.print(data[i]+" ");
    30. }
    31. }
    32. }
    33. </span>
时间: 2024-10-03 22:34:50

java的几种经典排序算法的相关文章

七种经典排序算法最全攻略

经典排序算法在面试中占有很大的比重,也是基础.包括冒泡排序,插入排序,选择排序,希尔排序,归并排序,快速排序,堆排序.希望能帮助到有需要的同学.全部程序采用JAVA实现. 本篇博客所有排序实现均默认从小到大. 一.冒泡排序 BubbleSort 介绍: 冒泡排序的原理非常简单,它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来. 步骤: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对第0个到第n-1个数据做同样的工作.这时,最大的数就"浮"到了

Jerry 2017年的五一小长假:8种经典排序算法的ABAP实现

2017年4月29日~5月1日,国际劳动节, 三天的小长假. 在国内,小长假往往是这样的: 然而我当时在戏称为"德村"(德国农村)的Walldorf出差并且住在Wiesloch, 这里的五一小长假能听见鸟叫,虫鸣,和风吹过的声音,除此之外再无其他. 街道上别说行人了,连行驶的汽车都很少. 如果一个在成都习惯了热闹生活的人,到了这种乡下地方来估计会觉得百无聊赖.当时国内有同事建议我小长假去德国其他地方转转,然而作为一个30年资深宅男,一个人出去转不是我的风格. 五一放假之前,坐我对面的一

九种经典排序算法汇总

/*********************************************************** 总结各种排序算法包括但不限于: 1. 插入排序类 1.1 直接插入排序 1.2 二分插入排序 1.3 希尔排序 2. 交换排序类 2.1 冒泡排序 2.2 快速排序 3. 选择排序 3.1 直接选择排序 3.2 堆排序 4. 归并排序 5. 基数排序 以上所有排序算法的实现均为将整形数组data递增排序 ************************************

九种经典排序算法详解(冒泡排序,插入排序,选择排序,快速排序,归并排序,堆排序,计数排序,桶排序,基数排序)

综述 最近复习了各种排序算法,记录了一下学习总结和心得,希望对大家能有所帮助.本文介绍了冒泡排序.插入排序.选择排序.快速排序.归并排序.堆排序.计数排序.桶排序.基数排序9种经典的排序算法.针对每种排序算法分析了算法的主要思路,每个算法都附上了伪代码和C++实现. 算法分类 原地排序(in-place):没有使用辅助数据结构来存储中间结果的排序**算法. 非原地排序(not-in-place / out-of-place):使用了辅助数据结构来存储中间结果的排序算法 稳定排序:数列值(key)

几种经典排序算法的R语言描述

1.数据准备 # 测试数组 vector = c(5,34,65,36,67,3,6,43,69,59,25,785,10,11,14) vector ## [1] 5 34 65 36 67 3 6 43 69 59 25 785 10 11 14 2.R语言内置排序函数 在R中和排序相关的函数主要有三个:sort(),rank(),order(). sort(x)是对向量x进行排序,返回值排序后的数值向量; rank()是求秩的函数,它的返回值是这个向量中对应元素的“排名”; order()

Java中几种常见排序算法

日常操作中常见的排序方法有:冒泡排序.快速排序.选择排序.插入排序.希尔排序等. 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. * 冒泡法排序 * 比较相邻的元素.如果第一个比第二个大,就交换他们两个. * 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应

Java实现9种常见排序算法

常见的排序算法有冒泡排序.选择排序.插入排序.堆排序.归并排序.快速排序.希尔排序.基数排序.计数排序,下面通过Java实现这些排序 1.冒泡排序 package com.buaa; import java.util.Arrays; /** * @ProjectName SortingAlgorithm * @PackageName com.buaa * @ClassName BubbleSort * @Description 冒泡排序 * @Author 刘吉超 * @Date 2016-05

8种经典排序算法总结

1.二分查找 代码: int binarySearch(int arr[],int l,int r,int x) { while(l <= r) { int m = l + (r-1)/2;//为了防止(l+r溢出) if(arr[m] == x) return m; if(arr[m] < x) l = m + 1; else r = m - 1; } return -1; } 问题扩展1:给定一个有序的数组,用最少的比较次数找出给定的元素. 代码: int binarySearch(int

经典排序算法的零基础通俗讲解

一.几种经典排序算法的排序过程及时间复杂度 冒泡:时间复杂度O(n²) 第一个数和第二个数比较,大的放在后边,然后第二个数再和第三个数比较,大的放在后面.以此类推. 选择:时间复杂度O(n²): 0到n-1里找最小值放位置0上:1到n-1里找最小值放位置1上 以此类推 插入:时间复杂度O(n²) 一个数 和他前边的数比较 如果大于那个数就放在那个数后面 如果比那个数小就一直往前比较 直到比某个数大就放在那个数后面.如果都没有就放在首位置. 时间复杂度:O(N*logN) : 归并排序,快速排序,