[TOC]
排序
冒泡排序法
冒泡排序法，利用两层嵌套循环，相邻数据进行比较，每次内层循环结束，把当前最大数交换到最后。
public class BubbleSort{
public static void mian(String[] args) {
int[] arr = {2, 3, 5, 6, 9, 1, 3, 5, 10, 12};
sort(arr);
for(int i=0; i< arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static void sort(int[] arr){
int length = arr.length;//数组长度
int temp;//用于交换
for(int i = 0; i< length - 1; i++) {//外圈循环
for(int j = 0; j < length - i -1; j++) {//每次循环后，会把最大值交换到最后，所以去除已经排序好的数据
if(arr[j] > arr[j + 1]) {
//判断前面数是否大于后面数，若是，则交换位置
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
快速排序法
快速排序法利用到分治和递归的思想，基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
public class QuickSort{
public static void main(String[] args) {
int[] arr = {2, 3, 5, 6, 9, 1, 3, 5, 10, 12};
int left = 0;
int right = arr.length-1;
sort(arr, left, right);
for(int i=0; i< arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
/**
* 快速排序
* @param arr 数据源
* @param left 起始数据的位置
* @param end 结束数据的位置
*/
public static void sort(int[] arr, int left, int right){
if(right > left) {
int midst = findMidst(arr, left, right); //找到基准点
sort(arr, left, midst); //对左侧排序
sort(arr, midst + 1, right); //对右侧排序
}
}
public static int findMidst(int[] arr, int left, int right) {
int midst = arr[left];
while(right > left) {
//从右向左循环，找到比基准数小的
while(right > left && arr[right] >= midst) {
right--;
}
arr[left] = arr[right];
//从左向右循环，找到比基准数大的
while(right > left && arr[left] <= midst) {
left++;
}
arr[right] = arr[left];
}
arr[left] = midst;
return left;
}
}
插入排序法
插入排序法，假设在要排序的一组数中，前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
public class InsertSort {
public static void main(String[] args) {
int[] arr = { 4, 3, 5, 6, 9, 1, 3, 5, 10, 12, 9, 1 };
sort(arr);
for (int k = 0; k < arr.length; k++) {
System.out.print(arr[k] + " ");
}
}
public static void sort(int[] arr) {
if (arr != null && arr.length > 1) {
for (int i = 1; i < arr.length; i++) {
int temp = arr[i]; //要插入的数据
int j;
for (j = i - 1; j >= 0; j--) {
if (arr[j] > temp) {
arr[j + 1] = arr[j];
} else {
break;
}
}
//此处注意 j会先-1，在判断j是否符合条件，故需要+1
arr[j + 1] = temp;
}
}
}
}
选择排序法
一组需要排序的数中，假设第一个数最小，遍历数组和其比较，找出最小的数和它交换位置，如此反复，即可全部排序。
public class SelectSort {
public static void main(String[] args) {
int[] arr = { 4, 3, 5, 6, 9, 1, 3, 5, 10, 12, 9, 1 };
sort(arr);
for (int k = 0; k < arr.length; k++) {
System.out.print(arr[k] + " ");
}
}
public static void sort(int[] arr) {
int pos;
int temp;
for(int i = 0; i < arr.length; i++) {
pos = i;
for(int j = i+1; j < arr.length; j++) {
if(arr[j] < arr[pos]) {
pos = j;
}
}
if(pos != i){
temp = arr[pos];
arr[pos] = arr[i];
arr[i] = temp;
}
}
}
}
希尔排序
在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序，然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。
public class ShellSort {
public static void main(String[] args) {
int[] arr = { 4, 3, 5, 6, 9, 1, 3, 5, 10, 12, 9, 1 };
sort(arr);
for (int k = 0; k < arr.length; k++) {
System.out.print(arr[k] + " ");
}
}
public static void sort(int[] arr) {
if (arr != null && arr.length > 2) {
int index = arr.length / 2;
while (true) {
for (int i = 0; i < index; i++) {
for (int j = i; j + index < arr.length; j += index) {
if(arr[j] > arr[j+index]) {
int temp = arr[j];
arr[j] = arr[j + index];
arr[j+ index] = temp;
}
}
}
if(index == 1) {
break;
}
index--;
}
}
}
}
查找
二分查找法
二分查找法，是对有序的序列进行折半查找，每次以序列的中间位置的数来与待查找的关键字进行比较，以确认下一查找区间的位置，直到匹配成功
public class BinarySearch {
public static void main(String[] args) {
int[] arr = { 55, 3, 5, 6, 9, 11, 34, 5, 10, 12, 9, 1 };
int target = search(arr, 0, arr.length - 1, 26);
System.out.println("target = " + target);
target = search(arr, 99);
System.out.println("target = " + target);
}
/**
* 递归实现
* @param arr
* @param start
* @param end
* @param target
* @return
*/
public static int search(int[] arr, int start, int end, int target) {
int middle = (start + end) / 2;
if(arr[end] < target || arr[start] > target || start > end) {
return -1;
}
if (arr[middle] == target) {
return middle;
} else if (arr[middle] > target) {
return search(arr, middle + 1, end, target);
} else{
return search(arr, 0, middle - 1, target);
}
}
/**
* 循环实现
* @param arr
* @param target
* @return
*/
public static int search(int[] arr, int target) {
int start = 0;
int end = arr.length - 1;
while(start <= end) {
int middle = (start + end) / 2;
if(arr[middle] == target) {
return middle;
}else if(arr[middle] > target) {
start = middle +1;
}else {
end = middle - 1;
}
}
return -1;
}
}
