1.冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1 package com.rong; 2 3 public class MyClass { 4 5 /** 6 * @author 容杰龙 7 * 排序与查找 8 */ 9 public static void main(String[] args) { 10 //声明并初始化数组 11 int[] arrays=new int[]{5,2,1,9,0,3,7,4,6,8}; 12 showArray(arrays); 13 //冒泡排序 14 //bubbleSort(arrays); 15 bubbleSort2(arrays); 16 showArray(arrays); 17 } 18 //这个方向》》》》》》》》》》》》比较 19 private static void bubbleSort(int[] arrays) { 20 for (int i = 0; i < arrays.length-1; i++) { 21 for (int j = 0; j < arrays.length-i-1; j++) { 22 if(arrays[j]>arrays[j+1]){ 23 int temp=arrays[j]; 24 arrays[j]=arrays[j+1]; 25 arrays[j+1]=temp; 26 } 27 } 28 } 29 } 30 //这个方向《《《《《《《《《《《《《《比较 31 private static void bubbleSort2(int[] arrays) { 32 for (int i = 0; i < arrays.length-1; i++) { 33 for (int j = arrays.length-1; j > i; j--) { 34 if(arrays[j-1]>arrays[j]){ 35 int temp=arrays[j-1]; 36 arrays[j-1]=arrays[j]; 37 arrays[j]=temp; 38 } 39 } 40 } 41 } 42 //打印数组元素 43 private static void showArray(int[] arrays) { 44 for (int array : arrays) { 45 System.out.print(array+" "); 46 } 47 System.out.println(); 48 } 49 }
2.选择排序
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
1 public static void main(String[] args) { 2 //声明并初始化数组 3 int[] arrays=new int[]{5,2,1,9,0,3,7,4,6,8}; 4 showArray(arrays); 5 //selectSort(arrays); 6 selectSort2(arrays); 7 showArray(arrays); 8 } 9 //这个方向>>>>>>>>>>>>>>>>比较 10 private static void selectSort2(int[] arrays) { 11 for (int i = 0; i < arrays.length-1; i++) { 12 int position=i; 13 for (int j = arrays.length-1; j >i; j--) { 14 if (arrays[position]>arrays[j]) { 15 position=j; 16 } 17 } 18 if (position!=i) { 19 int temp=arrays[position]; 20 arrays[position]=arrays[i]; 21 arrays[i]=temp; 22 } 23 } 24 } 25 //这个方向<<<<<<<<<<<<<<<<比较 26 private static void selectSort(int[] arrays) { 27 for (int i = 0; i < arrays.length-1; i++) { 28 int position=i; 29 for (int j = i+1; j < arrays.length; j++) { 30 if (arrays[position]>arrays[j]) { 31 position=j; 32 } 33 } 34 if (position!=i) { 35 int temp=arrays[position]; 36 arrays[position]=arrays[i]; 37 arrays[i]=temp; 38 } 39 } 40 }
3.插入排序
每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。
1 public static void main(String[] args) { 2 //声明并初始化数组 3 int[] arrays=new int[]{5,2,1,9,0,3,7,4,6,8}; 4 showArray(arrays); 5 insertSort(arrays); 6 showArray(arrays); 7 } 8 private static void insertSort(int[] arrays) { 9 for (int i = 1; i < arrays.length; i++) { 10 for (int j = i; j >0; j--) { 11 if (arrays[j-1]>arrays[j]) { 12 int temp=arrays[j-1]; 13 arrays[j-1]=arrays[j]; 14 arrays[j]=temp; 15 }else { 16 break; 17 } 18 } 19 } 20 }
4.快速排序
选择一个基准元素（枢纽元素）,通常选择第一个元素或者最后一个元素，通过一趟扫描，将待排序列分成两部分，一部分比基准元素小，一部分大于等于基准元素，此时基准元素在其排好序后的正确位置，然后再用同样的方法递归地排序划分的两部分。
1 public static void main(String[] args) { 2 //声明并初始化数组 3 int[] arrays=new int[]{5,2,1,9,0,3,7,4,6,8}; 4 showArray(arrays); 5 quick(arrays); 6 showArray(arrays); 7 } 8 public static int getMiddle(int[] arrays, int low, int high) { 9 int temp = arrays[low]; // 数组的第一个作为中轴 10 while (low < high) { 11 while (low < high && arrays[high] > temp) { 12 high--; 13 } 14 arrays[low] = arrays[high];// 比中轴小的记录移到低端 15 while (low < high && arrays[low] < temp) { 16 low++; 17 } 18 arrays[high] = arrays[low]; // 比中轴大的记录移到高端 19 } 20 arrays[low] = temp; // 中轴记录到尾 21 return low; // 返回中轴的位置 22 } 23 24 public static void quickSort(int[] arrays, int low, int high) { 25 if (low < high) { 26 int middle = getMiddle(arrays, low, high); // 将numbers数组进行一分为二 27 quickSort(arrays, low, middle - 1); // 对低字段表进行递归排序 28 quickSort(arrays, middle + 1, high); // 对高字段表进行递归排序 29 } 30 31 } 32 33 public static void quick(int[] arrays) { 34 if (arrays.length > 0) // 查看数组是否为空 35 { 36 quickSort(arrays, 0, arrays.length - 1); 37 } 38 }
5.顺序查找
1 public static void main(String[] args) { 2 //声明并初始化数组 3 int[] arrays=new int[]{5,2,1,9,0,3,7,4,6,8}; 4 showArray(arrays); 5 int target=3; 6 int index = orderSearch(arrays,target); 7 System.out.println(index); 8 showArray(arrays); 9 } 10 private static int orderSearch(int[] arrays, int target) { 11 for (int i = 0; i < arrays.length; i++) { 12 if (arrays[i]==target) { 13 return i; 14 } 15 } 16 return -1; 17 }
6.二分查找（折半查找）
二分查找，又叫折半查找，要求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。
1 public static void main(String[] args) { 2 //声明并初始化数组 3 int[] arrays=new int[]{5,2,1,9,0,3,7,4,6,8}; 4 showArray(arrays); 5 //先使数组有序，后查找 6 quick(arrays); 7 int target=3; 8 //int index = binarySearch(arrays,target); 9 int index = binarySearch2(arrays,target,0,arrays.length-1); 10 System.out.println(index); 11 showArray(arrays); 12 } 13 14 //非递归实现二分查找 15 private static int binarySearch(int[] arrays, int target) { 16 int low=0; 17 int high=arrays.length-1; 18 while(low<=high){ 19 int middle=(low+high)/2; 20 if(arrays[middle]==target){ 21 return middle; 22 }else if(arrays[middle]>target){ 23 high=middle-1; 24 }else { 25 low=middle+1; 26 } 27 } 28 return -1; 29 } 30 //递归实现二分查找 31 private static int binarySearch2(int[] arrays, int target,int low,int high) { 32 if (low<=high) { 33 int middle=(low+high)/2; 34 if(arrays[middle]==target){ 35 return middle; 36 }else if (arrays[middle]>target) { 37 return binarySearch2(arrays, target, low, middle-1); 38 }else { 39 return binarySearch2(arrays, target, middle+1, high); 40 } 41 } 42 return -1; 43 }