BlogJava-willpower88-随笔分类-数据结构&算法

[转]多种负载均衡算法及其Java代码实现

一凡 — Fri, 10 Feb 2017 10:57:00 GMT

http://www.iteye.com/news/32119

一凡 2017-02-10 18:57 发表评论

二叉树递归操作

一凡 — Mon, 09 Apr 2012 09:19:00 GMT

本文实现二叉树的递归创建、遍历及深度计算。即输入:abd##e##cf###（按二叉树结构输入）

二叉树：

返回结果如下：

完整代码如下：

#include <stdio.h>
//树结构
typedef struct tree {
     char data;
    struct tree *lchild, *rchild;
} tree;

//创建树
struct tree* create_tree() {
     char node_data;
    scanf("%c", &node_data);
    if(node_data == '#') {
        return NULL;
    } else {
        struct tree *T = NULL;
        T = (struct tree*)malloc(sizeof(struct tree));
        T->data = node_data;
        T->lchild = create_tree();
        T->rchild = create_tree();
        return T;
    }
}

//先序遍历
void pre_traverse(struct tree *T) {
     if(T == NULL) {
        return;
    } else {
        printf("%c\t", T->data);
        pre_traverse(T->lchild);
        pre_traverse(T->rchild);
    }
}
//中序遍历
void mid_traverse(struct tree *T) {
     if(T == NULL) {
        return;
    } else {
        mid_traverse(T->lchild);
        printf("%c\t", T->data);
        mid_traverse(T->rchild);

    }
}
//后序遍历
void aft_traverse(struct tree *T) {
     if(T == NULL) {
        return;
    } else {
        aft_traverse(T->lchild);
        aft_traverse(T->rchild);
        printf("%c\t", T->data);
    }
}
//深度
int tree_deepth(struct tree *T) {
    int i,j;
    if(!T) {
        return 0;
    } else {
        if(T->lchild)
            i = tree_deepth(T->lchild);
        else
            i = 0;

        if(T->rchild)
            j = tree_deepth(T->rchild);
        else
            j = 0;
    return i > j ? (i + 1) : (j + 1);
    }
}

int main(int argc, char **argv) {
     struct tree *T = create_tree();
    if(T) {
        printf("%s\n", "先序:");
        pre_traverse(T);
        printf("\n%s\n", "中序:");
        mid_traverse(T);
        printf("\n%s\n", "后序:");
        aft_traverse(T);
        printf("\n%s\n", "深度:");
        int deepth = tree_deepth(T);
        printf("%d\n", deepth);
        printf("\n");
    }
     return 0;
}

一凡 2012-04-09 17:19 发表评论

权重算法实现

一凡 — Tue, 31 Aug 2010 09:08:00 GMT

需求：广告按权重展现

基本算法描述如下:
1、每个广告增加权重
2、将所有匹配广告的权重相加sum，
3、以相加结果为随机数的种子，生成1~sum之间的随机数rd
4、.接着遍历所有广告，访问顺序可以随意.将当前节点的权重值加上前面访问的各节点权重值得curWt,判断curWt >= rd,如果条件成立则返回当前节点,如果不是则继续累加下一节点. 直到符合上面的条件,由于rd<=sum 因此一定存在curWt>=rd。
特别说明：
此算法和广告的顺序无关

测试代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class Test {

    /**
     * @param args
     */
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        List<Node> arrNodes = new ArrayList<Node>();
        Node n = new Node(10, "测试1");
        arrNodes.add(n);
        n = new Node(20, "测试2");
        arrNodes.add(n);
        n = new Node(30, "测试3");
        arrNodes.add(n);
        n = new Node(40, "测试4");
        arrNodes.add(n);

        //Collections.sort(arrNodes, new Node());
        Map<String, Integer> showMap = null;
        int sum = getSum(arrNodes);
        int random = 0;
        Node kw = null;
        for(int k = 0; k < 20; k++) {
            showMap = new LinkedHashMap<String, Integer>();
            for(int i = 0; i < 100; i++) {
                random = getRandom(sum);
                kw = getKW(arrNodes, random);
                if(showMap.containsKey(kw.kw)) {
                    showMap.put(kw.kw, showMap.get(kw.kw) + 1);
                } else {
                    showMap.put(kw.kw, 1);
                }
                //System.out.println(i + " " +random + " " + getKW(arrNodes, random));
            }
            System.out.print(k + " ");
            System.out.println(showMap);
        }
    }

    public static Node getKW(List<Node> nodes, int rd) {
        Node ret = null;
        int curWt = 0;
        for(Node n : nodes){
            curWt += n.weight;
            if(curWt >= rd) {
                ret = n;
                break;
            }
        }
        return ret;
    }
    public static int getSum(List<Node> nodes) {
        int sum = 0;
        for(Node n : nodes)
            sum += n.weight;
        return sum;
    }
    public static int getRandom(int seed) {
        return (int)Math.round(Math.random() * seed);
    }
}
class Node implements Comparator{
    int weight = 0;
    String kw = "";

    public Node() {}

    public Node(int wt, String kw) {
        this.weight = wt;
        this.kw = kw;
    }
    public String toString(){
        StringBuilder sbBuilder = new StringBuilder();
        sbBuilder.append(" weight=").append(weight);
        sbBuilder.append(" kw").append(kw);
        return sbBuilder.toString();
    }
    public int compare(Object o1, Object o2) {
        Node n1 = (Node)o1;
        Node n2 = (Node)o2;
        if(n1.weight > n2.weight)
            return 1;
        else
            return 0;
    }
}

一凡 2010-08-31 17:08 发表评论