1、冒泡排序：
冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
具体代码例一：
package com.abin.lee.algorithm.bubble;
public class BubbleSort {
public static void main(String[] args) {
int[] start={5,2,1,3,6,4};
int[] end=sort(start);
for(int i=0;i<end.length;i++){
System.out.println("end["+i+"]="+end[i]);
}
}
public static int[] sort(int[] input){
int temp=0;
//最多做n-1趟排序
for(int i=0;i<input.length-1;i++){
//对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
for(int j=0;j<input.length-i-1;j++){
//把大的值交换到后面
if(input[j]>input[j+1]){
temp=input[j];
input[j]=input[j+1];
input[j+1]=temp;
}
StringBuffer stb=new StringBuffer();
for(int k=0;k<input.length;k++){
stb.append("input["+k+"]="+input[k]+" ");
}
System.out.println("i="+i+",j="+j+" = "+stb.toString());
}
}
return input;
}
}
2、选择排序：
选择排序(Straight Select Sorting) 也是一种简单的排序方法，它的基本思想是：第一次从R[0]~R[n-1]中选取最小值，与R[0]交换，第二次从R{1}~R[n-1]中选取最小值，与R[1]交换，....， 第i次从R[i-1]~R[n-1]中选取最小值，与R[i-1]交换，.....，第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换,总共通过n-1次,得到一个按排序码从小到大排列的有序序列.
具体代码：
package com.abin.lee.algorithm.select;
public class SelectSort {
public static void main(String[] args) {
int[] start={5,2,3,1,6,4};
start=sort(start);
for(int i=0;i<start.length;i++){
System.out.println("start["+i+"]="+start[i]);
}
}
public static int[] sort(int[] input){
int temp=0;
for(int i=0;i<input.length;i++){
for(int j=i+1;j<input.length;j++){
if(input[i]>input[j]){
temp=input[i];
input[i]=input[j];
input[j]=temp;
}
StringBuffer stb=new StringBuffer();
for(int k=0;k<input.length;k++){
stb.append("input["+k+"]="+input[k]+" ");
}
System.out.println("i="+i+",j="+j+" = "+stb.toString());
}
}
return input;
}
}
3、请输入一个数字，比如4，输出为：
1
2 3
4 5 6
7 8 9 10
代码如下：
package com.abin.lee.photo;
public class TestInputNumber {
public static void main(String[] args) {
int n=4;
output(n);
}
public static void output(int n){
int temp=1;
for(int i=1;i<=n;i++){
for(int j=0;j<i;j++){
System.out.print(temp+" ");
temp++;
}
System.out.println("");
}
}
}
4.二叉树算法
package com.abin.lee.algorithm.binary;
public class BinaryNode {
public int data;//根节点
BinaryNode left;//左节点
BinaryNode right;//右节点
public BinaryNode(int data,BinaryNode left,BinaryNode right) {
this.data=data;
this.left=left;
this.right=right;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public BinaryNode getLeft() {
return left;
}
public void setLeft(BinaryNode left) {
this.left = left;
}
public BinaryNode getRight() {
return right;
}
public void setRight(BinaryNode right) {
this.right = right;
}
}
package com.abin.lee.algorithm.binary;
public class BinaryTree {
//前序遍历
public static void preOrder(BinaryNode root){
if(null!=root){
System.out.print(root.data+"-");
preOrder(root.left);
preOrder(root.right);
}
}
//中序遍历
public static void inOrder(BinaryNode root){
if(null!=root){
inOrder(root.left);
System.out.print(root.data+"--");
inOrder(root.right);
}
}
//后序遍历
public static void postOrder(BinaryNode root){
if(null!=root){
postOrder(root.left);
postOrder(root.right);
System.out.print(root.data+"---");
}
}
public static void main(String[] args) {
BinaryNode one=new BinaryNode(1,null,null);
BinaryNode three=new BinaryNode(3,null,null);
BinaryNode two=new BinaryNode(2,three,one);
BinaryNode four=new BinaryNode(4,one,two);
BinaryNode five=new BinaryNode(5,four,one);
System.out.println("preOrder");
preOrder(five);
System.out.println();
System.out.println("inOrder");
inOrder(five);
System.out.println();
System.out.println("postOrder");
postOrder(five);
System.out.println();
}
}
输出结果：
preOrder
5-4-1-2-3-1-1-
inOrder
1--4--3--2--1--5--1--
postOrder
1---3---1---2---4---1---5---
5、java插入排序
插入式排序法——插入排序法
插入排序（Insertion Sortion）的基本思想是：把n个待排序的元素看成一个有序表和一个无序表，开始有序表只包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
public class InjectionSort //定义一个 InjectionSort 类
public static void injectionSort(int[] number) //传数组
for(int j = 1;j<number.length;j++)//循环
int tmp = number[j]; //循环把数组第二个值放到tmp里
int i = j-1//给i 赋值
while(tmp<number[i]) //tmp值和数组第一个值比较谁小
number[i+1] = number[i]; //如果小于就把第一个值赋值给第二个
i--;
if(i == -1)//如果i值=-1
break; //退出循环
number[i+1] = tmp //因为比较数组里的前一个比后一个这样就换交了实现了把小的放在前面
这是第一次，因为循环是一个数组，后边的就一次往下循环，最后就把数组里的顺序从小到大排序了
public static void main(String[] args){
int[] num = {5,46,26,67,2,35};//定义数组num
injectionSort(num);//调用方法
for(int i = 0;i<num.length;i++){
System.out.println(num[i]);//显示排序后的数组，一行显示一个值
简单说就是数组里第二个和第一个比谁小，把小的放到第一个里，大的放到第二个里，然后第二个再和第三个比，小的还是放在前，一直比到这个数组结束，这样就实现了从小到大，希望我说的够详细
插入排序代码while循环：
package com.abin.lee.algorithm.insert;
public class InsertSort {
public static void main(String[] args) {
int[] input = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
input=sort(input);
for (int i = 0; i < input.length; i++) {
System.out.print(input[i] + " ");
}
}
public static int[] sort(int[] input) {
for (int i = 1; i < input.length; i++) {
int insertVal = input[i];
// insertValue准备和前一个数比较
int index = i - 1;
while (index >= 0 && insertVal < input[index]) {
// 将把input[index]向后移动
input[index + 1] = input[index];
// 让index向前移动一位
index--;
}
// 将insertValue插入到适当位置
input[index + 1] = insertVal;
//下面这个循环是为了打印一下中间的循环看看是不是插入排序的正确算法
StringBuffer stb=new StringBuffer();
for(int k=0;k<input.length;k++){
stb.append(input[k]+" ");
}
System.out.println("i="+i+" = "+stb.toString());
}
return input;
}
}
插入排序for循环代码：
package com.abin.lee.algorithm.insert;
public class DoInsertSort {
public static void main(String[] args) {
int[] input={5,4,6,3,7,2,8,1,0,9};
input=sort(input);
for(int i=0;i<input.length;i++){
System.out.print("input["+i+"]="+input[i]+" ");
}
}
public static int[] sort(int[] input){
for(int i=1;i<input.length;i++){
int temp=input[i];
int j;
for(j=i;j>0;j--){
if(temp<input[j-1]){
input[j]=input[j-1];
}else{
break;
}
}
input[j]=temp;
//下面这个循环是为了打印一下中间的循环看看是不是插入排序的正确算法
StringBuffer stb=new StringBuffer();
for(int k=0;k<input.length;k++){
stb.append(input[k]+" ");
}
System.out.println("i="+i+" = "+stb.toString());
}
return input;
}
}
二分查找又称折半查找，它是一种效率较高的查找方法。
折半查找的算法思想是将数列按有序化(递增或递减)排列，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置为比较对象，如果要找的元素值小于该中点元素，则将待查序列缩小为左半部分，否则为右半部分。通过一次比较，将查找区间缩小一半。 折半查找是一种高效的查找方法。它可以明显减少比较次数，提高查找效率。但是，折半查找的先决条件是查找表中的数据元素必须有序。
package com.abin.algorithm.template.half;
public class BinarySearch {
public static void main(String[] args) {
int[] src=new int[]{1,3,5,7,9,11};
int result=binarySearch(src, 3);
System.out.println("result="+result);
int status=binarySearch(src, 9 ,0 ,src.length);
System.out.println("status="+status);
}
//循环实现
public static int binarySearch(int[] src,int key){
int low=0;
int high=src.length-1;
while(low<=high){
int middle=(low+high)/2;
if(key==src[middle]){
return middle;
}else if(key<src[middle]){
high=middle-1;
}else{
low=middle+1;
}
}
return -1;
}
//递归实现
public static int binarySearch(int[] src,int key,int low,int high){
int middle=(low+high)/2;
if(src[middle]==key){
return middle;
}else if(low>=high){
return -1;
}else if(src[middle]>key){
return binarySearch(src, key, low, middle-1);
}else if(src[middle]<key){
return binarySearch(src, key, middle+1, high);
}
return -1;
}
}