冒泡排序
假设一个数组中有n个元素；
从数组的第一个元素开始，中是比较与后一个元素，如果前一个元素大于后一个元素，就交换位置，否则继续比较后面的元素，直到选出最大的元素。这样的排序类似于水中的冒泡，越大的泡上升的速度越快。这样一共比较n次，第i趟比较n-i-1次。
实现：
package org.westos.demo;
import java.util.logging.Level;
public class Sort {
public static void main(String[] args) {
int[] array={43,12,76,32,9,59};
sortByBub(array);
String s=bianLi(array);
System.out.println(s);
}
//遍历数组，以字符串的形式输出
private static String bianLi(int[] array) {
String s="[";
for (int i=0;i<array.length;i++){
if(i==array.length-1){
s+=array[i]+"]";
}else{
s+=array[i]+",";
}
}
return s;
}
private static void sortByBub(int[] array) {
//循环的趟数
for (int i=0;i<array.length-1;i++){
//每趟比较最大的数
for (int j=0;j<array.length-i-1;j++){
if(array[j]>array[j+1]){
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
}
}
}
}
}
选择排序
相当于将数组分成有序和无序两部分，前面的部分为从小到大的有序部分，每一次拿无序部分的第一个元素和剩余的元素挨个去比较，每一次比较都选出无序部分最小的那一个放到无序的第一个。
实现：
private static void sortBySelect(int[] array) {
for (int i=0;i<array.length-1;i++){
int index=i;
//选出每趟中最小的数往有序部分中依次插入
for(int j=index;j<array.length-1;j++){
if(array[index]>array[j+1]){
int tmp=array[index];
array[index]=array[j+1];
array[j+1]=tmp;
}
}
}
}
n=6
第一趟：index=0；排序后：9, 43,76,32,12,59
第二趟：index=1；排序后：9,12, 76,43,32,59
第三趟：index=2；排序后：9,12,32, 76,43,59
第四趟：index=3；排序后：9,12,32,43, 76,59
第五趟：index=4；排序后：9,12,32,43,59 76
插入排序
和选择排序原理基本相同，分为逻辑上的有序和无序部分，只是插入排序每次从无序序列中选出第一个元素，然后在有序序列中找到合适的位置进行排序。而选择排序是每次从无序序列中选出最小的那一个，直接放在有序序列的最后一个位置。
package org.westos.demo;
public class InsetSort {
public static void main(String[] args) {
int[] array={43,65,21,3,798,45,67};
insertSort(array);
travelArray(array);
}
public static void insertSort(int[] array){
//控制插入元素的个数，也就是控制次数
for (int i=0;i<array.length-1;i++){
//将无序序列中的第一个元素与有序序列中的比较
//找到合适的位置
int j=i;
//循环比较，直到前面的数比要插入的数小为止
while (j>=0&&array[j]>array[j+1]){
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
j--;
}
}
}
public static void travelArray(int[] array){
for (int i=0;i<=array.length-1;i++){
if(i==0){
System.out.print("["+array[i]+",");
}else if(i==array.length-1){
System.out.print(array[i]+"]");
}else {
System.out.print(array[i]+",");
}
}
}
}
二分法查找
输入一个有序数组和一个要查找的值elem，如果数组中存在elem则返回这个数的索引，则否返回-1；
实例：
private static int searchBydichotomy(int[] array, int elem) {
int maxIndex=array.length-1;
int minIndex=0;
int midIndex=(maxIndex+minIndex)/2;
//循环终止条件中间的索引不再小于最大数的索引
while (midIndex<maxIndex){
if(elem==array[midIndex]){
//如果找到就返回这个数的索引
return midIndex;
//如果被查的数小于中间的数则将最大数的索引变为中间索引减1，相当于下次将查找数组的前半部分
}else if(elem<array[midIndex]){
maxIndex=midIndex-1;
// 如果被查的数小于中间的数则将最小数的索引变为中间索引加1，下次差查找数组的后半部分
}else if(elem>array[midIndex]){
minIndex=midIndex+1;
}
midIndex=(maxIndex+minIndex)/2;
}
//如果没找到则返回-1
return -1;
}
快速排序
使用递归算法，每次找出基数的正确位置将数组分成逻辑的两部分，继续将左右两部分进行快速排序，每次保证左边索引小于右边索引。
package org.westos.Sort;
public class QuiklySort {
public static void main(String[] args) {
int[] array = {54, 32, 76, 90, 102, 5, 23, 78};
quickSort(array, 0, array.length-1);
//将数组遍历成字符形式
for (int i=0;i<=array.length-1;i++){
if(i==0){
System.out.print("["+array[i]+",");
}else if(i==array.length-1){
System.out.print(array[i]+"]");
}else {
System.out.print(array[i]+",");
}
}
}
private static void quickSort(int[] array, int left, int right) {
if (left < right) {
int index = getIndex(array, left, right);
quickSort(array,left,index-1);
quickSort(array,index+1,right);
}
}
public static int getIndex(int[] array, int left, int right) {
int mid = array[left];
//循环直到左边的所有数小于基数，右边的所有基数大于基数，直到找出基数正确的位置
while (left < right) {
//从右向左找，如果右边的数大于基数，则继续right--
while (left<right&&mid <= array[right]) {
right--;
}
//直到找到小于基数的那个数，填入左边的坑，换左边的数开始比较
if(left<right){
array[left] = array[right];
left++;
}
//从左向右找，如果左边的数小于基数，则继续像右找，left++
while (left<right&&mid > array[left]) {
left++;
}
//直到在左边找到比基数大的数，将它填入右边的坑，再比较右边的数
if(left<right){
array[right] = array[left];
right--;
}
}
//把基数填到数组空缺中，并返回它的索引
array[left]=mid;
return left;
}
}
