六大算法： 插入、选择、冒泡、快速、二分、水桶

JAVA经典算法链接：转载请注明出处:http://blog.csdn.net/l1028386804/article/details/51097928

 

 

 

*************************冒泡排序******************************

int[] arr = {5, 1, 2, 3, 7, 8, 6, 4};

int flag = 0;//0代表无序，1代表有序

//外循环决定需要几次冒泡

for(int i = 0 ;i<arr.length-1 && flag == 0;i++)

{ //假定数据有序

flag = 1;

//内循环决定一次冒泡的过程

for(int j=0;j<arr.length-1-i;j++)

//冒泡排序的核心算法，两两比较，满足条件交换

{

if(arr[j]>arr[j+1])

{

int t = arr[j];

arr[j] = arr[j+1];

arr[j+1] = t;

//确定无序

flag = 0;

}

}

}

for(int i =0; i<arr.length;i++)

{

System.out.print(arr[i]+" ");

}

 

}

 

*************************选择排序******************************

排序原理图如下

 

public class Tex {

public static void main(String[] args) {

int[] arr = {6, 7, 2, 1, 3, 8, 9};

for (int i = 0; i < arr.length; i++) {

int minIndex = i;//假定最小数的下标是第一个

for (int j = i; j < arr.length; j++) {

if(arr[minIndex] > arr[j]){

minIndex = j;

}

}

System.out.println("下标为"+minIndex+"最小值为"+arr[minIndex]);

int temp = arr[i];

arr[i] = arr[minIndex];

arr[minIndex] = temp;

}

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i]+" ");

}

}

}

 

 

插入排序原理

*************************插入排序******************************

public class insert1 {

public static void main(String[] args) {

int[] arr = {5, 7, 2, 1, 3, 6, 9};

//插入排序

for (int i = 1; i < arr.length; i++) {

int j =i;

int temp = arr[j];//取得有序区最后一个元素的值，进入二层循环

while ( j>0 && temp < arr[j-1]){//判断无序区下标（j > 0）不能溢出，判断和前一个数比较

arr[j] = arr[j-1];//进入循环，为要插入的数据留空间，数组后移一位

j--;//下标递减

}

arr[j] = temp;//最后和有序区最后一个元素交换

for (int k = 0; k < arr.length; k++) {

System.out.print(arr[k]+" ");}

System.out.println();

}

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i]+" ");

}

}

 

}

 

*************************水桶排序******************************

public class Barril {

public static void main(String[] args) {

int[] arr = {5, 7, 2, 1, 3, 6, 9};

int[] arr1 = new int[10];

for(int i = 0; i < arr.length; i++){

arr1[arr[i]]++;

}

for (int i = 0; i < arr1.length; i++) {

}

for(int i = 0 ; i < arr1.length; i++)

for(int j = 0; j < arr1[i]; j++){

System.out.print(i);

}

}

 

}

 

*************************二分查找******************************

必须是有序数列

public static int binarrySeek(int target, int[] src) {

int start = 0;

int end = src.length - 1;

while (start <= end) {

int mid = (start + end) / 2;

if(target > src[mid]){

start = mid +1;

}else if (target < src[mid]) {

end = mid - 1;

} else {

return mid;

}

}

return -1;

}

 

}

 

*************************二分查找******************************

 

//折半查找

public static int binarrySeek(int target, int[] src) {

int start = 0;

int end = src.length - 1;

while (start <= end) {

int mid = (start + end) / 2;

if(target > src[mid]){

start = mid +1;

}else if (target < src[mid]) {

end = mid - 1;

} else {

return mid;

}

}

return -1;

}

 

*************************快速查找（递归）***************************

public static void quickSort(int[] src, int start , int end) {//start和end 是为了递归

if(start >= end) {

//只有一个一下元素，返回

return;

}

int s = start;//定义起点

int e = end;//定义终点

//选出start指向的元素作为基准值

int temp = src[s];

while (s < e) { //起点和终点不重合

while (s < e &&src[e] > temp) { //开始都在基准值右边 当前数据合格 start < end 防止end-过头

e--;//大于基准值不动

}

if (s == e) {

break;//表示基准值找到了位置

}

src[s] = src[e];//小于src【s】的值放在src【s】左右

s++;

while (s < e && src[s] < temp) {//当前数据合格

s++;

}

if (s == e) {

break;

}

src[e] = src[s];

e--;

}

src[s] = temp;//起点终点重合，基准值找到了自己的位置

quickSort(src, start, s - 1);

quickSort(src, s + 1, src.length - 1);

}

*************************快速查找（非递归）**************************

 

import java.util.Arrays;

import java.util.LinkedList;

 

public class Demo2 {

 

public static void main(String[] args) {

int a[] = { 1, 3, 4, 2, 5, 7, 6, 9, 8, 10 };

quickSort(a);

System.out.println(Arrays.toString(a));

}

 

public static void quickSort(int[] a) {

int[] range = { 0, a.length - 1 };

 

LinkedList<int[]> stack = new LinkedList<int[]>();

stack.offerLast(range);

 

while (!stack.isEmpty()) {

int[] r = stack.pollLast();

int start = r[0];

int end = r[1];

int temp = a[start];

while (start < end) {

while (start < end && a[end] > temp) {

end--;

}

 

if (start == end) {

break;

}

 

a[start] = a[end];

start++;

 

while (start < end && a[start] < temp) {

start++;

}

 

if (start == end) {

break;

}

 

a[end] = a[start];

end--;

}

a[start] = temp;

if (r[0] < start - 1) {

stack.offerLast(new int[] { r[0], start - 1 });

}

if (r[1] > start + 1) {

stack.offerLast(new int[] { start + 1, r[1] });

}

}

}

}