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;
}
}