常见的八种排序算法Java实现记录

常见的八种排序算法Java实现记录

测试用数据集生成源码

这里取1-1999的数，按1000-1,1000-1999两部分奇偶交错，生成4部分等差数列

public static void main(String args[]) {
        for (int i = 1001; i > 0; i -= 2) {
            System.out.print(i + ",");
        }
        for (int i = 1003; i < 2000; i += 2) {
            System.out.print(i + ",");
        }
        for (int i = 1002; i > 1; i -= 2) {
            System.out.print(i + ",");
        }
        for (int i = 1004; i < 2000; i += 2) {
            System.out.print(i + ",");
        }
    }

生成的数据集如下：

	//排序数据集
    public static final int[] list1 = { 1001, 999, 997, 995, 993, 991, 989, 987, 985, 983, 981, 979, 977, 975, 973, 971, 969, 967,
            965, 963, 961, 959, 957, 955, 953, 951, 949, 947, 945, 943, 941, 939, 937, 935, 933, 931, 929, 927, 925, 923, 921,
            919, 917, 915, 913, 911, 909, 907, 905, 903, 901, 899, 897, 895, 893, 891, 889, 887, 885, 883, 881, 879, 877, 875,
            873, 871, 869, 867, 865, 863, 861, 859, 857, 855, 853, 851, 849, 847, 845, 843, 841, 839, 837, 835, 833, 831, 829,
            827, 825, 823, 821, 819, 817, 815, 813, 811, 809, 807, 805, 803, 801, 799, 797, 795, 793, 791, 789, 787, 785, 783,
            781, 779, 777, 775, 773, 771, 769, 767, 765, 763, 761, 759, 757, 755, 753, 751, 749, 747, 745, 743, 741, 739, 737,
            735, 733, 731, 729, 727, 725, 723, 721, 719, 717, 715, 713, 711, 709, 707, 705, 703, 701, 699, 697, 695, 693, 691,
            689, 687, 685, 683, 681, 679, 677, 675, 673, 671, 669, 667, 665, 663, 661, 659, 657, 655, 653, 651, 649, 647, 645,
            643, 641, 639, 637, 635, 633, 631, 629, 627, 625, 623, 621, 619, 617, 615, 613, 611, 609, 607, 605, 603, 601, 599,
            597, 595, 593, 591, 589, 587, 585, 583, 581, 579, 577, 575, 573, 571, 569, 567, 565, 563, 561, 559, 557, 555, 553,
            551, 549, 547, 545, 543, 541, 539, 537, 535, 533, 531, 529, 527, 525, 523, 521, 519, 517, 515, 513, 511, 509, 507,
            505, 503, 501, 499, 497, 495, 493, 491, 489, 487, 485, 483, 481, 479, 477, 475, 473, 471, 469, 467, 465, 463, 461,
            459, 457, 455, 453, 451, 449, 447, 445, 443, 441, 439, 437, 435, 433, 431, 429, 427, 425, 423, 421, 419, 417, 415,
            413, 411, 409, 407, 405, 403, 401, 399, 397, 395, 393, 391, 389, 387, 385, 383, 381, 379, 377, 375, 373, 371, 369,
            367, 365, 363, 361, 359, 357, 355, 353, 351, 349, 347, 345, 343, 341, 339, 337, 335, 333, 331, 329, 327, 325, 323,
            321, 319, 317, 315, 313, 311, 309, 307, 305, 303, 301, 299, 297, 295, 293, 291, 289, 287, 285, 283, 281, 279, 277,
            275, 273, 271, 269, 267, 265, 263, 261, 259, 257, 255, 253, 251, 249, 247, 245, 243, 241, 239, 237, 235, 233, 231,
            229, 227, 225, 223, 221, 219, 217, 215, 213, 211, 209, 207, 205, 203, 201, 199, 197, 195, 193, 191, 189, 187, 185,
            183, 181, 179, 177, 175, 173, 171, 169, 167, 165, 163, 161, 159, 157, 155, 153, 151, 149, 147, 145, 143, 141, 139,
            137, 135, 133, 131, 129, 127, 125, 123, 121, 119, 117, 115, 113, 111, 109, 107, 105, 103, 101, 99, 97, 95, 93, 91, 89,
            87, 85, 83, 81, 79, 77, 75, 73, 71, 69, 67, 65, 63, 61, 59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35, 33, 31,
            29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1, 1003, 1005, 1007, 1009, 1011, 1013, 1015, 1017, 1019, 1021,
            1023, 1025, 1027, 1029, 1031, 1033, 1035, 1037, 1039, 1041, 1043, 1045, 1047, 1049, 1051, 1053, 1055, 1057, 1059,
            1061, 1063, 1065, 1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085, 1087, 1089, 1091, 1093, 1095, 1097,
            1099, 1101, 1103, 1105, 1107, 1109, 1111, 1113, 1115, 1117, 1119, 1121, 1123, 1125, 1127, 1129, 1131, 1133, 1135,
            1137, 1139, 1141, 1143, 1145, 1147, 1149, 1151, 1153, 1155, 1157, 1159, 1161, 1163, 1165, 1167, 1169, 1171, 1173,
            1175, 1177, 1179, 1181, 1183, 1185, 1187, 1189, 1191, 1193, 1195, 1197, 1199, 1201, 1203, 1205, 1207, 1209, 1211,
            1213, 1215, 1217, 1219, 1221, 1223, 1225, 1227, 1229, 1231, 1233, 1235, 1237, 1239, 1241, 1243, 1245, 1247, 1249,
            1251, 1253, 1255, 1257, 1259, 1261, 1263, 1265, 1267, 1269, 1271, 1273, 1275, 1277, 1279, 1281, 1283, 1285, 1287,
            1289, 1291, 1293, 1295, 1297, 1299, 1301, 1303, 1305, 1307, 1309, 1311, 1313, 1315, 1317, 1319, 1321, 1323, 1325,
            1327, 1329, 1331, 1333, 1335, 1337, 1339, 1341, 1343, 1345, 1347, 1349, 1351, 1353, 1355, 1357, 1359, 1361, 1363,
            1365, 1367, 1369, 1371, 1373, 1375, 1377, 1379, 1381, 1383, 1385, 1387, 1389, 1391, 1393, 1395, 1397, 1399, 1401,
            1403, 1405, 1407, 1409, 1411, 1413, 1415, 1417, 1419, 1421, 1423, 1425, 1427, 1429, 1431, 1433, 1435, 1437, 1439,
            1441, 1443, 1445, 1447, 1449, 1451, 1453, 1455, 1457, 1459, 1461, 1463, 1465, 1467, 1469, 1471, 1473, 1475, 1477,
            1479, 1481, 1483, 1485, 1487, 1489, 1491, 1493, 1495, 1497, 1499, 1501, 1503, 1505, 1507, 1509, 1511, 1513, 1515,
            1517, 1519, 1521, 1523, 1525, 1527, 1529, 1531, 1533, 1535, 1537, 1539, 1541, 1543, 1545, 1547, 1549, 1551, 1553,
            1555, 1557, 1559, 1561, 1563, 1565, 1567, 1569, 1571, 1573, 1575, 1577, 1579, 1581, 1583, 1585, 1587, 1589, 1591,
            1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609, 1611, 1613, 1615, 1617, 1619, 1621, 1623, 1625, 1627, 1629,
            1631, 1633, 1635, 1637, 1639, 1641, 1643, 1645, 1647, 1649, 1651, 1653, 1655, 1657, 1659, 1661, 1663, 1665, 1667,
            1669, 1671, 1673, 1675, 1677, 1679, 1681, 1683, 1685, 1687, 1689, 1691, 1693, 1695, 1697, 1699, 1701, 1703, 1705,
            1707, 1709, 1711, 1713, 1715, 1717, 1719, 1721, 1723, 1725, 1727, 1729, 1731, 1733, 1735, 1737, 1739, 1741, 1743,
            1745, 1747, 1749, 1751, 1753, 1755, 1757, 1759, 1761, 1763, 1765, 1767, 1769, 1771, 1773, 1775, 1777, 1779, 1781,
            1783, 1785, 1787, 1789, 1791, 1793, 1795, 1797, 1799, 1801, 1803, 1805, 1807, 1809, 1811, 1813, 1815, 1817, 1819,
            1821, 1823, 1825, 1827, 1829, 1831, 1833, 1835, 1837, 1839, 1841, 1843, 1845, 1847, 1849, 1851, 1853, 1855, 1857,
            1859, 1861, 1863, 1865, 1867, 1869, 1871, 1873, 1875, 1877, 1879, 1881, 1883, 1885, 1887, 1889, 1891, 1893, 1895,
            1897, 1899, 1901, 1903, 1905, 1907, 1909, 1911, 1913, 1915, 1917, 1919, 1921, 1923, 1925, 1927, 1929, 1931, 1933,
            1935, 1937, 1939, 1941, 1943, 1945, 1947, 1949, 1951, 1953, 1955, 1957, 1959, 1961, 1963, 1965, 1967, 1969, 1971,
            1973, 1975, 1977, 1979, 1981, 1983, 1985, 1987, 1989, 1991, 1993, 1995, 1997, 1999, 1002, 1000, 998, 996, 994, 992,
            990, 988, 986, 984, 982, 980, 978, 976, 974, 972, 970, 968, 966, 964, 962, 960, 958, 956, 954, 952, 950, 948, 946,
            944, 942, 940, 938, 936, 934, 932, 930, 928, 926, 924, 922, 920, 918, 916, 914, 912, 910, 908, 906, 904, 902, 900,
            898, 896, 894, 892, 890, 888, 886, 884, 882, 880, 878, 876, 874, 872, 870, 868, 866, 864, 862, 860, 858, 856, 854,
            852, 850, 848, 846, 844, 842, 840, 838, 836, 834, 832, 830, 828, 826, 824, 822, 820, 818, 816, 814, 812, 810, 808,
            806, 804, 802, 800, 798, 796, 794, 792, 790, 788, 786, 784, 782, 780, 778, 776, 774, 772, 770, 768, 766, 764, 762,
            760, 758, 756, 754, 752, 750, 748, 746, 744, 742, 740, 738, 736, 734, 732, 730, 728, 726, 724, 722, 720, 718, 716,
            714, 712, 710, 708, 706, 704, 702, 700, 698, 696, 694, 692, 690, 688, 686, 684, 682, 680, 678, 676, 674, 672, 670,
            668, 666, 664, 662, 660, 658, 656, 654, 652, 650, 648, 646, 644, 642, 640, 638, 636, 634, 632, 630, 628, 626, 624,
            622, 620, 618, 616, 614, 612, 610, 608, 606, 604, 602, 600, 598, 596, 594, 592, 590, 588, 586, 584, 582, 580, 578,
            576, 574, 572, 570, 568, 566, 564, 562, 560, 558, 556, 554, 552, 550, 548, 546, 544, 542, 540, 538, 536, 534, 532,
            530, 528, 526, 524, 522, 520, 518, 516, 514, 512, 510, 508, 506, 504, 502, 500, 498, 496, 494, 492, 490, 488, 486,
            484, 482, 480, 478, 476, 474, 472, 470, 468, 466, 464, 462, 460, 458, 456, 454, 452, 450, 448, 446, 444, 442, 440,
            438, 436, 434, 432, 430, 428, 426, 424, 422, 420, 418, 416, 414, 412, 410, 408, 406, 404, 402, 400, 398, 396, 394,
            392, 390, 388, 386, 384, 382, 380, 378, 376, 374, 372, 370, 368, 366, 364, 362, 360, 358, 356, 354, 352, 350, 348,
            346, 344, 342, 340, 338, 336, 334, 332, 330, 328, 326, 324, 322, 320, 318, 316, 314, 312, 310, 308, 306, 304, 302,
            300, 298, 296, 294, 292, 290, 288, 286, 284, 282, 280, 278, 276, 274, 272, 270, 268, 266, 264, 262, 260, 258, 256,
            254, 252, 250, 248, 246, 244, 242, 240, 238, 236, 234, 232, 230, 228, 226, 224, 222, 220, 218, 216, 214, 212, 210,
            208, 206, 204, 202, 200, 198, 196, 194, 192, 190, 188, 186, 184, 182, 180, 178, 176, 174, 172, 170, 168, 166, 164,
            162, 160, 158, 156, 154, 152, 150, 148, 146, 144, 142, 140, 138, 136, 134, 132, 130, 128, 126, 124, 122, 120, 118,
            116, 114, 112, 110, 108, 106, 104, 102, 100, 98, 96, 94, 92, 90, 88, 86, 84, 82, 80, 78, 76, 74, 72, 70, 68, 66, 64,
            62, 60, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4,
            2, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, 1040,
            1042, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078,
            1080, 1082, 1084, 1086, 1088, 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1108, 1110, 1112, 1114, 1116,
            1118, 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154,
            1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192,
            1194, 1196, 1198, 1200, 1202, 1204, 1206, 1208, 1210, 1212, 1214, 1216, 1218, 1220, 1222, 1224, 1226, 1228, 1230,
            1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, 1256, 1258, 1260, 1262, 1264, 1266, 1268,
            1270, 1272, 1274, 1276, 1278, 1280, 1282, 1284, 1286, 1288, 1290, 1292, 1294, 1296, 1298, 1300, 1302, 1304, 1306,
            1308, 1310, 1312, 1314, 1316, 1318, 1320, 1322, 1324, 1326, 1328, 1330, 1332, 1334, 1336, 1338, 1340, 1342, 1344,
            1346, 1348, 1350, 1352, 1354, 1356, 1358, 1360, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1378, 1380, 1382,
            1384, 1386, 1388, 1390, 1392, 1394, 1396, 1398, 1400, 1402, 1404, 1406, 1408, 1410, 1412, 1414, 1416, 1418, 1420,
            1422, 1424, 1426, 1428, 1430, 1432, 1434, 1436, 1438, 1440, 1442, 1444, 1446, 1448, 1450, 1452, 1454, 1456, 1458,
            1460, 1462, 1464, 1466, 1468, 1470, 1472, 1474, 1476, 1478, 1480, 1482, 1484, 1486, 1488, 1490, 1492, 1494, 1496,
            1498, 1500, 1502, 1504, 1506, 1508, 1510, 1512, 1514, 1516, 1518, 1520, 1522, 1524, 1526, 1528, 1530, 1532, 1534,
            1536, 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1554, 1556, 1558, 1560, 1562, 1564, 1566, 1568, 1570, 1572,
            1574, 1576, 1578, 1580, 1582, 1584, 1586, 1588, 1590, 1592, 1594, 1596, 1598, 1600, 1602, 1604, 1606, 1608, 1610,
            1612, 1614, 1616, 1618, 1620, 1622, 1624, 1626, 1628, 1630, 1632, 1634, 1636, 1638, 1640, 1642, 1644, 1646, 1648,
            1650, 1652, 1654, 1656, 1658, 1660, 1662, 1664, 1666, 1668, 1670, 1672, 1674, 1676, 1678, 1680, 1682, 1684, 1686,
            1688, 1690, 1692, 1694, 1696, 1698, 1700, 1702, 1704, 1706, 1708, 1710, 1712, 1714, 1716, 1718, 1720, 1722, 1724,
            1726, 1728, 1730, 1732, 1734, 1736, 1738, 1740, 1742, 1744, 1746, 1748, 1750, 1752, 1754, 1756, 1758, 1760, 1762,
            1764, 1766, 1768, 1770, 1772, 1774, 1776, 1778, 1780, 1782, 1784, 1786, 1788, 1790, 1792, 1794, 1796, 1798, 1800,
            1802, 1804, 1806, 1808, 1810, 1812, 1814, 1816, 1818, 1820, 1822, 1824, 1826, 1828, 1830, 1832, 1834, 1836, 1838,
            1840, 1842, 1844, 1846, 1848, 1850, 1852, 1854, 1856, 1858, 1860, 1862, 1864, 1866, 1868, 1870, 1872, 1874, 1876,
            1878, 1880, 1882, 1884, 1886, 1888, 1890, 1892, 1894, 1896, 1898, 1900, 1902, 1904, 1906, 1908, 1910, 1912, 1914,
            1916, 1918, 1920, 1922, 1924, 1926, 1928, 1930, 1932, 1934, 1936, 1938, 1940, 1942, 1944, 1946, 1948, 1950, 1952,
            1954, 1956, 1958, 1960, 1962, 1964, 1966, 1968, 1970, 1972, 1974, 1976, 1978, 1980, 1982, 1984, 1986, 1988, 1990,
            1992, 1994, 1996, 1998 };

提取出的通用数组换位方法，后续会用到

	/**
     * 数组的i位和j位互换
     */
    private static void swap(int[] list, int i, int j) {
        int temp = list[i];
        list[i] = list[j];
        list[j] = temp;
    }

冒泡排序

复杂度 O(n²)
每个位置和下一个位置比较，如果根据升序判断是否互换，一直到最后一个，
这样一轮之后，最后一个就是最大的
然后第二轮，倒数第二个就是最大的，然后一直泡泡到第一个位置

    public static void bubbleSort(int[] list) {
        int length = list.length;
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - i - 1; j++) {
                if (list[j] > list[j + 1]) {
                    swap(list, j, j + 1);
                }
            }
        }
    }

选择排序

复杂度 O(n*(n-1)/2)
选出最小的放第一个，然后再最小的放第二个，类推

public static void chooseSort(int[] list) {
        int length = list.length;
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (list[i] > list[j]) {
                    swap(list, i, j);
                }
            }
        }
    }

插入排序

复杂度 O(n²)
类似扑克牌，每张都插入到范围的两张之间，保证排序

public static void insertSort(int[] list) {
        int cur;
        for (int i = 1; i < list.length; i++) {
            //先把需要插入的第i位元素提取出来
            cur = list[i];

            //待插入位置，初始化为已经排列好的元素的最后一位
            int j = i - 1;
            while (j >= 0 && list[j] > cur) {  //只要还有未比较元素，就跟待插入元素进行比较
                list[j + 1] = list[j];  //后移一位
                j--;
            }

            //这个时候，j位的元素比待插入元素要小了，放入j+1的空位
            list[j + 1] = cur;
        }
    }

希尔排序

对于直接插入排序问题，数据量巨大时使用
复杂度 O(n^(1.3—2))性能较由于插入排序

1、将数的个数设为n，取奇数k=n/2，将下标差值为k的书分为一组，构成有序序列。
2、再取k=k/2 ，将下标差值为k的书分为一组，构成有序序列。
3、重复第二步，直到k=1执行简单插入排序。

public static void sheelSort(int[] list) {
        int length = list.length;
        int cur;
        for (int gap = length / 2; gap > 1; gap = gap / 2) {
            for (int i = 0; i < gap; i++) {
                for (int j = i + gap; j < length; j += gap) {  //这里的算法参照直接插入排序
                    //先把需要插入的第j位元素提取出来
                    cur = list[j];

                    //待插入位置，初始化为已经排列好的元素的最后一位
                    int k = j - gap;
                    while (k >= 0 && list[k] > cur) {  //只要还有未比较元素，就跟待插入元素进行比较
                        list[k + gap] = list[k];  //后移一位
                        k -= gap;
                    }

                    //这个时候，k位的元素比待插入元素要小了，放入k + gap的空位
                    list[k + gap] = cur;
                }
            }
        }
        insertSort(list);
    }

快速排序

复杂度 O(nlogn)
1、选择第一个数为p，小于p的数放在左边，大于p的数放在右边。
2、递归的将p左边和右边的数都按照第一步进行，直到不能递归。

	public static void fastSort(int[] list) {
        fastSort(list, 0, list.length - 1);
    }

    /**
     * 快速排序的递归实现
     *
     * @param begin 第一位，闭区间，包括在内
     * @param end   最后一位，闭区间，包括在内
     */
    private static void fastSort(int[] list, int begin, int end) {
        //以第一位数作为参照数
        int beginNum = list[begin];

        int left = 0;  //参照数左边的已有数字
        int right = 0; //参照数右边的已有数字

        int cur;
        for (int i = begin + 1; i <= end; i++) {
            if (list[i] < beginNum) {
                cur = list[i];
                for (int j = i; j > begin + left; j--) {
                    list[j] = list[j - 1];  //从左侧已有数的最后一位，到当前数的位置，全部右移一位
                }
                list[begin + left] = cur;
                left++;
            } else {
                right++;  //右侧数无需移位
            }
        }
        if (left > 1) {
            fastSort(list, begin, begin + left);  //对参照数左边进行排序
        }
        if (right > 1) {
            fastSort(list, begin + left + 1, end); //对参照数右边进行排序
        }
    }

归并排序

复杂度 O(nlogn)
将一个数组分为多个2元素的数组，使每部分有序，然后两两合并成4元素部分，递归到整个数组有序

两个有序数组的合并，为分别在两个数组的起始位置标记指针，分别对指针标记的位置的值进行比较
取较小的值，并将指针往后移动，直至指针移到数组的尾部

	public static void mergeSort(int[] list) {
        for (int range = 1; range < list.length; range *= 2) {  //递归的对数组进行归并
            for (int i = 0; i < list.length; i += 2 * range) {
                mergeSort(list, range, i);
            }
        }
    }
    
	/**
     * 归并排序的递归实现
     *
     * @param range 范围
     * @param begin 开始位置
     * @param end   结束位置
     */
    private static void mergeSort(int[] list, int range, int begin) {
        if (begin + range > list.length - 1) {
            return;
        }
        int length = list.length;

        int cur;
        int firstPointer = 0;  //第一个数组的指针
        int secondPointer = 0; //第二个数组的指针

        int[] mergeList = new int[Math.min(2 * range, length - begin)];
        for (int i = 0; i < mergeList.length; i++) {
            if (firstPointer < range && (begin + range + secondPointer < length && secondPointer < range)) {
                //序列1和序列2都在范围内
                if (list[begin + firstPointer] < list[begin + range + secondPointer]) {
                    cur = list[begin + firstPointer];
                    firstPointer++;
                } else {
                    cur = list[begin + range + secondPointer];
                    secondPointer++;
                }
            } else if (firstPointer >= range && (begin + range + secondPointer < length && secondPointer < range)) {
                //只有序列2还在范围内
                cur = list[begin + range + secondPointer];
                secondPointer++;
            } else if (firstPointer < range && (begin + range + secondPointer >= length || secondPointer >= range)) {
                //只有序列1还在范围内
                cur = list[begin + firstPointer];
                firstPointer++;
            } else {
                continue; //都超出范围了就跳过
            }
            mergeList[i] = cur;
        }

        //用归并后的新数组覆盖原数组
        for (int k = 0; k < mergeList.length; k++) {
            list[begin + k] = mergeList[k];
        }
    }

基数排序

复杂度 O(nlog(r）m)， r表示基数（10进制的基数就是10），m表示堆数（数据集的最大位数）
按个位比较，放入0-9 的九个桶中，然后取出，再按十位比较，以此类推，直到最大位数

	public static void radixSort(int[] list) {
        if (list.length == 0) {
            return;
        }
        //最大位数，即需要放入桶的次数
        int maxRadix = Arrays.stream(list).map(i -> String.valueOf(i).length()).max().getAsInt();

        //定义一个桶，对应0-9位数所
        Map<Integer, List<Integer>> drumMap;

        //基数
        int radix;
        for (int i = 0; i < maxRadix; i++) {
            drumMap = new HashMap<>();
            radix = getRadix(i);

            for (int l : list) {
                //所在桶的位置
                int num = (l % radix) / (radix / 10);

                List<Integer> curNumList = drumMap.getOrDefault(num, new ArrayList<>());
                curNumList.add(l);
                drumMap.put(num, curNumList);
            }
            int pointer = 0;
            for (int j = 0; j < 10; j++) {
                if (!drumMap.containsKey(j)) {
                    continue;
                }
                for (Integer num : drumMap.get(j)) {
                    list[pointer] = num;
                    pointer++;
                }
            }
        }
    }

    /**
     * 获取当前的基数
     */
    private static int getRadix(int i) {
        int radix = 10;
        for (int j = 0; j < i; j++) {
            radix *= 10;
        }
        return radix;
    }

堆排序

复杂度 O (nlogn)
对简单选择排序的优化

1、将序列构建成大顶堆。
2、将根节点与最后一个节点交换，然后断开最后一个节点。
3、重复第一、二步，直到所有节点断开。

	public static void heapSort(int[] list) {
        int length = list.length;
        for (int i = 0; i < length - 1; i++) {
            int maxLength = length - 1 - i;

            //从0到length-1建大顶堆
            buildHeap(list, maxLength);

            //堆的首位和末尾换位，保证末位为最大值
            swap(list, 0, maxLength);
        }
    }

    /**
     * 构造大顶堆
     */
    private static void buildHeap(int[] list, int maxLength) {
        int cur;
        int curParent;
        for (int i = maxLength + 1; i > 1; i--) {
            cur = list[i - 1];
            curParent = list[i / 2 - 1];
            if (cur > curParent) {
                swap(list, i - 1, i / 2 - 1);
            }
        }
    }

用于验证排序、记录排序性能的main方法

public static void main(String args[]) {
        //        int[] list = { 1, 3, 5, 7, 2, 4, 6 };
        int[] list = Arrays.copyOf(list1, 1999);

        long start = System.currentTimeMillis();
        //        bubbleSort(list); //冒泡排序 7-12ms
        //        chooseSort(list); //选择排序 5-9ms
        //        insertSort(list); //插入排序 4-6ms
        //        sheelSort(list);  //希尔排序 1-2ms
        //        fastSort(list);   //快速排序 6-7ms
        //        mergeSort(list);  //归并排序 1ms
        //        radixSort(list);  //基数排序 6-8ms
        //        heapSort(list);   //堆排序   10-20ms
        System.out.println((System.currentTimeMillis() - start) + "ms");
        for (int i : list) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

上述排序方法耗时仅在个人机器上运行，不同机器JVM运行性能不同，结果仅供参考
有兴趣可以构造更大的数据集，对性能进行验证