简单的算法动手写备忘

package me.knowledge;

/**

* Created by zhongxiankui on 16-4-9.

*/

public class BubbleSortTest {

public static void bubbleSort(int[] array){
int size = array.length;
for(int i = size; i > 0; i--) {
for (int j = 0; j < i - 1; j++) {
if (array[j] > array[j + 1]) {
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
}
}
}
}

public static void printArray(int[] array){
for (int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println();
}

public static void main(String[] args){
int[] array = new int[]{9,3,3,1,0,3,7,15,1,2};
printArray(array);
bubbleSort(array);
printArray(array);
}

}

package me.knowledge;

/**

* Created by zhongxiankui on 16-4-9.

*/

public class ChoseSortTest {

public static void choseSort(int[] array){
int size = array.length;
for(int i = 0; i < size; i++){
int minIndex = i;
int min = array[minIndex];
for(int j = i+1; j < size; j++){
if(array[j] < min){
minIndex = j;
min = array[j];
}
}

if(i != minIndex){
int tmp = array[i];
array[i] = array[minIndex];
array[minIndex] = tmp;
}
}
}

public static void printArray(int[] array){
for (int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println();
}

public static void main(String[] args){
int[] array = new int[]{9,3,3,1,0,3,7,15,1,2};
printArray(array);
choseSort(array);
printArray(array);
}

}

package me.knowledge;

/**

* Created by zhongxiankui on 16-4-7.

*/

public class InsertSortTest {

public static void insertSort(int[] array){
int size = array.length;
for(int i = 1; i < size; i++){

//good method
int tmp = array[i];
int j = i;
while(--j >= 0 && array[j] > tmp){
array[j+1] = array[j];
}
array[j+1] = tmp;

/*
//bad method
for(int j = 0; j < i; j++){
if(array[j] > array[i]){
int tmp = array[i];
for (int k = i; k > j; k--){
array[k] = array[k-1];
}
array[j] = tmp;
break;
}
}
*/
}
}

public static void printArray(int[] array){
for (int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println();
}

public static void main(String[] args){
int[] array = new int[]{9,3,3,1,0,3,7,15,1,2};
printArray(array);
insertSort(array);
printArray(array);
}

}

package me.knowledge;

/**

* Created by zhongxiankui on 16-4-9.

*/

public class MergeSortTest {

public static void mergeSort(int[] arrayA, int[] arrayB, int[] arrayC){
int sizeA = arrayA.length;
int sizeB = arrayB.length;

int i = 0;
int j = 0;
int k = 0;

while (i < sizeA && j < sizeB){
if(arrayA[i] <= arrayB[j]){
arrayC[k++] = arrayA[i++];
}else {
arrayC[k++] = arrayB[j++];
}
}

if(j == sizeB){
while (i < sizeA){
arrayC[k++]=arrayA[i++];
}
}

if(i == sizeA){
while (j < sizeB){
arrayC[k++]=arrayB[j++];
}
}
}

public static void printArray(int[] array){
for (int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println();
}

public static void main(String[] args){
int[] arrayA = new int[]{1,3,9,15,21,29,35};
int[] arrayB = new int[]{2,6,10};
int[] arrayC = new int[arrayA.length + arrayB.length];
printArray(arrayA);
printArray(arrayB);
mergeSort(arrayA, arrayB, arrayC);
printArray(arrayC);
}

}

package me.knowledge;

/**

* Created by zhongxiankui on 16-4-9.

*/

public class QuickSortTest {

public static void quickSort(int[] array, int start, int end){

if(start >= end){
return;
}

int left = start;
int right = end;
int flagIndex = start;
int flag = array[flagIndex];

while(left < right){
while(flag < array[right] && left < right){
right--;
}

if(left < right){
flagIndex=right;
array[left] = array[right];
left++;
}

while(flag > array[left] && left < right){
left++;
}

if(left < right){
flagIndex=left;
array[right] = array[left];
right--;
}
}

array[flagIndex] = flag;
printArray(array);
quickSort(array, start, flagIndex-1);
quickSort(array,flagIndex+1, end);
/*
if(start < flagIndex -1){
quickSort(array, start, flagIndex-1);
}

if(flagIndex+1 < end){
quickSort(array,flagIndex+1, end);
}
*/
}

public static void printArray(int[] array){
for (int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println();
}

public static void main(String[] args){
int[] array = new int[]{9,3,3,1,0,3,7,15,1,2};
printArray(array);
quickSort(array, 0, array.length-1);
printArray(array);
}

}

package me.knowledge;

/**

* Created by zhongxiankui on 16-4-7.

*/

public class BinaryTreeTest {

private static class Node{

public Node(int value){
this.value = value;
this.father = null;
this.left = null;
this.right = null;
}

public Node father;
public Node left;
public Node right;
public int value;
}

public static Node scanTree(Node node){
if(null == node){
return null;
}

while (null != node.left){
if(null == scanTree(node.left)){
break;
}
}

if(null == node.left){
System.out.println("get enode:" + node.value);
}

if(null != node.father && node.father.right != node){
System.out.println("get fnode:" + node.father.value);
scanTree(node.father.right);
}

return null;
}

public static void test1(){
Node node1 =  new Node(1);
Node node2 = new Node(3);
node1.left = node2;
node2.father = node1;

Node node3 = new Node(5);
node1.right = node3;
node3.father = node1;

Node node4 = new Node(7);
node2.left = node4;
node4.father = node2;

Node node5 = new Node(2);
node2.right = node5;
node5.father = node2;

Node node6 = new Node(10);
node3.left = node6;
node6.father = node3;

Node node7 = new Node(20);
node4.left = node7;
node7.father = node4;
scanTree(node1);
}

public static void main(String[] args){
test1();
}

}

package me.base.knowledge.algorithmic;

/**

* @author : zhongxiankui

* @time : 2016-04,12 10:11:上午10:11

* @project

*/

public class HeapSortTest {

public static void heapSort(int[] array, int index, int num){

int i = index * 2 + 1;
int tmp = array[index];

while(i < num){
if(i + 1 < num && array[i + 1] < array[i]){
i++;
}

if(array[i] > array[index]){
break;
}

array[index] = array[i];
array[i] = tmp;
index = i;
i = index * 2 + 1;
}
}

public static void printArray(int[] array){
for (int i = 0; i < array.length; i++){
System.out.print(array[i] + ",");
}
System.out.println();
}

public static void main(String[] args){
int n = 7;
int[] array = {4,9,1,0,14,41,3};
printArray(array);
for(int i = n /2; i >=0 ; i--){
heapSort(array,i, n);
}
printArray(array);
}

}

package me.base.knowledge.algorithmic;

/**

* @author : zhongxiankui

* @time : 2016-04,14 10:18:上午10:18

*/

public class BinarySearchTest {

public static int binarySearch(int[] array, int start, int end, int value){

if(start >= end){
if(array[start] == value){
return value;
}else if(value > array[start]){
return -(start + 1);
}else {
if(start == 0){
return 0;
}else if(0 == start - 1){
return -1;
}else {
return -(start - 1);
}
}
}

int mid = (start + end) / 2;
if(value == array[mid]) {
return value;
}else if (value < array[mid]){
return binarySearch(array, start , mid - 1, value);
}else {
return binarySearch(array, mid + 1, end, value);
}
}

public static void main(String[] args){
int[] array = {1,3,5,7,9,11};

int findValue = binarySearch(array, 0, array.length - 1, 2);
System.out.println(findValue);
}

}