排序算法
1 冒泡排序
长度为 i 的数组元素两两比较,不符合顺序,就交换两个元素的位置:
/**
-
冒泡排序
*/
public class BubbleSort {public static void main(String[] args) {
int[] arr = new int[]{1, 4, 10, 5, 3, 2, 19, 23, 11};
sort(arr);
System.out.println(Arrays.toString(arr));
}/**
- 升序
- @param arr
*/
private static void sort(int[] arr){
int temp;
for(int i=0; i<arr.length; i++){
for(int j=0; j<i; j++){
if(arr[i] < arr[j]){
temp = arr[i];
arr[i] =arr[j];
arr[j] = temp;
}
}
}
}
}
2 快速排序
令索引 i 从数列左方往右方查找,知道找到小于 base 的数
令索引 j 从数列右方往左方查找,知道找到大于 base 的数
如果 i<=j 则交换 i 和 j 两处的值,如果 i>j 离开循环
如果 start<j,对基数左边轴递归
如果 end>i,对基数右边轴递归
package com.cary.serial;
import java.util.ArrayList;
import java.util.Arrays;
/**
-
快速排序
*/
public class QuickSort {public static void main(String[] args) {
int[] arr = new int[]{1, 4, 10, 5, 3, 2, 19, 23, 11};
sort(arr, 0, arr.length-1);
System.out.println(Arrays.toString(arr));
}/**
-
升序
-
@param arr
*/
private static void sort(int[] arr, int start, int end){
if(start < end){
int base = arr[start];//以第一个元素为基准
int i = start;
int j = end;
int temp;do{ while(arr[i]<base && i<end) i++; while(arr[j]>base && j>start) j--; if(i <= j){ temp = arr[j]; arr[j] = arr[i]; arr[i] = temp; i++; j--; } }while (i <= j); if(start < j){ sort(arr, start, j); } if(i < end){ sort(arr, i, end); }
}
}
-
}
3. 选择排序
每次循环都遍历出数组中最小元素,记录索引值
通过索引值,将最小元素放到数组的最左边
对剩余未排序的元素数组再执行上述两个步骤
package com.cary.serial;
import java.util.Arrays;
/**
-
选择排序
*/
public class SelectSort {public static void main(String[] args) {
int[] arr = new int[]{1, 4, 10, 5, 3, 2, 19, 23, 11};
sort(arr);
System.out.println(Arrays.toString(arr));
}/**
- 升序
- @param arr
*/
private static void sort(int[] arr){
for(int i=0; i<arr.length; i++){
int min = i;
for(int j=i+1; j<arr.length; j++){
if(arr[j] < arr[min]){
min = j;
}
}
if(min != i){
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
}
4 插入排序
/**
* 插入排序
*
* 从第一个元素开始,该元素可以认为已经被排序
* 取出下一个元素,在已经排序的元素序列中从后向前扫描
* 如果该元素(已排序)大于新元素,将该元素移到下一位置
* 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
* 将新元素插入到该位置中
* 重复步骤2
* @param numbers 待排序数组
*/
public static void insertSort(int[] numbers)
{
int size = numbers.length;
int temp = 0 ;
int j = 0;
for(int i = 0 ; i < size ; i++)
{
temp = numbers[i];
//假如temp比前面的值小,则将前面的值后移
for(j = i ; j > 0 && temp < numbers[j-1] ; j --)
{
numbers[j] = numbers[j-1];
}
numbers[j] = temp;
}
}
查找算法
- 二分非递归查找
算法思想:又叫折半查找,要求待查找的序列有序。每次取中间位置的值与待查关键字比较,如果中间位置的值比待查关键字大,则在前半部分循环这个查找的过程,如果中间位置的值比待查关键字小,则在后半部分循环这个查找的过程。直到查找到了为止,否则序列中没有待查的关键字。
package com.cary.serial;
import java.util.Arrays;
/**
-
二分查找
*/
public class BinarySearch {public static void main(String[] args) {
int[] arr = new int[]{1, 3, 11, 15, 17, 18, 19, 23, 29};
System.out.println(search(arr, 15));
}private static int search(int[] arr, int number){
int start = 0;
int end = arr.length-1;
while(start<=end){
int middle = (start+end)/2;
if(number==arr[middle]){
return middle+1;
} else if(number < arr[middle]){
end = middle-1;
} else {
start = middle+1;
}
}
return -1;
}
}
- 二分递归查找
package com.cary.serial;
import java.util.Arrays;
/**
-
二分查找
*/
public class BinarySearch {public static void main(String[] args) {
int[] arr = new int[]{1, 3, 11, 15, 17, 18, 19, 23, 29};
System.out.println(search(arr, 0, arr.length-1, 15));
}private static int search(int[] arr,int start, int end, int number){
if(start <= end){
int middle = (start+end)/2;if(number == arr[middle]){ return middle+1; } else if(number<arr[middle]){ return search(arr, start, middle-1, number); } else { return search(arr, middle+1, end, number); } } return -1;
}
}