1、冒泡排序：
冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個(gè)數(shù)，將小數(shù)放在前面，大數(shù)放在后面。即在第一趟：首先比較第1個(gè)和第2個(gè)數(shù)，將小數(shù)放前，大數(shù)放后。然后比較第2個(gè)數(shù)和第3個(gè)數(shù)，將小數(shù)放前，大數(shù)放后，如此繼續(xù)，直至比較最后兩個(gè)數(shù)，將小數(shù)放前，大數(shù)放后。至此第一趟結(jié)束，將最大的數(shù)放到了最后。在第二趟：仍從第一對(duì)數(shù)開始比較（因?yàn)榭赡苡捎诘?個(gè)數(shù)和第3個(gè)數(shù)的交換，使得第1個(gè)數(shù)不再小于第2個(gè)數(shù)），將小數(shù)放前，大數(shù)放后，一直比較到倒數(shù)第二個(gè)數(shù)（倒數(shù)第一的位置上已經(jīng)是最大的），第二趟結(jié)束，在倒數(shù)第二的位置上得到一個(gè)新的最大數(shù)（其實(shí)在整個(gè)數(shù)列中是第二大的數(shù)）。如此下去，重復(fù)以上過程，直至最終完成排序。
具體代碼例一：
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++){
//對(duì)當(dāng)前無序區(qū)間score[0......length-i-1]進(jìn)行排序(j的范圍很關(guān)鍵，這個(gè)范圍是在逐步縮小的)
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) 也是一種簡(jiǎn)單的排序方法，它的基本思想是：第一次從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次,得到一個(gè)按排序碼從小到大排列的有序序列.
具體代碼：
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、請(qǐng)輸入一個(gè)數(shù)字，比如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;//根節(jié)點(diǎn)
BinaryNode left;//左節(jié)點(diǎn)
BinaryNode right;//右節(jié)點(diǎn)
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();
}
}
輸出結(jié)果：
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個(gè)待排序的元素看成一個(gè)有序表和一個(gè)無序表，開始有序表只包含一個(gè)元素，無序表中包含n-1個(gè)元素，排序過程中每次從無序表中取出第一個(gè)元素，把它的排序碼依次與有序表元素的排序碼進(jìn)行比較，將它插入到有序表中的適當(dāng)位置，使之成為新的有序表。
public class InjectionSort //定義一個(gè) InjectionSort 類
public static void injectionSort(int[] number) //傳數(shù)組
for(int j = 1;j<number.length;j++)//循環(huán)
int tmp = number[j]; //循環(huán)把數(shù)組第二個(gè)值放到tmp里
int i = j-1//給i 賦值
while(tmp<number[i]) //tmp值和數(shù)組第一個(gè)值比較誰小
number[i+1] = number[i]; //如果小于就把第一個(gè)值賦值給第二個(gè)
i--;
if(i == -1)//如果i值=-1
break; //退出循環(huán)
number[i+1] = tmp //因?yàn)楸容^數(shù)組里的前一個(gè)比后一個(gè)這樣就換交了實(shí)現(xiàn)了把小的放在前面
這是第一次，因?yàn)檠h(huán)是一個(gè)數(shù)組，后邊的就一次往下循環(huán)，最后就把數(shù)組里的順序從小到大排序了
public static void main(String[] args){
int[] num = {5,46,26,67,2,35};//定義數(shù)組num
injectionSort(num);//調(diào)用方法
for(int i = 0;i<num.length;i++){
System.out.println(num[i]);//顯示排序后的數(shù)組，一行顯示一個(gè)值
簡(jiǎn)單說就是數(shù)組里第二個(gè)和第一個(gè)比誰小，把小的放到第一個(gè)里，大的放到第二個(gè)里，然后第二個(gè)再和第三個(gè)比，小的還是放在前，一直比到這個(gè)數(shù)組結(jié)束，這樣就實(shí)現(xiàn)了從小到大，希望我說的夠詳細(xì)
插入排序代碼while循環(huán)：
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準(zhǔn)備和前一個(gè)數(shù)比較
int index = i - 1;
while (index >= 0 && insertVal < input[index]) {
// 將把input[index]向后移動(dòng)
input[index + 1] = input[index];
// 讓index向前移動(dòng)一位
index--;
}
// 將insertValue插入到適當(dāng)位置
input[index + 1] = insertVal;
//下面這個(gè)循環(huán)是為了打印一下中間的循環(huán)看看是不是插入排序的正確算法
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循環(huán)代碼：
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;
//下面這個(gè)循環(huán)是為了打印一下中間的循環(huán)看看是不是插入排序的正確算法
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;
}
}
二分查找又稱折半查找，它是一種效率較高的查找方法。
折半查找的算法思想是將數(shù)列按有序化(遞增或遞減)排列，查找過程中采用跳躍式方式查找，即先以有序數(shù)列的中點(diǎn)位置為比較對(duì)象，如果要找的元素值小于該中點(diǎn)元素，則將待查序列縮小為左半部分，否則為右半部分。通過一次比較，將查找區(qū)間縮小一半。 折半查找是一種高效的查找方法。它可以明顯減少比較次數(shù)，提高查找效率。但是，折半查找的先決條件是查找表中的數(shù)據(jù)元素必須有序。
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);
}
//循環(huán)實(shí)現(xiàn)
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;
}
//遞歸實(shí)現(xiàn)
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;
}
}