热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

开发笔记:9.八大排序

篇首语:本文由编程笔记#小编为大家整理,主要介绍了9.八大排序相关的知识,希望对你有一定的参考价值。 一、冒泡排序: 1 package com.duan.array; 2 3 import jav

篇首语:本文由编程笔记#小编为大家整理,主要介绍了9.八大排序相关的知识,希望对你有一定的参考价值。



一、冒泡排序


1 package com.duan.array;
2
3 import java.util.Arrays;
4 //两两比较,大的往后边放,经过一轮比较,最大的元素就会出现在最后面。
5 public class BubbleSort {
6 public static void main(String[] args) {
7 int [] arr={24,69,80,57,13};
8 //i代表比较轮次
9 for (int i = 0; i ) {
10 for (int j = 0; j ) {
11 //arr[j]代表要比较的元素,arr[j+1]代表它后边的元素
12 if(arr[j]>arr[j+1]){
13 int t=arr[j];
14 arr[j]=arr[j+1];
15 arr[j+1]=t;
16 }
17 }
18 }
19 System.out.println(Arrays.toString(arr));
20 }
21 }


二、选择排序:


1 package com.duan.array;
2
3 import java.util.Arrays;
4 //每一次拿一个元素,跟后面的元素挨个比较,小的往前换,经过一轮后,最小的就会换在最前面
5 public class SelectSort {
6 public static void main(String[] args) {
7 int [] arr={24,69,80,57,13};
8 for (int index = 0; index //index代表比较轮次和要比较元素的索引
9 for (int j = 1+index; j ) {
10 //j=1+index 下一个元素的索引,不用和自己比。
11 //arr[index]代表要比较的元素,arr[j]表示下一个元素
12 if(arr[index]>arr[j]) {
13 int t = arr[index];
14 arr[index] = arr[j];
15 arr[j] = t;
16 }
17 }
18 }
19 System.out.println(Arrays.toString(arr));
20 }
21 }


三、直接插入:


1 package com.duan.array;
2
3 import java.util.Arrays;
4 //将后面的元素,插入之前的有序列表,使其仍然保持有序。
5 public class StraightInsertionSort {
6 public static void main(String[] args) {
7 int []arr={1,2,0,3,4,6,10,-1};
8 Sort1(arr);
9 System.out.println(Arrays.toString(arr));
10 sort2(arr);
11 System.out.println(Arrays.toString(arr));
12 }
13
14 private static void sort2(int[] arr) {
15 //外层控制循环次数
16 for (int i = 0; i ) {
17 //里边比前一项小就换,直到有序为止。
18 for (int j = i; j >0; j--) {
19 if(arr[j]]){
20 int t=arr[j];
21 arr[j]=arr[j-1];
22 arr[j-1]=t;
23 }
24 }
25 }
26 }
27
28 private static void Sort1(int[] arr) {
29 for (int i = 1; i ) {
30 int j=i;
31 while (j>0&&arr[j]]){
32 int t=arr[j];
33 arr[j]=arr[j-1];
34 arr[j-1]=t;
35 j--;
36 }
37 }
38 }
39 }


四、希尔排序:

技术图片

 

 


1 package com.duan.array;
2
3 import java.util.Arrays;
4 //选择一个合适的增量,经过一轮插入排序后,让数组大致有序,然后缩小增量进行插入排序,直到增量为1结束排序。
5 public class ShellSort {
6 public static void main(String[] args) {
7 int[] arr={46,55,13,42,17,94,5,70};
8 //kunth克努特序列选增量
9 int zengliang =1;
10 while (zengliang){
11 zengliang=3*zengliang+1;
12 }
13 //增量为一半h=arr.lenth/2;
14 for (int h = zengliang; h >0; h=(h-1)/3) {
15 for (int i =h; i ) {
16 //j>增量-1;j=j-zengliang;
17 for (int j = i; j >h-1; j-=h) {
18 if(arr[j]h]) {
19 int t = arr[j];
20 arr[j] = arr[j-h];
21 arr[j-h] = t;
22 }
23 }
24 }
25 }
26 System.out.println(Arrays.toString(arr));
27 }
28 }


五、快速排序:

技术图片

 

 


1 package com.duan.array;
2
3 import java.util.Arrays;
4 //比大小再分区。从数组中取出一个数,作为基准数,将大的数放右边,小的放左边。
5 //再对左右分区重复第二步,直到各分区只有一个数为止。
6 //挖坑填数。
7 //1.挖出一个基准数,形成第一个坑。
8 //2.从后往前挖比它小的数填到上一个坑中(挖基准数的坑)
9 //3.从前往后挖一个大于或等于它的数填到上一个坑中
10 //4.重复2.3步。
11 public class QuickSort {
12 public static void main(String[] args) {
13 int[]arr={2,3,5,8,4,1,7,6,9,10};
14 chaifen(arr,0,arr.length-1);
15 System.out.println(Arrays.toString(arr));
16 }
17
18 private static void chaifen(int[] arr, int start, int end) {
19 if(start<end){
20 int index=getIndex(arr,start,end);
21 //左右拆分
22 chaifen(arr,start,index-1);
23 chaifen(arr,index+1,end);
24 }
25 }
26
27 /**
28 * @param arr 传进来的数组
29 * @param start 开始索引
30 * @param end 结束索引
31 * @return 返回基准数的索引
32 */
33 private static int getIndex(int[] arr, int start, int end) {
34 //定义起始结束索引
35 int i=start;
36 int j=end;
37 //定义基准数
38 int x=arr[i];
39 //循环
40 while (i<j){
41 //从后往前找比基准数小的数
42 while(i=x){
43 j--;
44 }
45 //填数到上一个坑中
46 if(i<j){
47 arr[i]=arr[j];
48 i++;
49 }
50 //从前往后找大于等于基准数的数
51 while(ix){
52 i++;
53 }
54 //填数到上一个坑中
55 if(i<j){
56 arr[j]=arr[i];
57 j--;
58 }
59 }
60 //循环结束,把基准数填进最后一个坑(i=j)中,也就以基准数为界限分成左右两部分
61 arr[i]=x;//填进去
62 return i;//返回基准数所在位置的索引
63 }
64 }


六、归并排序:

技术图片

 

 


1 package com.duan.array;
2
3 import java.util.Arrays;
4 //分而治之。假设初始序列有N个记录,则可以看成N个有序的子序列,每个子序列的长度为1,然后两两合并得到一个N/2
5 //个长度为2或1的有序子序列,再两两归并...如此重复直到得到一个长度为N的有序序列为止。
6 public class MergeSort {
7 public static void main(String[] args) {
8 int[]arr={2,3,5,8,4,1,7,6,9,10};
9 chaifen(arr,0,arr.length-1);
10 System.out.println(Arrays.toString(arr));
11 }
12
13 private static void chaifen(int[] arr, int startIndex, int endIndex) {
14 int centerIndex=(startIndex+endIndex)/2;
15 if(startIndex<endIndex){
16 //左边递归拆
17 chaifen(arr,startIndex,centerIndex);
18 //右边递归拆
19 chaifen(arr,centerIndex+1,endIndex);
20 //合并
21 hebing(arr,startIndex,centerIndex,endIndex);
22 }
23 }
24
25 private static void hebing(int[] arr, int startIndex, int centerIndex, int endIndex) {
26 //定义一个临时数组
27 int[] tempArray=new int [endIndex-startIndex+1];
28 //定义临时数组起始索引
29 int index=0;
30 //定义第一个数组起始索引
31 int i=startIndex;
32 //定义第二个数组起始索引
33 int j=centerIndex+1;
34 //遍历数组开始归并
35 while(i<=centerIndex&&j<=endIndex){
36 if(arr[i]<=arr[j]){
37 tempArray[index]=arr[i];
38 i++;//增加索引
39 }else{
40 tempArray[index]=arr[j];
41 j++;//增加索引
42 }
43 index++;//临时数组增加索引
44 }
45 //处理左边剩余元素
46 while (i<=centerIndex){
47 tempArray[index]=arr[i];
48 i++;
49 index++;
50 }
51 //处理右边剩余元素
52 while (j<=endIndex){
53 tempArray[index]=arr[j];
54 j++;
55 index++;
56 }
57 //遍历临时数组赋值到原始数组
58 for (int m = 0; m ) {
59 arr[m+startIndex]=tempArray[m];
60 }
61 }
62 }


七、基数排序LSD:

技术图片

 

 


1 package com.duan.array;
2
3 import java.util.Arrays;
4
5 //分配再收集。按个位-十位-百位-... 位数从低位开始排序。LSD法。
6 public class RadixSort {
7 public static void main(String[] args) {
8 int []arr={0,2,11,30,49,50,100,123,187,543 };
9 Sort(arr);
10 System.out.println(Arrays.toString(arr));
11 }
12
13 private static void Sort(int[] arr) {
14 //定义一个二维数组
15 int[][]tempArr=new int [10][arr.length];//里面一维数组的长度和待排数组的长度一样
16 //定义一个统计的一维数组,用来统计二维数组中放的数字个数
17 int[]count=new int [10];//长度和二维数组保持一致
18 //获取数组中的最大数
19 int max=getMax(arr);
20 //计算数组中最大的数有几位,这也是我们需要比较的轮次
21 int lunci = String.valueOf(max).length();
22 for (int i = 0, n = 1; i ) {
23 for (int j = 0; j ) {
24 //获取每个位上的数字
25 int shu = arr[j] / n % 10;
26 //我们找一个二维数组,数组中放10个桶,这个桶就是一维数组
27 // count[shu]++ 意思是,二维数组的桶中放一个数字,那么统计数组对于的位置就统计一下
28 tempArr[shu][count[shu]++] = arr[j];
29 }
30 //我们遍历统计数组,取出二维数组中的元素,放回原数组
31 int index = 0;
32 for (int k = 0; k ) {
33 if (count[k] != 0) {
34 for (int h = 0; h ) {
35 arr[index] = tempArr[k][h];
36 index++;
37 }
38 //一轮过后统计的个数
39 count[k] = 0;
40 }
41 }
42 }
43
44
45 }
46
47 private static int getMax(int[] arr) {
48 int max=arr[0];
49 for (int i = 1; i ) {
50 if(arr[i]>max){
51 max=arr[i];
52 }
53 }
54 return max;
55 }
56 }


八、堆排序:


思想:初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个堆,这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。


1 package com.duan.array;
2
3 import java.util.Arrays;
4
5 public class HeapSort {
6 public static void main(String[] args) {
7 int[] nums = {16,7,3,20,17,8};
8 headSort(nums);
9 for (int num : nums) {
10 System.out.print(num + " ");
11 }
12 }
13
14 /**
15 * 堆排序
16 */
17 public static void headSort(int[] list) {
18 //构造初始堆,从第一个非叶子节点开始调整,左右孩子节点中较大的交换到父节点中
19 for (int i = (list.length) / 2 - 1; i >= 0; i--) {
20 headAdjust(list, list.length, i);
21 }
22 //排序,将最大的节点放在堆尾,然后从根节点重新调整
23 for (int i = list.length - 1; i >= 1; i--) {
24 int temp = list[0];
25 list[0] = list[i];
26 list[i] = temp;
27 headAdjust(list, i, 0);
28 }
29 }
30
31 private static void headAdjust(int[] list, int len, int i) {
32 int k = i, temp = list[i], index = 2 * k + 1;
33 while (index < len) {
34 if (index + 1 < len) {
35 if (list[index] ]) {
36 index = index + 1;
37 }
38 }
39 if (list[index] > temp) {
40 list[k] = list[index];
41 k = index;
42 index = 2 * k + 1;
43 } else {
44 break;
45 }
46 }
47 list[k] = temp;
48 }
49 }

 




 








推荐阅读
  • 1:有如下一段程序:packagea.b.c;publicclassTest{privatestaticinti0;publicintgetNext(){return ... [详细]
  • 本文介绍了Java并发库中的阻塞队列(BlockingQueue)及其典型应用场景。通过具体实例,展示了如何利用LinkedBlockingQueue实现线程间高效、安全的数据传递,并结合线程池和原子类优化性能。 ... [详细]
  • 本文深入探讨了 Java 中的 Serializable 接口,解释了其实现机制、用途及注意事项,帮助开发者更好地理解和使用序列化功能。 ... [详细]
  • 将Web服务部署到Tomcat
    本文介绍了如何在JDeveloper 12c中创建一个Java项目,并将其打包为Web服务,然后部署到Tomcat服务器。内容涵盖从项目创建、编写Web服务代码、配置相关XML文件到最终的本地部署和验证。 ... [详细]
  • 本文详细介绍了Java中org.w3c.dom.Text类的splitText()方法,通过多个代码示例展示了其实际应用。该方法用于将文本节点在指定位置拆分为两个节点,并保持在文档树中。 ... [详细]
  • 本文详细介绍了 Apache Jena 库中的 Txn.executeWrite 方法,通过多个实际代码示例展示了其在不同场景下的应用,帮助开发者更好地理解和使用该方法。 ... [详细]
  • 本文介绍了如何通过 Maven 依赖引入 SQLiteJDBC 和 HikariCP 包,从而在 Java 应用中高效地连接和操作 SQLite 数据库。文章提供了详细的代码示例,并解释了每个步骤的实现细节。 ... [详细]
  • 本文详细介绍了Java中org.neo4j.helpers.collection.Iterators.single()方法的功能、使用场景及代码示例,帮助开发者更好地理解和应用该方法。 ... [详细]
  • 优化ListView性能
    本文深入探讨了如何通过多种技术手段优化ListView的性能,包括视图复用、ViewHolder模式、分批加载数据、图片优化及内存管理等。这些方法能够显著提升应用的响应速度和用户体验。 ... [详细]
  • Explore a common issue encountered when implementing an OAuth 1.0a API, specifically the inability to encode null objects and how to resolve it. ... [详细]
  • Java 类成员初始化顺序与数组创建
    本文探讨了Java中类成员的初始化顺序、静态引入、可变参数以及finalize方法的应用。通过具体的代码示例,详细解释了这些概念及其在实际编程中的使用。 ... [详细]
  • 本文详细介绍了Java中org.eclipse.ui.forms.widgets.ExpandableComposite类的addExpansionListener()方法,并提供了多个实际代码示例,帮助开发者更好地理解和使用该方法。这些示例来源于多个知名开源项目,具有很高的参考价值。 ... [详细]
  • 深入解析Spring Cloud Ribbon负载均衡机制
    本文详细介绍了Spring Cloud中的Ribbon组件如何实现服务调用的负载均衡。通过分析其工作原理、源码结构及配置方式,帮助读者理解Ribbon在分布式系统中的重要作用。 ... [详细]
  • 本文详细介绍了Akka中的BackoffSupervisor机制,探讨其在处理持久化失败和Actor重启时的应用。通过具体示例,展示了如何配置和使用BackoffSupervisor以实现更细粒度的异常处理。 ... [详细]
  • 本文详细探讨了VxWorks操作系统中双向链表和环形缓冲区的实现原理及使用方法,通过具体示例代码加深理解。 ... [详细]
author-avatar
手机用户2502871157
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有