甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
import java.util.Arrays;
岳普湖ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：13518219792（备注：SSL证书合作）期待与您的合作！
import java.util.Collection;
public class Demo2 {
public static void main(String[] args) {
// 这是你的三个数
int[] arr = { 12, 32, 18 };
// 两层嵌套循环
for (int i = 0; i arr.length; i++) {
for (int j = 0; j i; j++) {
// 如果后者小于前者，让他们交换位置，一直循环
// 直到每个数字都从头到尾跟数组里的每个数字比较一次
if (arr[i] arr[j]) {
// 这三步就是交换位置，相信聪明的你一定看得懂了
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
}
}
//最后打印出来
for (int i = 0; i arr.length; i++) {
System.out.println(arr[i]);
}
}
}
资料拓展：
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论
import java.util.Scanner;
/**
* @author young
* @Description:
*/
public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[] a = new int[10];
int count = 0;
while (count 10) {
System.out.print("输入第" + (count + 1) + "个数:");
a[count] = scanner.nextInt();
count++;
}
System.out.print("\n排序之前的数组：");
for(int i = 0; i a.length; i++){
System.out.print(a[i] + " ");
}
// 选择排序：
for (int i = 0; i a.length; i++) {
int min = a[i];
int n = i;
for (int j = i + 1; j a.length; j++) {
if (a[j] min) {
min = a[j];
n = j;
}
}
a[n] = a[i];
a[i] = min;
}
System.out.print("\n选择排序之后：");
for (int i = 0; i a.length; i++) {
System.out.print(a[i] + " ");
}
}
}
给你介绍4种排序方法及源码，供参考
1.冒泡排序
主要思路： 从前往后依次交换两个相邻的元素，大的交换到后面，这样每次大的数据就到后面，每一次遍历，最大的数据到达最后面，时间复杂度是O(n^2)。
public static void bubbleSort(int[] arr){
for(int i =0; i arr.length - 1; i++){
for(int j=0; j arr.length-1; j++){
if(arr[j] arr[j+1]){
arr[j] = arr[j]^arr[j+1];
arr[j+1] = arr[j]^arr[j+1];
arr[j] = arr[j]^arr[j+1];
}
}
}
}
2.选择排序
主要思路：每次遍历序列，从中选取最小的元素放到最前面，n次选择后，前面就都是最小元素的排列了，时间复杂度是O(n^2）。
public static void selectSort(int[] arr){
for(int i = 0; i arr.length -1; i++){
for(int j = i+1; j arr.length; j++){
if(arr[j] arr[i]){
arr[j] = arr[j]^arr[i];
arr[i] = arr[j]^arr[i];
arr[j] = arr[j]^arr[i];
}
}
}
}
3.插入排序
主要思路：使用了两层嵌套循环，逐个处理待排序的记录。每个记录与前面已经排好序的记录序列进行比较，并将其插入到合适的位置，时间复杂度是O(n^2）。
public static void insertionSort(int[] arr){
int j;
for(int p = 1; p arr.length; p++){
int temp = arr[p]; //保存要插入的数据
//将无序中的数和前面有序的数据相比，将比它大的数，向后移动
for(j=p; j0 temp arr[j-1]; j--){
arr[j] = arr[j-1];
}
//正确的位置设置成保存的数据
arr[j] = temp;
}
}
4.希尔排序
主要思路：用步长分组，每个分组进行插入排序，再慢慢减小步长，当步长为1的时候完成一次插入排序， 希尔排序的时间复杂度是：O（nlogn）～O（n2），平均时间复杂度大致是O(n^1.5)
public static void shellSort(int[] arr){
int j ;
for(int gap = arr.length/2; gap 0 ; gap/=2){
for(int i = gap; i arr.length; i++){
int temp = arr[i];
for(j = i; j=gap temparr[j-gap]; j-=gap){
arr[j] = arr[j-gap];
}
arr[j] = temp;
}
}
}
可以实现比较器Comparator来定制排序方案，同时使用Colletions.sort的方式进行排序，代码如下：
public void sortDesc(ListLong s){
Collections.sort(s, new ComparatorLong() {
public int compare(Long o1, Long o2) {
Long result = o2 - o1;
return result.intValue();
}
});
s.forEach(item-{
System.out.print(item +" ");
});
}
同时常用的比较排序算法主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。
java的冒泡排序实现如下：
public static void bubbleSort(int []arr) { for(int i =0;iarr.length-1;i++) { for(int j=0;jarr.length-i-1;j++) {//-1为了防止溢出 if(arr[j]arr[j+1]) { int temp = arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } }
还有非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。
将数字从大到小排序的方法：
例如简一点的冒泡排序，将第一个数字和后面的数字逐个比较大小，如果小于，则互换位置，大于则不动。此时，第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较，以次类推。
示例代码如下：
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、插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。
选择排序的基本思想是：每一趟在n-i+1（i=1，2，…n-1）个记录中选取关键字最大的记录作为有序序列中第i个记录。基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。
java选择排序法代码
import java.util.Random;
public class ArrayDemo {
public static void main(String[] args) {
Random random=new Random();
int[] pData=new int[10];
for(int i=0;ipData.length;i++){ //随机生成10个排序数
Integer a =random.nextInt(100);
pData[i]= a;
System.out.print(pData[i]+" ");
}
System.out.println();
pData=Choose(pData);
for(int i=0;ipData.length;i++){
System.out.print(pData[i]+" ");
}
System.out.println();
}
public static int[] Choose(int[] pData){
System.out.println();
int k;
for (int i = 0; i pData.length; i++) {
k = i;
for (int j = i; j pData.length; j++) {
if(pData[j]pData[k]){k = j;}
}
int a=pData[i];
pData[i]=pData[k];
pData[k]=a;
}
return pData;
}
}
扩展资料：
其他排序方法：
简单选择排序的基本思想：第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；
以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
以下为简单选择排序的存储状态，其中大括号内为无序区，大括号外为有序序列：
初始序列：{49 27 65 97 76 12 38}
第1趟：12与49交换：12{27 65 97 76 49 38}
第2趟：27不动 ：12 27{65 97 76 49 38}
第3趟：65与38交换：12 27 38{97 76 49 65}
第4趟：97与49交换：12 27 38 49{76 97 65}
第5趟：76与65交换：12 27 38 49 65{97 76}
第6趟：97与76交换：12 27 38 49 65 76 97 完成
参考资料：百度百科-选择排序法