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);
}
}
‘贰’ java怎样调用排序包而不用自己写排序算法
import java.util.Arrays;
public class Test_2 {
public static void main(String[] args) {
int
a[]={9,88,77,11,8};
Arrays.sort(a);
for(int
i=0;i<a.length;i++)
System.out.println(a[i]);
}
}
这不是用TreeSet写的 你看是你想要的不
补充：
这是树集 相对比较复杂
package Test;
import java.util.Arrays;
import java.util.Comparator;
import
java.util.Iterator;
import java.util.TreeSet;
public class Test_2 {
public static void main(String[] args) {
// int a[]={9,88,77,11,8};
//
Arrays.sort(a);
// for(int i=0;i<a.length;i++)
//
System.out.println(a[i]);
TreeSet mytree = new TreeSet(new Comparator()
{
public int compare(Object A, Object B) {
Student s1=(Student)
A;
Student s2=(Student) B;
return s1.compareTo(s2);
}
});
Student
st1,st2,st3,st4;
st1=new Student(90);
st2=new Student(9);
st3=new
Student(99);
st4=new
Student(19);
mytree.add(st1);
mytree.add(st2);
mytree.add(st3);
mytree.add(st4);
Iterator
te=mytree.iterator();
while(te.hasNext())
{
Student s=(Student)
te.next();
System.out.println(s.score);
}
}
}
class Student implements Comparable {
int score;
Student(int score) {
this.score = score;
}
public int compareTo(Object obj) {
Student st = (Student) obj;
return
(this.score - st.score);
}
}
‘叁’ 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;
}
}
‘肆’ 初学者：用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]+" ");
}
}
}
‘伍’ java排序，效率高的是哪种排序方法
你网络一下快速排序。它是左右两边同时排序的，效率很高。
‘陆’ 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) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序
等。
‘柒’ 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
‘捌’ 用JAVA实现快速排序算法
public void quickSort(int left,int right,int a[])
{
int l=left;
int r=right;
int pivot=a[(l+r)/2];//转轴数
int temp=0;
while(l<r)
{
while(a[l]<pivot)l++;
while(a[r]>pivot)r--;
if(l>=r)break;
temp=a[l];
a[l]=a[r];
a[r]=temp;
if(a[l]==pivot)r--;
if(a[r]==pivot)l++;
}
if(l==r)
{
l++;
r--;
}
if(left<r)quickSort(left,r,a);
if(right>l)quickSort(l,right,a);
}
‘玖’ Java的排序算法有哪些
排序： 插入，冒泡，选择，Shell,快速排序
‘拾’ 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;
}
}
}
}
楼上说的没错，你得自己去学会解决问题。好好加油吧...