冒泡排序：
利用冒泡排序对数组进行排序
二、基本概念：
依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
举例说明：要排序数组：int[] arr={6,3,8,2,9,1};
第一趟排序：
第一次排序：6和3比较，6大于3，交换位置： 3 6 8 2 9 1
第二次排序：6和8比较，6小于8，不交换位置：3 6 8 2 9 1
第三次排序：8和2比较，8大于2，交换位置： 3 6 2 8 9 1
第四次排序：8和9比较，8小于9，不交换位置：3 6 2 8 9 1
第五次排序：9和1比较：9大于1，交换位置： 3 6 2 8 1 9
第一趟总共进行了5次比较， 排序结果： 3 6 2 8 1 9
---------------------------------------------------------------------
第二趟排序：
第一次排序：3和6比较，3小于6，不交换位置：3 6 2 8 1 9
第二次排序：6和2比较，6大于2，交换位置： 3 2 6 8 1 9
第三次排序：6和8比较，6大于8，不交换位置：3 2 6 8 1 9
第四次排序：8和1比较，8大于1，交换位置： 3 2 6 1 8 9
第二趟总共进行了4次比较， 排序结果： 3 2 6 1 8 9
---------------------------------------------------------------------
第三趟排序：
第一次排序：3和2比较，3大于2，交换位置： 2 3 6 1 8 9
第二次排序：3和6比较，3小于6，不交换位置：2 3 6 1 8 9
第三次排序：6和1比较，6大于1，交换位置： 2 3 1 6 8 9
第二趟总共进行了3次比较， 排序结果： 2 3 1 6 8 9
---------------------------------------------------------------------
第四趟排序：
第一次排序：2和3比较，2小于3，不交换位置：2 3 1 6 8 9
第二次排序：3和1比较，3大于1，交换位置： 2 1 3 6 8 9
第二趟总共进行了2次比较， 排序结果： 2 1 3 6 8 9
---------------------------------------------------------------------
第五趟排序：
第一次排序：2和1比较，2大于1，交换位置： 1 2 3 6 8 9
第二趟总共进行了1次比较， 排序结果： 1 2 3 6 8 9
---------------------------------------------------------------------
最终结果：1 2 3 6 8 9
---------------------------------------------------------------------
由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数，即
/* * 冒泡排序 */public class BubbleSort { public static void main(String[] args) { int[] arr={6,3,8,2,9,1}; System.out.println("排序前数组为："); for(int num:arr){ System.out.print(num+" "); } for(int i=0;i arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } System.out.println(); System.out.println("排序后的数组为："); for(int num:arr){ System.out.print(num+" "); } } } 冒泡排序的六种写法 public class javaData1 {
// public static void swap(Long a,Long b){
// long tmp;// tmp=a;// a=b;// b=tmp;// } public static void show(long []arr){ System.out.print("arr=["); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } System.out.print("]"); System.out.println(); } /** * * 冒泡排序的第一种写法 * */ public static void BubbleSort(long []arr){for (int i = 0; i < arr.length; i++) {
for (int j = 1; j < arr.length-i; j++) {if (arr[j-1]>arr[j]) {
//swap(arr[j-1], arr[j]); //Swap swap=new Swap(arr[j-1], arr[j]); //Swap.swap(arr[j-1], arr[j]); arr[j-1]=arr[j-1]^arr[j]; arr[j]=arr[j-1]^arr[j]; arr[j-1]=arr[j-1]^arr[j];//swap.swap(arr[j-1], arr[j]);
}
} }}
/**
* * 冒泡排序的第二种写法 * */ public static void BubbleSort1(long []arr){for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length-i-1; j++) { if (arr[j]>arr[j+1]) { arr[j]=arr[j]^arr[j+1]; arr[j+1]=arr[j]^arr[j+1]; arr[j]=arr[j]^arr[j+1]; } } }}
/** * * 冒泡排序的第三种写法 * */public static void BubbleSort2(long[]arr){
for (int i = 0; i < arr.length-1; i++) {
for (int j = arr.length-1; j >0; j--) { if (arr[j-1]>arr[j]) { arr[j-1]=arr[j-1]^arr[j]; arr[j]=arr[j-1]^arr[j]; arr[j-1]=arr[j-1]^arr[j]; } } }}
/**
* 冒泡排序的第四种写法 * */ public static void BubbleSort4(int []arr){ boolean flag=true; do{ flag=false; for (int j = arr.length-1; j >=1; j--) { if (arr[j-1]>arr[j]) { arr[j-1]=arr[j-1]^arr[j]; arr[j]=arr[j-1]^arr[j]; arr[j-1]=arr[j-1]^arr[j]; flag=true; } } }while(flag);}
/**
* * 冒泡排序的第五种写法 * * 这种写法的思想是： 第一个元素和后面的所有元素比较， * 内层循环一轮结束，就可以将最大的数放到最后；接下来 * 是执行第二次内层的循环，将已经排序之后的数组（已经排列 * 好最大的数字）的第二大的数字放到倒数第二位； * 接下来是依次将大数放到后面。 * */ public static void BubbleSort4(long[]arr){for (int i = 0; i < arr.length; i++) {
for (int j = i+1; j < arr.length; j++) { if (arr[i]>arr[j]) { arr[i]=arr[i]^arr[j]; arr[j]=arr[i]^arr[j]; arr[i]=arr[i]^arr[j]; } } }}
/**
* * 冒泡排序的第六种写法 * 这种写法的思想是：从数组的最后一个元素进行和之前所有的元素 * 进行比较，只一次内层的循环，将最小的数字放到第一位；接下来 * 是执行第二次的内层循环，将第二小的的放到第二位，依次将数组 * 从小到大排列。 * */public static void BubbleSort5(long[]arr){
for (int i = 0; i < arr.length; i++) { for (int j = arr.length-1; j >i; j--) { if (arr[i]>arr[j]) { arr[i]=arr[i]^arr[j]; arr[j]=arr[i]^arr[j]; arr[i]=arr[i]^arr[j]; } } }}
/**
* @param args */ public static void main(String[] args) { // TODO Auto-generated method stublong[] arr = { 0, 5, 4, 333, 91, 9,8,7,6,3,2,1-99999, 67, 78, 87, 66, 41, -11119 };
show(arr); BubbleSort5(arr); // BubbleSort(arr); // SelectSort1(arr); //InsertSort(arr); // ShellSort(arr); //QuickSort(arr,0,arr.Length-1); show(arr);}
}
class Swap{ long a; long b; public Swap(long a, long b) { super(); this.a = a; this.b = b; } public static void swap(long a,long b){// long tmp=a;
// a=b;// b=tmp;a=a^b;
b=a^b; a=a^b; }}
算法优化：
冒泡排序法存在的不足及改进方法：
第一，在排序过程中，执行完最后的排序后，虽然数据已全部排序完备，但程序无法判断是否完成排序，为了解决这一不足，可设置一个标志位flag，将其初始值设置为非0，表示被排序的表是一个无序的表，每一次排序开始前设置flag值为0，在进行数据交换时，修改flag为非0。在新一轮排序开始时，检查此标志，若此标志为0，表示上一次没有做过交换数据，则结束排序；否则进行排序；mport java.util.Arrays;/** * 冒泡排序改进版 * @author mmz * */public class BubbleSort1 { public static void BubbleSort(int[] arr) { boolean flag = true; while(flag){ int temp;//定义一个临时变量 for(int i=0;i 
把整个序列看做一个数组，把第零个位置看做中轴，和最后一个比，如果比它小交换，比它大不做任何处理；交换了以后再和小的那端比，比它小不交换，比他大交换。这样循环往复，一趟排序完成，左边就是比中轴小的，右边就是比中轴大的，然后再用分治法，分别对这两个独立的数组进行排序。
public int getMiddle(Integer[] list, int low, int high) { int tmp = list[low]; //数组的第一个作为中轴 while (low < high) { while (low < high && list[high] > tmp) { high--; } list[low] = list[high]; //比中轴小的记录移到低端 while (low < high && list[low] < tmp) { low++; } list[high] = list[low]; //比中轴大的记录移到高端 } list[low] = tmp; //中轴记录到尾 return low; //返回中轴的位置 } 递归形式的分治排序算法： public void _quickSort(Integer[] list, int low, int high) { if (low < high) { int middle = getMiddle(list, low, high); //将list数组进行一分为二 _quickSort(list, low, middle - 1); //对低字表进行递归排序 _quickSort(list, middle + 1, high); //对高字表进行递归排序 } } 测试打印结果 public class TestMain { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Integer[] list={34,3,53,2,23,7,14,10}; QuicSort qs=new QuicSort(); qs.quick(list); for(int i=0;i 二叉树是一种非常重要的，非常多其他数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们寻常所说的层次遍历。由于树的定义本身就是递归定义，因此採用递归的方法去实现树的三种遍历不仅easy理解并且代码非常简洁，而对于广度遍历来说，须要其他数据结构的支撑。比方堆了。所以。对于一段代码来说，可读性有时候要比代码本身的效率要重要的多。
四种基本的遍历思想为：
前序遍历：根结点 ---> 左子树 ---> 右子树
中序遍历：左子树---> 根结点 ---> 右子树
后序遍历：左子树 ---> 右子树 ---> 根结点
层次遍历：仅仅需按层次遍历就可以
比如。求以下二叉树的各种遍历
前序遍历：1 2 4 5 7 8 3 6
中序遍历：4 2 7 5 8 1 3 6
后序遍历：4 7 8 5 2 6 3 1
层次遍历：1 2 3 4 5 6 7 8
一致性哈希
一致性hash算法是分布式中一个常用且好用的分片算法、或者数据库分库分表算法。现在的互联网服务架构中，为避免单点故障、提升处理效率、横向扩展等原因，分布式系统已经成为了居家旅行必备的部署模式，所以也产出了几种数据分片的方法：
1.取模，2.划段，3.一致性hash 前两种有很大的一个问题就是需要固定的节点数，即节点数不能变，不能某一个节点挂了或者实时增加一个节点，变了分片规则就需要改变，需要迁移的数据也多。 那么一致性hash是怎么解决这个问题的呢？ 一致性hash：对节点和数据，都做一次hash运算，然后比较节点和数据的hash值，数据值和节点最相近的节点作为处理节点。为了分布得更均匀，通过使用虚拟节点的方式，每个节点计算出n个hash值，均匀地放在hash环上这样数据就能比较均匀地分布到每个节点。 1、原理 (1)环形Hash空间 按照常用的hash算法来将对应的key哈希到一个具有2^32次方个桶的空间中，即0~(2^32)-1的数字空间中。 现在我们可以将这些数字头尾相连，想象成一个闭合的环形。如下图 (2)把数据通过一定的hash算法处理后映射到环上 现在我们将object1、object2、object3、object4四个对象通过特定的Hash函数计算出对应的key值，然后散列到Hash环上。如下图： Hash(object1) = key1； Hash(object2) = key2； Hash(object3) = key3； Hash(object4) = key4； (3)将机器通过hash算法映射到环上 在采用一致性哈希算法的分布式集群中将新的机器加入，其原理是通过使用与对象存储一样的Hash算法将机器也映射到环中 （一般情况下对机器的hash计算是采用机器的IP或者机器唯一的别名作为输入值），然后以顺时针的方向计算，将所有对象存储到离自己最近的机器中。 假设现在有NODE1，NODE2，NODE3三台机器，通过Hash算法得到对应的KEY值，映射到环中，其示意图如下： Hash(NODE1) = KEY1; Hash(NODE2) = KEY2; Hash(NODE3) = KEY3; 通过上图可以看出对象与机器处于同一哈希空间中，这样按顺时针转动object1存储到了NODE1中，object3存储到了NODE2中，object2、object4存储到了NODE3中。 在这样的部署环境中，hash环是不会变更的，因此，通过算出对象的hash值就能快速的定位到对应的机器中，这样就能找到对象真正的存储位置了。 2、机器的删除与添加 普通hash求余算法最为不妥的地方就是在有机器的添加或者删除之后会造成大量的对象存储位置失效。下面来分析一下一致性哈希算法是如何处理的。 (1)节点（机器）的删除 以上面的分布为例，如果NODE2出现故障被删除了，那么按照顺时针迁移的方法，object3将会被迁移到NODE3中，这样仅仅是object3的映射位置发生了变化，其它的对象没有任何的改动。如下图： (2)节点（机器）的添加 如果往集群中添加一个新的节点NODE4，通过对应的哈希算法得到KEY4，并映射到环中，如下图： 通过按顺时针迁移的规则，那么object2被迁移到了NODE4中，其它对象还保持着原有的存储位置。 通过对节点的添加和删除的分析，一致性哈希算法在保持了单调性的同时，还是数据的迁移达到了最小，这样的算法对分布式集群来说是非常合适的，避免了大量数据迁移，减小了服务器的的压力。 3、平衡性–虚拟节点 根据上面的图解分析，一致性哈希算法满足了单调性和负载均衡的特性以及一般hash算法的分散性，但这还并不能当做其被广泛应用的原由， 因为还缺少了平衡性。下面将分析一致性哈希算法是如何满足平衡性的。 hash算法是不保证平衡的，如上面只部署了NODE1和NODE3的情况（NODE2被删除的图），object1存储到了NODE1中，而object2、object3、object4都存储到了NODE3中，这样就造成了非常不平衡的状态。在一致性哈希算法中，为了尽可能的满足平衡性，其引入了虚拟节点。 ——“虚拟节点”（ virtual node ）是实际节点（机器）在 hash 空间的复制品（ replica ），一个实际节点（机器）对应了若干个“虚拟节点”，这个对应个数也成为“复制个数”，“虚拟节点”在 hash 空间中以hash值排列。 以上面只部署了NODE1和NODE3的情况（NODE2被删除的图）为例，之前的对象在机器上的分布很不均衡，现在我们以2个副本（复制个数）为例，这样整个hash环中就存在了4个虚拟节点，最后对象映射的关系图如下： 根据上图可知对象的映射关系：object1->NODE1-1，object2->NODE1-2，object3->NODE3-2，object4->NODE3-1。通过虚拟节点的引入，对象的分布就比较均衡了。那么在实际操作中，正真的对象查询是如何工作的呢？对象从hash到虚拟节点到实际节点的转换如下图： “虚拟节点”的hash计算可以采用对应节点的IP地址加数字后缀的方式。例如假设NODE1的IP地址为192.168.1.100。引入“虚拟节点”前，计算 cache A 的 hash 值： Hash(“192.168.1.100”); 引入“虚拟节点”后，计算“虚拟节”点NODE1-1和NODE1-2的hash值： Hash(“192.168.1.100#1”); // NODE1-1 Hash(“192.168.1.100#2”); // NODE1-2二、一致性hash算法的Java实现。
1、不带虚拟节点的package hash;
import java.util.SortedMap;
import java.util.TreeMap;/**
* 不带虚拟节点的一致性Hash算法 * 重点：1.如何造一个hash环，2.如何在哈希环上映射服务器节点，3.如何找到对应的节点 */ public class ConsistentHashingWithoutVirtualNode {//待添加入Hash环的服务器列表
private static String[] servers = { "192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111", "192.168.0.3:111", "192.168.0.4:111" };//key表示服务器的hash值，value表示服务器
private static SortedMap<Integer, String> sortedMap = new TreeMap<Integer, String>();//程序初始化，将所有的服务器放入sortedMap中
static { for (int i=0; i<servers.length; i++) { int hash = getHash(servers[i]); System.out.println("[" + servers[i] + "]加入集合中, 其Hash值为" + hash); sortedMap.put(hash, servers[i]); } System.out.println(); }//得到应当路由到的结点
private static String getServer(String key) { //得到该key的hash值 int hash = getHash(key); //得到大于该Hash值的所有Map SortedMap<Integer, String> subMap = sortedMap.tailMap(hash); if(subMap.isEmpty()){ //如果没有比该key的hash值大的，则从第一个node开始 Integer i = sortedMap.firstKey(); //返回对应的服务器 return sortedMap.get(i); }else{ //第一个Key就是顺时针过去离node最近的那个结点 Integer i = subMap.firstKey(); //返回对应的服务器 return subMap.get(i); } }//使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别
private static int getHash(String str) { final int p = 16777619; int hash = (int) 2166136261L; for (int i = 0; i < str.length(); i++) hash = (hash ^ str.charAt(i)) * p; hash += hash << 13; hash ^= hash >> 7; hash += hash << 3; hash ^= hash >> 17; hash += hash << 5;// 如果算出来的值为负数则取其绝对值
if (hash < 0) hash = Math.abs(hash); return hash; }public static void main(String[] args) {
String[] keys = {"太阳", "月亮", "星星"}; for(int i=0; i<keys.length; i++) System.out.println("[" + keys[i] + "]的hash值为" + getHash(keys[i]) + ", 被路由到结点[" + getServer(keys[i]) + "]"); } } 执行结果：[192.168.0.0:111]加入集合中, 其Hash值为575774686
[192.168.0.1:111]加入集合中, 其Hash值为8518713[192.168.0.2:111]加入集合中, 其Hash值为1361847097[192.168.0.3:111]加入集合中, 其Hash值为1171828661[192.168.0.4:111]加入集合中, 其Hash值为1764547046[太阳]的hash值为1977106057, 被路由到结点[192.168.0.1:111]
[月亮]的hash值为1132637661, 被路由到结点[192.168.0.3:111][星星]的hash值为880019273, 被路由到结点[192.168.0.3:111]2、带虚拟节点的package hash;
import java.util.LinkedList;
import java.util.List; import java.util.SortedMap; import java.util.TreeMap;import org.apache.commons.lang.StringUtils;
/**
* 带虚拟节点的一致性Hash算法 */ public class ConsistentHashingWithoutVirtualNode {//待添加入Hash环的服务器列表
private static String[] servers = {"192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111", "192.168.0.3:111", "192.168.0.4:111"};//真实结点列表,考虑到服务器上线、下线的场景，即添加、删除的场景会比较频繁，这里使用LinkedList会更好
private static List<String> realNodes = new LinkedList<String>();//虚拟节点，key表示虚拟节点的hash值，value表示虚拟节点的名称
private static SortedMap<Integer, String> virtualNodes = new TreeMap<Integer, String>();//虚拟节点的数目，这里写死，为了演示需要，一个真实结点对应5个虚拟节点
private static final int VIRTUAL_NODES = 5;static{
//先把原始的服务器添加到真实结点列表中 for(int i=0; i<servers.length; i++) realNodes.add(servers[i]);//再添加虚拟节点，遍历LinkedList使用foreach循环效率会比较高
for (String str : realNodes){ for(int i=0; i<VIRTUAL_NODES; i++){ String virtualNodeName = str + "&&VN" + String.valueOf(i); int hash = getHash(virtualNodeName); System.out.println("虚拟节点[" + virtualNodeName + "]被添加, hash值为" + hash); virtualNodes.put(hash, virtualNodeName); } } System.out.println(); }//使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别
private static int getHash(String str){ final int p = 16777619; int hash = (int)2166136261L; for (int i = 0; i < str.length(); i++) hash = (hash ^ str.charAt(i)) * p; hash += hash << 13; hash ^= hash >> 7; hash += hash << 3; hash ^= hash >> 17; hash += hash << 5;// 如果算出来的值为负数则取其绝对值
if (hash < 0) hash = Math.abs(hash); return hash; }//得到应当路由到的结点
private static String getServer(String key){ //得到该key的hash值 int hash = getHash(key); // 得到大于该Hash值的所有Map SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash); String virtualNode; if(subMap.isEmpty()){ //如果没有比该key的hash值大的，则从第一个node开始 Integer i = virtualNodes.firstKey(); //返回对应的服务器 virtualNode = virtualNodes.get(i); }else{ //第一个Key就是顺时针过去离node最近的那个结点 Integer i = subMap.firstKey(); //返回对应的服务器 virtualNode = subMap.get(i); } //virtualNode虚拟节点名称要截取一下 if(StringUtils.isNotBlank(virtualNode)){ return virtualNode.substring(0, virtualNode.indexOf("&&")); } return null; }public static void main(String[] args){
String[] keys = {"太阳", "月亮", "星星"}; for(int i=0; i<keys.length; i++) System.out.println("[" + keys[i] + "]的hash值为" + getHash(keys[i]) + ", 被路由到结点[" + getServer(keys[i]) + "]"); } }执行结果：虚拟节点[192.168.0.0:111&&VN0]被添加, hash值为1686427075
虚拟节点[192.168.0.0:111&&VN1]被添加, hash值为354859081虚拟节点[192.168.0.0:111&&VN2]被添加, hash值为1306497370虚拟节点[192.168.0.0:111&&VN3]被添加, hash值为817889914虚拟节点[192.168.0.0:111&&VN4]被添加, hash值为396663629...虚拟节点[192.168.0.4:111&&VN0]被添加, hash值为586921010虚拟节点[192.168.0.4:111&&VN1]被添加, hash值为184078390虚拟节点[192.168.0.4:111&&VN2]被添加, hash值为1331645117虚拟节点[192.168.0.4:111&&VN3]被添加, hash值为918790803虚拟节点[192.168.0.4:111&&VN4]被添加, hash值为1232193678[太阳]的hash值为1977106057, 被路由到结点[192.168.0.2:111]
[月亮]的hash值为1132637661, 被路由到结点[192.168.0.4:111][星星]的hash值为880019273, 被路由到结点[192.168.0.3:111]