快上网专注成都网站设计 成都网站制作 成都网站建设
成都网站建设公司服务热线:028-86922220

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决

java数组快速排序代码 java代码实现数组顺序排列

java 数组顺序排列

首先,API里面写了: Sorts the specified array of ints into ascending numerical order.

网站建设哪家好,找创新互联公司!专注于网页设计、网站建设、微信开发、成都小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了朝天免费建站欢迎大家使用!

就是这是个升序!

其次,你这个运行应该不会报错,输出的会是 数组地址,因为数组在java里面是一个对象,如果要看排序的结果,需要遍历下:

比如

for(int i:arr){

System.out.println(i);

}

Java数组排序 几种排序方法详细一点

JAVA中在运用数组进行排序功能时,一般有四种方法:快速排序法、冒泡法、选择排序法、插入排序法。

快速排序法主要是运用了Arrays中的一个方法Arrays.sort()实现。

冒泡法是运用遍历数组进行比较,通过不断的比较将最小值或者最大值一个一个的遍历出来。

选择排序法是将数组的第一个数据作为最大或者最小的值,然后通过比较循环,输出有序的数组。

插入排序是选择一个数组中的数据,通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。

1利用Arrays带有的排序方法快速排序

public class Test2{   

public static void main(String[] args){   

int[] a={5,4,2,4,9,1};   

Arrays.sort(a);  //进行排序   

for(int i: a){   

System.out.print(i);   

}  

}  

}

2冒泡排序算法

public static int[] bubbleSort(int[] args){//冒泡排序算法   

for(int i=0;iargs.length-1;i++){   

for(int j=i+1;jargs.length;j++){   

if (args[i]args[j]){   

int temp=args[i];   

args[i]=args[j];   

args[j]=temp;   

}   

}  

}  

return args;  

}

3选择排序算法

public static int[] selectSort(int[] args){//选择排序算法   

for (int i=0;iargs.length-1 ;i++ ){   

int min=i;   

for (int j=i+1;jargs.length ;j++ ){   

if (args[min]args[j]){   

min=j;   

}   

}   

if (min!=i){  

int temp=args[i];  

args[i]=args[min];  

args[min]=temp;          

}  

}  

return args;  

}

4插入排序算法

public static int[] insertSort(int[] args){//插入排序算法   

for(int i=1;iargs.length;i++){   

for(int j=i;j0;j--){   

if (args[j]args[j-1]){   

int temp=args[j-1];  

args[j-1]=args[j];  

args[j]=temp;          

}else break;   

}  

}  

return args;  

}

如何用JAVA实现快速排序算法?

本人特地给你编的代码\x0d\x0a亲测\x0d\x0a\x0d\x0apublicclassQuickSort{\x0d\x0a\x0d\x0apublicstaticintPartition(inta[],intp,intr){\x0d\x0aintx=a[r-1];\x0d\x0ainti=p-1;\x0d\x0ainttemp;\x0d\x0afor(intj=p;jif(a[j-1]//swap(a[j-1],a[i-1]);\x0d\x0ai++;\x0d\x0atemp=a[j-1];\x0d\x0aa[j-1]=a[i-1];\x0d\x0aa[i-1]=temp;\x0d\x0a\x0d\x0a}\x0d\x0a}\x0d\x0a//swap(a[r-1,a[i+1-1]);\x0d\x0atemp=a[r-1];\x0d\x0aa[r-1]=a[i+1-1];\x0d\x0aa[i+1-1]=temp;\x0d\x0a\x0d\x0areturni+1;\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0apublicstaticvoidQuickSort(inta[],intp,intr){\x0d\x0a\x0d\x0aif(p

java怎么让数组的数字从大到小排序?

将数字从大到小排序的方法:

例如简一点的冒泡排序,将第一个数字和后面的数字逐个比较大小,如果小于,则互换位置,大于则不动。此时,第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较,以次类推。

示例代码如下: 

public class Test { 

public static void main(String[] args) { 

int [] array = {12,3,1254,235,435,236,25,34,23}; 

int temp; 

for (int i = 0; i  array.length; i++) { 

for (int j = i+1; j  array.length; j++) { 

if (array[i]  array[j]) { 

temp = array[i]; 

array[i] = array[j]; 

array[j] = temp; // 两个数交换位置 

for (int i = 0; i  array.length; i++) { 

System.out.print(array[i]+"  "); 

}

数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量,如 numbers[100] 来代替直接声明 100 个独立变量 number0,number1,....,number99

扩展资料

Java中利用数组进行数字排序一般有4种方法:

1、选择排序是先将数组中的第一个数作为最大或最小数,然后通过循环比较交换最大数或最小数与一轮比较中第一个数位置进行排序。

2、冒泡排序也是先将数组中的第一个数作为最大或最小数,循环比较相邻两个数的大小,满足条件就互换位置,将最大数或最小数沉底。

3、快速排序法主要是运用Arrays类中的Arrays.sort方法()实现。

4、插入排序是选择一个数组中的数据,通过不断的插入比较最后进行排序。

用java写 定义一个数组 将它们从小到大排列

最佳答案:冒泡排序算法。一下为C#语言例子:

int temp = 0;

int[] arr = { 23, 44, 66, 76, 98, 11, 3, 9, 7 };

Console.WriteLine("排序前的数组:");

foreach (int item in arr)

{

Console.Write(item + " ");

}

Console.WriteLine();

for (int i = 0; i arr.Length-1; i++)

{

for (int j = 0; j arr.Length-1-i; j++)

{

if (arr[j+1] arr[j])

{

temp = arr[j+1];arr[j+1] = arr[j];arr[j] = temp; }

}

}

Console.WriteLine("排序后的数组:");

foreach (int item in arr)

{

Console.Write(item + " ");

}

Console.WriteLine();

Console.ReadKey();

}

请问一下java快速排序源代码

快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**

* @author treeroot

* @since 2006-2-2

* @version 1.0

*/

public class QuickSort implements SortUtil.Sort{

/* (non-Javadoc)

* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

public void sort(int[] data) {

quickSort(data,0,data.length-1);

}

private void quickSort(int[] data,int i,int j){

int pivotIndex=(i+j)/2;

//swap

SortUtil.swap(data,pivotIndex,j);

int k=partition(data,i-1,j,data[j]);

SortUtil.swap(data,k,j);

if((k-i)1) quickSort(data,i,k-1);

if((j-k)1) quickSort(data,k+1,j);

}

/**

* @param data

* @param i

* @param j

* @return

*/

private int partition(int[] data, int l, int r,int pivot) {

do{

while(data[++l]pivot);

while((r!=0)data[--r]pivot);

SortUtil.swap(data,l,r);

}

while(lr);

SortUtil.swap(data,l,r);

return l;

}

}

改进后的快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**

* @author treeroot

* @since 2006-2-2

* @version 1.0

*/

public class ImprovedQuickSort implements SortUtil.Sort {

private static int MAX_STACK_SIZE=4096;

private static int THRESHOLD=10;

/* (non-Javadoc)

* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

public void sort(int[] data) {

int[] stack=new int[MAX_STACK_SIZE];

int top=-1;

int pivot;

int pivotIndex,l,r;

stack[++top]=0;

stack[++top]=data.length-1;

while(top0){

int j=stack[top--];

int i=stack[top--];

pivotIndex=(i+j)/2;

pivot=data[pivotIndex];

SortUtil.swap(data,pivotIndex,j);

//partition

l=i-1;

r=j;

do{

while(data[++l]pivot);

while((r!=0)(data[--r]pivot));

SortUtil.swap(data,l,r);

}

while(lr);

SortUtil.swap(data,l,r);

SortUtil.swap(data,l,j);

if((l-i)THRESHOLD){

stack[++top]=i;

stack[++top]=l-1;

}

if((j-l)THRESHOLD){

stack[++top]=l+1;

stack[++top]=j;

}

}

//new InsertSort().sort(data);

insertSort(data);

}

/**

* @param data

*/

private void insertSort(int[] data) {

int temp;

for(int i=1;idata.length;i++){

for(int j=i;(j0)(data[j]data[j-1]);j--){

SortUtil.swap(data,j,j-1);

}

}

}

}


分享标题:java数组快速排序代码 java代码实现数组顺序排列
当前地址:http://6mz.cn/article/docdjej.html

其他资讯