JAVA常考三种排序(选择 冒泡 插入)
java的几种排序方式
java的几种排序方式用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。
插入排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class InsertSort implements SortUtil.Sort{/* (non-Javadoc)* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/public void sort(int[] data) {int temp;for(int i=1;i for(int j=i;(j>0)&&(data[j] SortUtil.swap(data,j,j-1);}}}}冒泡排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class BubbleSort implements SortUtil.Sort{/* (non-Javadoc)* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/public void sort(int[] data) {int temp;for(int i=0;i for(int j=data.length-1;j>i;j--){if(data[j] SortUtil.swap(data,j,j-1);}}}}}选择排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class SelectionSort implements SortUtil.Sort { /** (non-Javadoc)** @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) */public void sort(int[] data) {int temp;for (int i = 0; i < data.length; i++) {int lowIndex = i;for (int j = data.length - 1; j >i; j--) {if (data[j] < data[lowIndex]) {lowIndex = j;}}SortUtil.swap(data,i,lowIndex);}}}Shell排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class ShellSort implements SortUtil.Sort{/* (non-Javadoc)* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) */public void sort(int[] data) {for(int i=data.length/2;i>2;i/=2){for(int j=0;j insertSort(data,j,i);}}insertSort(data,0,1);/*** @param data* @param j* @param i*/private void insertSort(int[] data, int start, int inc) {int temp;for(int i=start+inc;i for(int j=i;(j>=inc)&&(data[j] SortUtil.swap(data,j,j-inc); }}}}快速排序：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;//swapSortUtil.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) {while(data[++l] while((r!=0)&&data[--r]>pivot);SortUtil.swap(data,l,r);}while(l 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(top>0){int j=stack[top--];int i=stack[top--];pivotIndex=(i+j)/2;pivot=data[pivotIndex];SortUtil.swap(data,pivotIndex,j);//partitionl=i-1;r=j;do{while(data[++l] while((r!=0)&&(data[--r]>pivot)); SortUtil.swap(data,l,r);}while(l 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;i for(int j=i;(j>0)&&(data[j] SortUtil.swap(data,j,j-1); }}}}归并排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class MergeSort implements SortUtil.Sort{/* (non-Javadoc)* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/public void sort(int[] data) {int[] temp=new int[data.length];mergeSort(data,temp,0,data.length-1);}private void mergeSort(int[] data,int[] temp,int l,int r){int mid=(l+r)/2;if(l==r) return ;mergeSort(data,temp,l,mid);mergeSort(data,temp,mid+1,r);for(int i=l;i<=r;i++){temp=data;}int i1=l;int i2=mid+1;for(int cur=l;cur<=r;cur++){if(i1==mid+1)data[cur]=temp[i2++];else if(i2>r)data[cur]=temp[i1++];else if(temp[i1] data[cur]=temp[i1++];elsedata[cur]=temp[i2++];}}}改进后的归并排序:package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class ImprovedMergeSort implements SortUtil.Sort { private static final int THRESHOLD = 10;/** (non-Javadoc)** @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/public void sort(int[] data) {int[] temp=new int[data.length];mergeSort(data,temp,0,data.length-1);}private void mergeSort(int[] data, int[] temp, int l, int r) { int i, j, k;int mid = (l + r) / 2;if (l == r)return;if ((mid - l) >= THRESHOLD)mergeSort(data, temp, l, mid);elseinsertSort(data, l, mid - l + 1);if ((r - mid) >THRESHOLD)mergeSort(data, temp, mid + 1, r);elseinsertSort(data, mid + 1, r - mid);for (i = l; i <= mid; i++) {temp = data;}for (j = 1; j <= r - mid; j++) {temp[r - j + 1] = data[j + mid];}int a = temp[l];int b = temp[r];for (i = l, j = r, k = l; k <= r; k++) {if (a < b) {data[k] = temp;a = temp;} else {data[k] = temp[j--];b = temp[j];}}}/*** @param data* @param l* @param i*/private void insertSort(int[] data, int start, int len) {for(int i=start+1;i for(int j=i;(j>start) && data[j] SortUtil.swap(data,j,j-1); }}}}堆排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class HeapSort implements SortUtil.Sort{/* (non-Javadoc)* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])public void sort(int[] data) {MaxHeap h=new MaxHeap();h.init(data);for(int i=0;i h.remove();System.arraycopy(h.queue,1,data,0,data.length); }private static class MaxHeap{void init(int[] data){this.queue=new int[data.length+1];for(int i=0;i queue[++size]=data;fixUp(size);}}private int size=0;private int[] queue;public int get() {return queue[1];}public void remove() {SortUtil.swap(queue,1,size--);fixDown(1);}//fixdownprivate void fixDown(int k) {int j;while ((j = k << 1) <= size) {if (j < size && queue[j] j++;if (queue[k]>queue[j]) //不用交换break;SortUtil.swap(queue,j,k);k = j;}}private void fixUp(int k) {while (k >1) {int j = k >>1;if (queue[j]>queue[k])break;SortUtil.swap(queue,j,k);k = j;}}}SortUtil：package org.rut.util.algorithm;import org.rut.util.algorithm.support.BubbleSort;import org.rut.util.algorithm.support.HeapSort;import org.rut.util.algorithm.support.ImprovedMergeSort;import org.rut.util.algorithm.support.ImprovedQuickSort;import org.rut.util.algorithm.support.InsertSort;import org.rut.util.algorithm.support.MergeSort;import org.rut.util.algorithm.support.QuickSort;import org.rut.util.algorithm.support.SelectionSort;import org.rut.util.algorithm.support.ShellSort;/*** @author treeroot* @since 2006-2-2* @version 1.0*/public class SortUtil {public final static int INSERT = 1;public final static int BUBBLE = 2;public final static int SELECTION = 3;public final static int SHELL = 4;public final static int QUICK = 5;public final static int IMPROVED_QUICK = 6;public final static int MERGE = 7;public final static int IMPROVED_MERGE = 8;public final static int HEAP = 9;public static void sort(int[] data) {sort(data, IMPROVED_QUICK);}private static String[] name={"insert", "bubble", "selection", "shell", "quick", "improved_quick", "merge", "improved_merge", "heap"};private static Sort[] impl=new Sort[]{new InsertSort(),new BubbleSort(),new SelectionSort(),new ShellSort(),new QuickSort(),new ImprovedQuickSort(),new MergeSort(),new ImprovedMergeSort(),new HeapSort()public static String toString(int algorithm){return name[algorithm-1];}public static void sort(int[] data, int algorithm) { impl[algorithm-1].sort(data);}public static interface Sort {public void sort(int[] data);}public static void swap(int[] data, int i, int j) { int temp = data;data = data[j];data[j] = temp;}}。
Java实现冒泡排序
Java实现冒泡排序问题描述利⽤冒泡排序把⼀列数组按从⼩到⼤或从⼤到⼩排序(⼀)、冒泡排序思想以从⼩到⼤为例：1、第⼀轮的冒泡，从第⼀个数开始，与相邻的第⼆个数相⽐，若第⼀个数更⼤，则交换⼀⼆的位置，反之不动，结束后进⾏⼆三位置两个数的⽐较，同理如此反复，直到把最⼤的⼀个数排到最后⼀个位置。
2、进⾏第⼆轮的冒泡，依旧从第⼀个数开始，依次⽐较当前的⼀⼆、⼆三······位置的数，直到把第⼆⼤的数排到倒数第⼆位。
3、如此循环进⾏，直到所有数按从⼩到⼤排列。
(⼆)、问题分析1.输⼊数组根据⽤户输⼊的进⾏排序的数字数量n，建⽴⼀个长度为n的数组public static void main (String[] args){int n,m;Scanner sc = new Scanner(System.in);System.out.println("请输⼊你想排序的数量n");n=sc.nextInt();int [] arrary = new int[n];System.out.println("请输⼊"+n+"个数，并⽤空格隔开");for(int i=0;i<arrary.length;i++){arrary[i]=sc.nextInt();}2.输⼊如何排序设置两条路径：m=1为从⼩到⼤，m=2为从⼤到⼩，m=其他提醒⽤户重新输⼊System.out.println("请问你想：1.从⼩到⼤ 2.从⼤到⼩排序？");m=sc.nextInt();while (m!=1 && m!=2 ){System.out.println("输⼊有误请再次输⼊");m = sc.nextInt();continue;}3.排序算法（1）数组长度 arrary.length 也就是⽤户输⼊的 n（2）j 表⽰第 j+1 轮排序，这⾥⾯n-1轮排序就已⾜够（3）k 表⽰第 k+1 个位置，arrary[k] 表⽰第 k+1 个位置的数（4）由于每⼀轮都能确定⼀个最⼤数排在最后，所以每⼀轮进⾏⽐较的数都会少⼀个，⽐较的次数也会少⼀个，所以是k<arrary.length-1-j（5）较⼤数与较⼩数交换位置的经典算法：若a>b; 则c=a; a=b; b=c;（6）从⼤到⼩排序只需把 arrary[k]>arrary[k+1] 换成 arrary[k]<arrary[k+1] 即可（7）选择进⾏何种排序，在 if 语句的判断框⾥加上此时m应该等于的值（8）因为要先选择进⾏何种排序，才能进⾏排序，所以把 m==1 放在 arrary[k]>arrary[k+1] 前⾯，且⽤短板与 && ，这样更易于理解（如果m≠1，则直接进⾏else if 的语句）（9）也可以 m==1 & arrary[k]>arrary[k+1] 或 arrary[k]>arrary[k+1] & m==1，但不能 arrary[k]<arrary[k+1] && m==2。
链表排序（冒泡、选择、插入、快排、归并、希尔、堆排序）
链表排序（冒泡、选择、插⼊、快排、归并、希尔、堆排序）这篇⽂章分析⼀下链表的各种排序⽅法。
以下排序算法的正确性都可以在LeetCode的这⼀题检测。
本⽂⽤到的链表结构如下（排序算法都是传⼊链表头指针作为参数，返回排序后的头指针）struct ListNode {int val;ListNode *next;ListNode(int x) : val(x), next(NULL) {}};插⼊排序（算法中是直接交换节点，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *insertionSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.if(head == NULL || head->next == NULL)return head;ListNode *p = head->next, *pstart = new ListNode(0), *pend = head;pstart->next = head; //为了操作⽅便，添加⼀个头结点while(p != NULL){ListNode *tmp = pstart->next, *pre = pstart;while(tmp != p && p->val >= tmp->val) //找到插⼊位置{tmp = tmp->next; pre = pre->next;}if(tmp == p)pend = p;else{pend->next = p->next;p->next = tmp;pre->next = p;}p = pend->next;}head = pstart->next;delete pstart;return head;}};选择排序（算法中只是交换节点的val值，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *selectSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//选择排序if(head == NULL || head->next == NULL)return head;ListNode *pstart = new ListNode(0);pstart->next = head; //为了操作⽅便，添加⼀个头结点ListNode*sortedTail = pstart;//指向已排好序的部分的尾部while(sortedTail->next != NULL){ListNode*minNode = sortedTail->next, *p = sortedTail->next->next;//寻找未排序部分的最⼩节点while(p != NULL){if(p->val < minNode->val)minNode = p;p = p->next;}swap(minNode->val, sortedTail->next->val);sortedTail = sortedTail->next;}head = pstart->next;delete pstart;return head;}};快速排序1（算法只交换节点的val值，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition我们参考(选取第⼀个元素作为枢纽元的版本，因为链表选择最后⼀元素需要遍历⼀遍)，具体可以参考这⾥我们还需要注意的⼀点是数组的partition两个参数分别代表数组的起始位置，两边都是闭区间，这样在排序的主函数中：void quicksort(vector<int>&arr, int low, int high){if(low < high){int middle = mypartition(arr, low, high);quicksort(arr, low, middle-1);quicksort(arr, middle+1, high);}}对左边⼦数组排序时，⼦数组右边界是middle-1，如果链表也按这种两边都是闭区间的话，找到分割后枢纽元middle，找到middle-1还得再次遍历数组，因此链表的partition采⽤前闭后开的区间（这样排序主函数也需要前闭后开区间），这样就可以避免上述问题class Solution {public:ListNode *quickSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//链表快速排序if(head == NULL || head->next == NULL)return head;qsortList(head, NULL);return head;}void qsortList(ListNode*head, ListNode*tail){//链表范围是[low, high)if(head != tail && head->next != tail){ListNode* mid = partitionList(head, tail);qsortList(head, mid);qsortList(mid->next, tail);}}ListNode* partitionList(ListNode*low, ListNode*high){//链表范围是[low, high)int key = low->val;ListNode* loc = low;for(ListNode*i = low->next; i != high; i = i->next)if(i->val < key){loc = loc->next;swap(i->val, loc->val);}swap(loc->val, low->val);return loc;}};快速排序2（算法交换链表节点，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition，我们选取第⼀个节点作为枢纽元，然后把⼩于枢纽的节点放到⼀个链中，把不⼩于枢纽的及节点放到另⼀个链中，最后把两条链以及枢纽连接成⼀条链。
用Java实现常见的8种内部排序算法
⽤Java实现常见的8种内部排序算法⼀、插⼊类排序插⼊类排序就是在⼀个有序的序列中，插⼊⼀个新的关键字。
从⽽达到新的有序序列。
插⼊排序⼀般有直接插⼊排序、折半插⼊排序和希尔排序。
1. 插⼊排序1.1 直接插⼊排序/*** 直接⽐较，将⼤元素向后移来移动数组*/public static void InsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i]; //temp ⽤于存储元素，防⽌后⾯移动数组被前⼀个元素覆盖int j;for(j = i; j > 0 && temp < A[j-1]; j--) { //如果 temp ⽐前⼀个元素⼩，则移动数组A[j] = A[j-1];}A[j] = temp; //如果 temp ⽐前⼀个元素⼤，遍历下⼀个元素}}/*** 这⾥是通过类似于冒泡交换的⽅式来找到插⼊元素的最佳位置。
⽽传统的是直接⽐较，移动数组元素并最后找到合适的位置*/public static void InsertSort2(int[] A) { //A[] 是给定的待排数组for(int i = 0; i < A.length - 1; i++) { //遍历数组for(int j = i + 1; j > 0; j--) { //在有序的序列中插⼊新的关键字if(A[j] < A[j-1]) { //这⾥直接使⽤交换来移动元素int temp = A[j];A[j] = A[j-1];A[j-1] = temp;}}}}/*** 时间复杂度：两个 for 循环 O(n^2)* 空间复杂度：占⽤⼀个数组⼤⼩，属于常量，所以是 O(1)*/1.2 折半插⼊排序/** 从直接插⼊排序的主要流程是：1.遍历数组确定新关键字 2.在有序序列中寻找插⼊关键字的位置* 考虑到数组线性表的特性，采⽤⼆分法可以快速寻找到插⼊关键字的位置，提⾼整体排序时间*/public static void BInsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i];//⼆分法查找int low = 0;int high = i - 1;int mid;while(low <= high) {mid = (high + low)/2;if (A[mid] > temp) {high = mid - 1;} else {low = mid + 1;}}//向后移动插⼊关键字位置后的元素for(int j = i - 1; j >= high + 1; j--) {A[j + 1] = A[j];}//将元素插⼊到寻找到的位置A[high + 1] = temp;}}2. 希尔排序希尔排序⼜称缩⼩增量排序，其本质还是插⼊排序，只不过是将待排序列按某种规则分成⼏个⼦序列，然后如同前⾯的插⼊排序⼀般对这些⼦序列进⾏排序。
JAVA冒泡、插入、选择排序算法
import java.io.*;public class Paixu {// 冒泡排序法public void Maopao(int a[]) {for (int i = 1; i < a.length; i++) {for (int j = 0; j < a.length - i; j++) { if (a[j] > a[j + 1]) {int temp = a[j + 1];a[j + 1] = a[j];a[j] = temp;}}}System.out.println("\n" + "采用冒泡排序法：");}// 插入排序法：public void Charu(int a[]) {for (int i = 1; i < a.length; i++) {for (int j = 0; j < i; j++) {if (a[j] > a[i]) {int temp = a[i];for (int k = i; k > j; k--) {a[k] = a[k--];}a[j] = temp;}}}System.out.println("\n" + "采用插入排序法：");}// 选择排序法：public void Xuanze(int a[]) {for (int i = 0; i < a.length; i++) {int position = i;for (int j = i + 1; j < a.length; j++) {if (a[position] > a[j]) {int temp = a[position];a[position] = a[j];a[j] = temp;}}}System.out.println("\n" + "采用选择排序法：");}public void Print(int a[]) {System.out.println("从小到大排序结果为：");for (int i = 0; i < a.length; i++) {System.out.print(a[i] + ",");}}public static void main(String[] args) {int a[] = new int[5];Paixu px = new Paixu();BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));System.out.println("请输入五个整数：");for (int i = 0; i < a.length; i++) {try {String s = buf.readLine();int j = Integer.parseInt(s);a[i] = j;} catch (Exception e) {System.out.println("出错了！必须输入整数,请重新输入!");i--;}}System.out.println("您输入的整数依次为：");for (int i = 0; i < a.length; i++) {System.out.print(a[i] + ",");}System.out.println("\n" + "-------------");px.Maopao(a); // 调用冒泡算法px.Print(a);System.out.println("\n" + "-------------");px.Charu(a); // 调用插入算法px.Print(a);System.out.println("\n" + "-------------");px.Xuanze(a); // 调用选择算法px.Print(a);}}Java实现二分查找2008-11-19 21:38今天阿朗被问到二分查找竟然一着急没写出来。
java 排序方法
java 排序方法Java一种面向对象的程序设计语言，由 James Gosling其他 Sun Microsystems工于 1995 5发布，是最初的商业化 Java拟机实现，Java技术是功能强大而灵活的，它可以应用于众多领域。
在处理程序中，排序是一个非常重要的技术，可以有效地提高数据处理的效率。
在Java中，可以使用多种方法实现排序。
第一种是基于简单比较的排序方法，其中包括冒泡排序（Bubble Sort），选择排序（Selection Sort），插入排序（Insertion Sort）和希尔排序（Shell Sort）。
冒泡排序是基于简单比较的最简单算法，其原理是检查相邻的元素，如果第一个比第二个大，就交换它们。
通过重复这个过程，算法最终会将最大元素放到最右边。
冒泡排序是两层循环，外部循环控制循环次数，内部循环用于比较两个元素的大小，如果符合条件就进行交换。
选择排序（Selection Sort）也是基于简单比较，它的基本思想是从头到尾依次比较每个元素，将最小的元素放到数组的头部，接着比较第二小的元素，将其放到数组的第二个位置，以此类推，完成排序。
插入排序（Insertion Sort）也是一种比较简单的排序方法，它的原理是首先将第一个元素看作一个已排序的子序列，然后逐一将后面的元素插入到该子序列中，从而完成排序。
希尔排序（Shell Sort）是一种特殊的插入排序，它采用了插入排序的思想，但是将相距一定距离的元素插入到已排序的子序列中，从而达到提高排序效率的目的。
另一种是非基于简单比较的排序方法，其中包括快速排序（Quick Sort）和归并排序（Merge Sort）。
快速排序（Quick Sort）是一种比较典型的分治算法，它的基本思想是：首先在数组中选择一个中心点，将比中心点小的数放在左边，将比中心点大的数放在右边，然后依次对左右两边的数组进行快速排序，直到所有子数组有序。
归并排序（Merge Sort）也是一种分治算法，它的基本思想是将一个大的数组划分为两个小的子数组，然后将这两个子数组分别进行归并排序，最后将它们合并起来，形成一个有序的大数组。
冒泡排序法、选择排序法、插入排序法(java案例详解)
1.冒泡排序法/***功能：冒泡排序法*思想：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的排序码，*，若发现逆序这交换，使得排序码较小的元素逐渐从后部移向前部（从下标较大的单元移向下标）*较小的单元，，就像水底下的气泡一样逐渐向上冒。
*作者：徐守威*/package com.xushouwei;public class T4 {/***@param args*/public static void main(String[] args) {// TODO Auto-generated method stubint arr1[]={1,6,0,-1,9,-100,90};//开始排序,创建一个Bubble类Bubble bubble=new Bubble();bubble.sort(arr1);//输出最后结果for(int i=0;i<arr1.length;i++){System.out.print(arr1[i]+" ");}}}//定义一个Bubble类class Bubble{//排序方法public void sort(int arr[]){//第一层循环用来指定排序的次数//定义一个临时变量来存放交换的值int temp=0;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]){//交换位置temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}}}}2.选择排序法/***功能：选择排序法*思想：第一次从R[0]-R[N-1]中选取最小值，与R[0]交换，第二次从R[1]-R[N-1]中选取最小值，与R[1]交换，*第三次从R[2]-R[N-1]中选取最小值，与R[2]交换...第i次从R[i]-R[N-1]中选取最小值，与R[i-1]交换，*第n-1次从R[n-2]-R[N-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的*有序序列。
常用排序操作方法
常用排序操作方法
常用的排序操作方法有：
1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果前面的元素大于后面的元素则交换位置，依次比较直到最后一对元素。
2. 选择排序（Selection Sort）：每次从未排序的序列中选择最小（最大）的元素，放到已排序的序列的末尾，直到全部元素排序完成。
3. 插入排序（Insertion Sort）：将未排序的元素逐一插入到已排序的序列中的合适位置，从而实现排序。
4. 快速排序（Quick Sort）：选择一个基准元素，将小于基准元素的放在左侧，大于基准元素的放在右侧，然后对左右两个子序列进行递归排序。
5. 归并排序（Merge Sort）：将待排序序列不断二分为子序列，对子序列进行排序后再合并成有序序列。
6. 堆排序（Heap Sort）：将待排序序列构建成最大（最小）堆，然后将堆顶元素与末尾元素交换，然后重新调整堆为最大（最小）堆。
这些排序方法都具有不同的时间复杂度和适用场景，可以根据实际情况选择使用。