常用Java排序算法

冒泡排序 、选择排序、快速排序

 1 package com.javaee.corejava;
 2
 3 public class DataSort {
 4
 5     public DataSort() {
 6         // TODO Auto-generated constructor stub
 7     }
 8
 9     public static void main(String[] args) {
10         int[] p = { 34, 21, 54, 18, 23, 76, 38, 98, 45, 33, 27, 51, 11, 20, 79,
11                 30, 89, 41 };
12
13         long start = System.currentTimeMillis();
14
15         DataSort.bubbleSort(p);// 冒泡排序
16         //DataSort.selectSort1(p);// 选择排序 1
17         //DataSort.selectSort2(p);// 选择排序2
18         //DataSort.quickSort(p, 0, p.length - 1);// 快速排序
19
20         System.out.println("所用时间:" + (System.currentTimeMillis() - start));
21         for (int i = 0; i < p.length; i++) {
22             System.out.print(p[i] + " ");
23         }
24
25     }
26     //冒泡排序
27     public static void bubbleSort(int[] data){
28         for(int i=0;i<data.length-1;i++){
29             for(int j=0;j<data.length-i-1;j++){
30                 if(data[j]>data[j+1]){
31                     int temp=data[j];
32                     data[j]=data[j+1];
33                     data[j+1]=temp;
34                 }
35             }
36         }
37     }
38     //选择排序1
39     public static void selectSort1(int[] data){
40         if(data==null||data.length==0){
41             return;
42         }
43         for(int i=0;i<data.length-1;i++){
44             int min=i;
45             for(int j=i+1;j<data.length;j++){
46                 if(data[j]<data[min]){
47                     min=j;
48                 }
49             }
50             if(i!=min){
51                 int temp=data[i];
52                 data[i]=data[min];
53                 data[min]=temp;
54             }
55         }
56     }
57     //选择排序2
58     public static void selectSort2(int[] data){
59         for(int i=0;i<data.length-1;i++){
60             for(int j=i+1;j<data.length;j++){
61                 if(data[i]>data[j]){
62                     int temp=data[i];
63                     data[i]=data[j];
64                     data[j]=temp;
65                 }
66             }
67         }
68     }
69     //快速排序
70     public static void quickSort(int[] data,int start,int end){
71         int key=data[start];
72         int i=start;
73         int j=end;
74         while(i<j){
75             while(data[j]>key&&i<j){
76                 j--;
77             }
78             data[i]=data[j];
79             while(data[i]<key&&i<j){
80                 i++;
81             }
82             data[j]=data[i];
83         }
84         data[i]=key;
85         if(i-1>start){
86             quickSort(data,start,i-1);
87         }
88         if(i+1<end){
89             quickSort(data,i+1,end);
90         }
91     }
92
93 }
 
时间: 2024-08-10 12:19:38

常用Java排序算法的相关文章

java SE 常用的排序算法

java程序员会用到的经典排序算法实现 常用的排序算法(以下代码包含的)有以下五类: A.插入排序(直接插入排序.希尔排序) B.交换排序(冒泡排序.快速排序) C.选择排序(直接选择排序.堆排序) D.归并排序 E.分配排序(基数排序) 以下算法都是可以实现的,但是什么情况使用什么算法都是根据实际情况选用的. 如果有用的话就顶起吧,谢谢. import java.util.ArrayList; import java.util.List; public class Sort { // test

(转)java 排序算法

排序算法汇总(java实现,附源代码) 整理系统的时候发现了原来写的各种算法的总结,看了一下,大吃一惊,那时候的我还如此用心,具体的算法,有的已经模糊甚至忘记了,看的时候就把内容整理出来,顺便在熟悉一下,以后需要的时候就可以直接过来摘抄了.下面是总结的几个常用的排序算法: 插入排序 快速排序 冒泡排序 堆排序 计数排序 桶排序 可能大家对插入排序,快速排序,冒泡排序比较常用,在满足需求的时候也简单一些,下面逐一说一下每个算法的实现方式,不保证是写的最有效率的,但是能保证的是,各种算法的中心思想是

JavaScript实现常用的排序算法

▓▓▓▓▓▓ 大致介绍 由于最近要考试复习,所以学习js的时间少了 -_-||,考试完还会继续的努力学习,这次用原生的JavaScript实现以前学习的常用的排序算法,有冒泡排序.快速排序.直接插入排序.希尔排序.直接选择排序 ▓▓▓▓▓▓ 交换排序 交换排序是一类在排序过程中借助于交换操作来完成排序的方法,基本思想是两两比较排序记录的关键字,如果发现两个关键字逆序,则将两个记录位置互换,重复此过程,直到该排序列中所有关键字都有序为止,接下来介绍交换排序中常见的冒泡排序和快速排序 ▓▓▓▓▓▓

【计算机基础】 常用的排序算法的时间复杂度和空间复杂度

常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n2) O(n2) 稳定 O(1) 快速排序 O(n2) O(n*log2n) 不稳定 O(log2n)~O(n) 选择排序 O(n2) O(n2) 稳定 O(1) 二叉树排序 O(n2) O(n*log2n) 不一顶 O(n) 插入排序 O(n2) O(n2) 稳定 O(1) 堆排序 O(n*log2n) O(n*log2n) 不稳定 O(1) 希尔排序 O O 不稳定 O(1) 1

Java排序算法(一)

Java排序算法(一) 一.排序的基本概念和分类 1.1排序的定义 在<大话数据结构>中,排序定义为,假设含有n个记录的序列为{r1,r2,...,rn},其相应的关键字{k1,k2,...,kn},需确定1,2...n的一种排列p1,p2...pn,是其相应的关键字满足Kp1<=Kp2<=...<=Kpn(非递减或非递增)关键,即使得序列称为一个按关键字有序的序列{rp1,rp2...rp3},这样的操作称为排序. 1.2排序的稳定性 假设ki=kj(1<=i<

7 种常用的排序算法-视觉直观感受

7 种常用的排序算法-可视化 1. 快速排序 介绍: 快速排序是由东尼·霍尔所发展的一种排序算法.在平均状况下,排序 n 个项目要Ο(n log n)次比较.在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见.事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来,且在大部分真实世界的数据,可以决定设计的选择,减少所需时间的二次方项之可能性. 步骤: 从数列中挑出一个元素,称为 “基准”(pivot),

几种常用的排序算法总结

主要针对于插入排序,交换(冒泡和快速),选择,堆排序,归并这几种排序的基本原理和时间复杂度,及空间复杂度的一个总结. 一.插入排序 基本执行过程:3  5  2  7  9  8 1.从小到大:从第二个数开始,每次比较都与前边的几个数进行比较 但是从大到小,要先与前边排好序的几个数中的最大的开始进行比较即倒序比较,依次往前推. 如:5 先与3进行比较,比3大,所以直接排在3的后边为:3 5: 2要先与5进行比较,比5小,再与3比较,比3小,所以排序后为 2 3 5: 7要先与5比,比5大,所以直

C#中常用的排序算法的时间复杂度和空间复杂度

常用的排序算法的时间复杂度和空间复杂度 常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n2) O(n2) 稳定 O(1) 快速排序 O(n2) O(n*log2n) 不稳定 O(log2n)~O(n) 选择排序 O(n2) O(n2) 稳定 O(1) 二叉树排序 O(n2) O(n*log2n) 不一顶 O(n) 插入排序 O(n2) O(n2) 稳定 O(1) 堆排序 O(n*log2n) O(n*log2n) 不稳定 O(1)

常用查找排序算法

1.折半查找算法: 对于一个已排好序的数组,若要查找某元素是否属于数组中,则可以用这种算法. 返回找到的元素在数组中的下标,找不到则返回-1 #include <stdio.h> #define LEN 8 int a[LEN] = { 1, 3, 3, 3, 4, 5, 6, 7 }; int binarysearch(int number) { int mid, start = 0, end = LEN - 1; while (start <= end) { mid = (start