排序： 插入，冒泡，选择，Shell,快速排序
2. java排序算法有多少种
算法和语言无关吧，语言只是把具体的算法实现出来而已。据我了解的排序算法11-13种。排序算法嘛 主要就是个思想而已。不同的算法时间复杂度不一样，空间复杂度也不一样，当然执行的效率也不一样。当然采用哪种算法还取决于你要实现什么样的功能。就好比说：要同时尽快的找出最大最小，或者尽快的找出最值的位置等等。冒泡排序（bubble sort） — O(n2)
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体
归并排序 （merge sort）— O(n log n); 需要 O(n) 额外记忆体
原地归并排序 — O(n2)
二叉树排序 （Binary tree sort） — O(n log n); 需要 O(n) 额外记忆体
鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体
基数排序 （radix sort）— O(n·k); 需要 O(n) 额外记忆体
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体不稳定
选择排序 （selection sort）— O(n2)
希尔排序 （shell sort）— O(n log n) 如果使用最佳的现在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望时间, O(n2) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序
等。
3. java怎么实现排序
Java实现几种常见排序方法
日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。
以下常见算法的定义
1. 插入排序：插入排序基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
2. 选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。
4. 快速排序：快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
5. 归并排序：归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
6. 希尔排序：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
https://www.cnblogs.com/wangmingshun/p/5635292.html
4. java 请教排序算法
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @author wsj
* @date 2010-5-16, 上午10:13:47
*/
public class Test1 {
public static void main(String[] args){
Integer arr1[]={6,3,4,5,1};
Integer arr2[]={3,4,7,9,0};
List<MyInteger> list1=new ArrayList<MyInteger>();
List<MyInteger> list2=new ArrayList<MyInteger>();
for (int i = 0; i < arr2.length; i++) {
list1.add(new MyInteger(arr1[i]));
list2.add(new MyInteger(arr2[i]));
}
System.out.print("数组A排序前:");
output(list1);
Collections.sort(list1);
System.out.print("数组A排序后:");
output(list1);
System.out.print("数组B排序前:");
output(list2);
Collections.sort(list2);
System.out.print("数组B排序后:");
output(list2);
List<MyInteger> allList=new ArrayList<MyInteger>();
allList.addAll(list1);
allList.addAll(list2);
System.out.print("合并排序前：");
output(allList);
Collections.sort(allList);
System.out.print("合并排序后：");
output(allList);
System.out.println("A数组占："+getCount(allList, list1)+" 个");
System.out.println("B数组占："+getCount(allList, list2)+" 个");
}
public static void output(List<MyInteger> list){
for (MyInteger m:list) {
System.out.print(m.val+",");
}
System.out.println();
}
public static int getCount(List<MyInteger> allList,List<MyInteger> list){
int count=0;
for (int i = 4; i>=0; i--) {
count=list.lastIndexOf(allList.get(i))+1;
if(count>0) return count;
}
return count;
}
}
class MyInteger implements Comparable<MyInteger>{
Integer val;
public MyInteger(Integer val) {
this.val = val;
}
@Override
public int compareTo(MyInteger o) {
if(o==null||o.val==null) return -1;
return -val.compareTo(o.val);
}
@Override
public boolean equals(Object obj) {
return val.equals(((MyInteger)obj).val);
}
}
5. Java 排序算法（选择、冒泡）等等
//选择排序
publicstaticvoidselectionSort(int[] elements){
for(inti = 0; i < elements.length-1; ++i){
intk = i;
for(intj = i; j < elements.length; ++j){
if(elements[k] > elements[j]){
k = j;
}
}
if(k != i){//交换元素
inttemp = elements[i];
elements[i] = elements[k];
elements[k] = temp;
}
} }
//冒泡排序
static void bubblesort(int[] a){
int temp;
for(int i=0; i<a.length;++i){
for(int j=a.length-1;j>i;--j){
if(a[j] <a[j-1]){
temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
}
}
楼上说的没错，你得自己去学会解决问题。好好加油吧...
6. 冒泡排序算法，java
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第
1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大
数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至
全部排序完成。
publicclass BubbleSort {
publicstaticvoid main(String[] args) { int[] arr={12,45,23,67,56,34,99,123}; System.out.println("排序前数组为：");
for(int n:arr){
System.out.print(n+"");
}
for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次 if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp;
}
}
7. java选择排序法
这是一个很简单的选择排序的方法,加了一些重点步骤的注释,希望对您有帮助!(上次发错了.这次是正确的版本)
public class ChooseSort {
public static void main(String[] args) {
int src[] = new int[]{25，15，42，16，12，36};
ChooseSort choose = new ChooseSort();
choose.doChooseSort(src);
}
private void doChooseSort(int[] src){
long start = System.currentTimeMillis();
for(int k=0;k<1000000;k++){
int temp;
for(int i=0;i<src.length;i++){
temp=src[i];
//最小数下标
int smallLocation=i;
for(int j=i+1;j<src.length;j++){
if(src[j]<temp){
//取出最小数
temp=src[j];
//最小数下标
smallLocation=j;
}
}
src[smallLocation]=src[i];
src[i]=temp;
}
}
System.out.println("选择排序如下,耗时:"+ (System.currentTimeMillis() - start));
}
}
8. java的排序算法怎么写所有的
public static void buildHeap(int [] a,int beg,int end){
int size = end-beg+1;
int temp;
for(int i = size/2;i>0;i--){
if((2*i+1<=end)&&a[i]<a[2*i+1]){
temp=a[i];
a[i]=a[2*i+1];
a[2*i+1]=temp;
}
if((2*i<=end)&&a[i]<a[2*i]){
temp=a[i];
a[i]=a[2*i];
a[2*i]=temp;
}
}
}
public static void heapSort(int [] a,int beg,int end){
int size = end-beg+1;
int temp;
for(int i =size;i>0;i--){
buildHeap(a, 1, i);
temp=a[1];
a[1]=a[i];
a[i]=temp;
}
}
public static void shellSort(int[] a,int wid){
int temp;int j;
for(int i=0;i<a.length;i++){
for(int k=i+wid;k<a.length;k+=wid){
j=k-wid;
temp=a[k];
while((j>=0)&&(temp<a[j])){
a[j+wid]=a[j];
j-=wid;
}
a[j+wid]=temp;
}
}
}
public static int partition(int[] a,int beg,int end){
int temp = a[beg];
while(beg<end){
while(beg<end&&a[end]>=temp){
end--;
}
a[beg]=a[end];
while((beg<end)&&(a[beg]<=temp))
{
beg++;
}
a[end]=a[beg];
}
a[beg]=temp;
return beg;
}
public static void quickSort(int[] a,int beg,int end){
if(beg<end){
int q = partition(a, beg, end);
quickSort(a, beg, q-1);
quickSort(a, q+1, end);
}
}
public static void insertSort(int[] a){
int temp;
int j;
for(int i=1;i<a.length;i++){
j=i-1;
temp=a[i];
while((j>=0)&&(temp<a[j])){
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
}
}
9. 初学者：用java程序写一个选择排序算法！
选择排序法：
public class TSort{
public static void main(String args[]){
int a[]={12,45,2,5,26,56};
for(int i=0;i<a.length-1;i++){
int t;
for(int j=i+1;j<a.length;j++){
if(a[i]>a[j]){
t=a[i];a[i]=a[j];a[j]=t;
}
}
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}