Localhost8080

dijkstra算法裸实现+heap优化

Dijkstra算法简述

　　Dijkstra算法是图论中的一种求单源最短路的算法，即从一个点开始到所有其他点的最短路。其基本原理是：集合T包含所有当前已经找到最短路径的点，初始情况下T中只有源点。U维护当前源点通过T中各点到达其他各点的距离。从源点开始，每次新扩展一个属于U、距离T中点最短的点，用该点更新U中的与其相邻的点的距离。当所有边权都为正时，由于不会存在一个距离更短的没扩展过的点，所以这个点的距离永远不会再被改变，因而保证了算法的正确性。不过根据这个原理，用Dijkstra求最短路的图不能有负权边，因为扩展到负权边的时候会产生更短的距离，有可能就破坏了已经更新的点距离不会改变的性质。

Dijkstra算法流程

　　在以下说明中，start为源，Adj[u,v]为点u和v之间的边的长度，结果保存在Closest[]

初始化：源的距离Closest[start]设为0，其他的点距离设为无穷大，同时把所有的点的状态设为没有扩展过。
以下过程循环n-1次：
在没有扩展过的点中取一距离最小的点u，并将其状态设为已扩展。
对于每个与u相邻的点v，如果Closest[u]+Adj[u,v] < Closest[v]，那么把Closest[v]更新成更短的距离Closest[u]+Adj[u,v]。此时到点v的最短路径上，前一个节点即为u。
结束。此时对于任意的u，Closest[u]就是start到u的距离。

//呵呵，有点简陋，但是思想还是正确地

#include <iostream>
using namespace std;
const int max_vertexes = 3;
const int infinity = 10001;
int graph[max_vertexes][max_vertexes]={
    0,1,5,
    infinity,0,2,
    infinity,infinity,infinity
};
//typedef **int Graph;
int path[max_vertexes];
int n,s,t;
int Dijkstra(int G[max_vertexes][max_vertexes],int n,int s,int t, int path[])
{
    int i,j,w,minc,d[max_vertexes],flag[max_vertexes];
    memset(flag,0,sizeof(flag));
    for (i=0;i<n;i++)
    {
        d[i]=G[s][i];
        path[i]=s;//都从S直接到达的
    }
    flag[s]=1;
    path[s]=0;//s点为第一步
    d[s]=0;
    for (i=1;i<n;i++)
    {
        minc=infinity;
        w=0;
        for(j=0;j<n;j++)//找出一个到S距离最短的未添加的节点
            if ((flag[j]==0)&&(minc>=d[j]))
            {
                minc=d[j];
                w=j;
            }
            flag[w]=1;
            for (j=0;j<n;j++)//更新路径
                if((flag[j]==0)&&(G[w][j]!=infinity)&&(d[j]>d[w]+G[w][j]))
                {
                    d[j]=d[w]+G[w][j];
                    path[j]=w;
                }
    }
    return d[t];
}

int main(void)
{
    int s,t;
    while(cin>>s>>t)
    {
        int result = Dijkstra(graph,max_vertexes,s,t,path);
        cout<<result<<endl;
    }
    return 0;
}

堆优化版：
描述:

回忆经典dijkstra算法
每次在没标记的节点中找离源点最近的,此步骤可以用HEAP维护,每次取根(最小值),然后删除根,在其左右儿子中选更小的作为堆的根,但此时选中的子树有无根了,递归处理.
找到最近点后,要更新各点离源点的距离,若能更新,则该点的值变小了,可能比其父亲更小,与其比较,更小就交换,不断往上比较,直到是整个堆的根或不比父亲小.

heap里存顶点（按dist的顺序）

repeat

relax从heap[1]发出的每一条边，当然，一边relax一边fixup，

delete(heap[1])，fixdown

until empty(heap);

复杂度分析:

众所周知没有经过优化的dijkstra算法的复杂度为O(V^2)

算法使用了堆，每次以最小代价加入顶点，即deletemin操作(O(logn))
然后根据该点调整其他顶点到当前树的距离，主要用到decreasekey操作(logn)
因为decrease最多m次，所以decrease花掉 O(mlogn)的时间，deletemin执行n次，它花掉O(nlogn)时间，一共O((m+n)logn)时间。而其初始化部分的复杂度不超过这个值，所以算法总复杂度O((m+n)logn)(当然这个复杂度只适用于邻接表表示的稀疏图)

#include <iostream>
#include <vector>
using namespace std;
const unsigned int NoEdge=0xfffffff;
struct vertex{
    int n;
    int weight;
};

vertex heap[100];
int ph[100];//ph[i]存放顶点i在堆中的下标,当i的位置改变时它也随之改变
int size;//堆的大小
inline int parent(int i)
{
    return (i+1)/2-1;
}
inline int left(int i)
{
    return (i+1)*2-1;
}
inline int right(int i)
{
    return (i+1)*2;
}
void heapify(int i)
{
    int smallest=i;
    if(left(i)<size&&heap[left(i)].weight<heap[smallest].weight)
    {
        smallest=left(i);
    }
    if(right(i)<size&&heap[right(i)].weight<heap[smallest].weight)
    {
        smallest=right(i);
    }
    if(smallest!=i)
    {//交换heap[smallest]和heap[i]中的值,并实ph[]中的值与交换后的情况一致
        ph[heap[smallest].n]=i;
        ph[heap[i].n]=smallest;
        vertex temp;
        temp=heap[smallest];
        heap[smallest]=heap[i];
        heap[i]=temp;
        heapify(smallest);
    }
}
vertex extract()
{
    //得到从原点出发的可到达的最近的点
    vertex min=heap[0];
    heap[0]=heap[--size];
    ph[heap[0].n]=0;
    heapify(0);
    return min;
}
void build()
{
    //initialize a heap from an array , but not used in Dijkstra.
    for(int i = parent(size-1) ; i >=0 ; --i)
    {
        heapify(i);
    }
}
void decrease(int i,int key)
{
    //更新heap[i]的值为key,且key必须为非负
    heap[i].weight=key;
    while(i>0&&heap[i].weight<heap[parent(i)].weight)
    {
        ph[heap[i].n]=parent(i);
        ph[heap[parent(i)].n]=i;
        vertex temp;
        temp=heap[i];
        heap[i]=heap[parent(i)];
        heap[parent(i)]=temp;
        i=parent(i);
    }
}
bool empty()
{//测试堆是否为空
    return size==0;
}
int n;//顶点的个数
int d[100];//存放从原点到此顶点的最短距离
vector<vertex> v[100];
void Dijkstra(int source)
{
    for(int i = 0 ; i < n ; ++i )
    {
        heap[i].n=i;
        heap[i].weight=NoEdge;
        ph[i]=i;
    }
    decrease(source,0);
    vertex min;
    while(!empty())
    {
        min=extract();
        d[min.n]=min.weight;
        cout << endl;
        for(vector<vertex>::iterator itr=v[min.n].begin();itr!=v[min.n].end();++itr)
        {
            if(heap[ph[itr->n]].weight>min.weight+itr->weight)
            {
                decrease(ph[itr->n],min.weight+itr->weight);
            }
        }
    }
}
int main()
{
    int a,b,w;
    int edges;
    vertex temp;
    cin >> n;
    cin >> edges;
    size=n;
    for(int i = 0 ; i < n ; ++i )
    {
        d[i]=NoEdge;
    }
    for(int i = 0 ; i < edges; ++i )
    {
        cin >> a >> b >> w;
        temp.n=b;
        temp.weight=w;
        v[a].push_back(temp);
    }

    int s,t;
    while(cin>>s>>t)
    {
        Dijkstra(s);
        cout<<d[t]<<endl;
    }
    return 0;
}

posted @ 2010-10-18 20:32 superKiki 阅读(2286) | 评论 (0) | 编辑收藏

二叉树的各种遍历

摘要: 上周数据结构课在讲二叉树的遍历，老师只讲递归算法，没有什么技术含量，遂自己琢磨非递归算法实现... 前序遍历:先访问根节点，再访问左子树，最后访问右子树。设置一个栈，出栈即为访问节点。先将根节点进栈，在栈不空时一直如下循环:出栈，访问，将其右孩子进栈，再将左孩子进栈。中序遍历:先访问左子树，再访问根节点，最后访问右子树。设置一个栈，出栈即为访问节点。先将根节点的左节点全部进栈，然后出栈一个节... 阅读全文

posted @ 2010-10-18 20:17 superKiki 阅读(368) | 评论 (0) | 编辑收藏

数组分割问题

题目概述：有一个没有排序，元素个数为2N的正整数数组。要求把它分割为元素个数为N的两个数组，并使两个子数组的和最接近。
假设数组A[1..2N]所有元素的和是SUM。模仿动态规划解0-1背包问题的策略，令S(k, i)表示前k个元素中任意i个元素的和的集合。显然：
S(k, 1) = {A[i] | 1<= i <= k}
S(k, k) = {A[1]+A[2]+…+A[k]}
S(k, i) = S(k-1, i) U {A[k] + x | x属于S(k-1, i-1) }
按照这个递推公式来计算，最后找出集合S(2N, N)中与SUM最接近的那个和，这便是答案。这个算法的时间复杂度是O(22N).
因为这个过程中只关注和不大于SUM/2的那个子数组的和。所以集合中重复的和以及大于SUM/2的和都是没有意义的。把这些没有意义的和剔除掉，剩下的有意义的和的个数最多就是SUM/2个。所以，我们不需要记录S(2N,N)中都有哪些和，只需要从SUM/2到1遍历一次，逐个询问这个值是不是在S(2N,N)中出现，第一个出现的值就是答案。我们的程序不需要按照上述递推公式计算每个集合，只需要为每个集合设一个标志数组，标记SUM/2到1这个区间中的哪些值可以被计算出来。关键代码如下：

for(i = 0; i < N+1; i++)
    for(j = 0; j < sum/2+1; j++)
        flag[i][j] = false;
flag[0][0] = true;
for(int k = 1; k <= 2*N; k++) {
    for(i = k > N ? N : k; i >= 1; i--) {
        //两层外循环是遍历集合S(k,i)
        for(j = 0; j <= sum/2; j++) {
            if(j >= A[k] && flag[i-1][j-A[k]])
                flag[i][j] = true;
        }
    }
}
for(i = sum/2; i >= 0; i--) {
    if(flag[N][i]) {
        cout << "minimum delta is " << abs(2*i - sum) << endl;
        break;
    }
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lyso1/archive/2010/10/11/5933701.aspx

posted @ 2010-10-17 00:47 superKiki 阅读(734) | 评论 (0) | 编辑收藏

高精度类（有点小bug待解决）

#include <iostream>
using namespace std;
typedef long long hugeint;
const int Base = 1000000000;
const int Capacity = 100;

class BigInt
{
public:
    int Len;
    int Data[Capacity];
    BigInt() : Len(0) {}
    BigInt(const BigInt& V) : Len(V.Len) { memcpy(Data, V.Data, Len * sizeof *Data); }
    BigInt(int V) : Len(0) { for (; V > 0; V /= Base) Data[Len++] = V % Base; }
    BigInt& operator=(const BigInt& V) {Len = V.Len; memcpy(Data, V.Data, Len * sizeof *Data); return *this; }
    int& operator[](int Index) { return Data[Index]; }
    int operator[](int Index) const { return Data[Index]; }
};

int compare(const BigInt& A, const BigInt& B)
{
    int I;
    if (A.Len != B.Len)
        return A.Len > B.Len ? 1 : -1;
    for (I = A.Len - 1; I >= 0 && A[I] == B[I]; I--);
    if (I < 0)
        return 0;
    return A[I]>B[I]?1:-1;
}

BigInt operator+(const BigInt& A, const BigInt& B)
{
    BigInt R;
    int I;
    int Carry = 0;
    for (I = 0; I < A.Len || I < B.Len || Carry > 0; I++)
    {
        if (I < A.Len)
            Carry += A[I];
        if (I < B.Len)
            Carry += B[I];
        R[I] = Carry % Base;
        Carry /= Base;
    }
    R.Len = I;
    return R;
}

BigInt operator-(const BigInt& A, const BigInt& B)
{
    BigInt R;
    int Carry = 0;
    R.Len = A.Len;
    int I;
    for (I = 0; I < R.Len; I++)
    {
        R[I] = A[I] - Carry;
        if (I < B.Len) R[I] -= B[I];
        if (R[I] < 0) Carry = 1, R[I] += Base;
        else Carry = 0;
    }
    while (R.Len > 0 && R[R.Len - 1] == 0) R.Len--;
    return R;
}

BigInt operator*(const BigInt& A, const int B)
{
    int I;
    if (B == 0) return 0;
    BigInt R;
    hugeint Carry = 0;
    for (I = 0; I < A.Len || Carry > 0; I++)
    {
        if (I < A.Len) Carry += hugeint(A[I]) * B;
        R[I] = Carry % Base;
        Carry /= Base;
    }
    R.Len = I;
    return R;
}

BigInt operator*(const BigInt& A, const BigInt& B)
{
    int I;
    if (B.Len == 0) return 0;
    BigInt R;
    for (I = 0; I < A.Len; I++)
    {
        hugeint Carry = 0;
        for (int J = 0; J < B.Len || Carry > 0; J++)
        {
            if (J < B.Len) Carry += hugeint(A[I]) * B[J];
            if (I + J < R.Len) Carry += R[I + J];
            if (I + J >= R.Len) R[R.Len++] = Carry % Base;
            else R[I + J] = Carry % Base;
            Carry /= Base;
        }
    }
    return R;
}

BigInt operator/(const BigInt& A, const int B)
{
    BigInt R;
    int I;
    hugeint C = 0;
    for (I = A.Len - 1; I >= 0; I--)
    {
        C = C * Base + A[I];
        R[I] = C / B;
        C %= B;
    }
    R.Len = A.Len;
    while (R.Len > 0 && R[R.Len - 1] == 0) R.Len--;
    return R;
}

BigInt operator/(const BigInt& A, const BigInt& B)
{
    int I;
    BigInt R, Carry = 0;
    int Left, Right, Mid;
    for (I = A.Len - 1; I >= 0; I--)
    {
        Carry = Carry * Base + A[I];
        Left = 0;
        Right = Base - 1;
        while (Left < Right)
        {
            Mid = (Left + Right + 1) / 2;
            if (compare(B * Mid, Carry) <= 0) Left = Mid;
            else Right = Mid - 1;
        }
        R[I] = Left;
        Carry = Carry - B * Left;
    }
    R.Len = A.Len;
    while (R.Len > 0 && R[R.Len - 1] == 0) R.Len--;
    return R;
}
BigInt operator%(const BigInt& A, const BigInt& B)
{
    int I;
    BigInt R, Carry = 0;
    int Left, Right, Mid;
    for (I = A.Len - 1; I >= 0; I--)
    {
        Carry = Carry * Base + A[I];
        Left = 0;
        Right = Base - 1;
        while (Left < Right)
        {
            Mid = (Left + Right + 1) / 2;
            if (compare(B * Mid, Carry) <= 0) Left = Mid;
            else Right = Mid - 1;
        }
        R[I] = Left;
        Carry = Carry - B * Left;
    }
    R.Len = A.Len;
    while (R.Len > 0 && R[R.Len - 1] == 0) R.Len--;
    return Carry;
}

istream& operator>>(istream& In, BigInt& V)
{
    char Ch;
    for (V = 0; In >> Ch;)
    {
        V = V * 10 + (Ch - '0');
        if (cin.peek() <= ' ') break;
    }
    return In;
}

ostream& operator<<(ostream& Out, const BigInt& V)
{
    int I;
    Out << (V.Len == 0 ? 0 : V[V.Len - 1]);
    for (I = V.Len - 2; I >= 0; I--) for (int J = Base / 10; J > 0; J /= 10) Out << V[I] / J % 10;
    return Out;
}

BigInt a,b;
int main(void)
{
    while(cin>>a>>b)
    {
        cout<<a-b<<endl;
    }
    return 0;
}

posted @ 2010-10-16 21:45 superKiki 阅读(217) | 评论 (0) | 编辑收藏

小程序大作为：高级查找/替换、正则表达式练习器、Javascript脚本程序调试器

把下面代码复制到记事本里，保存为 HTML 格式就ok 了！

原代码：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<HTML><HEAD><TITLE>Power Maintenance Tools -- By Alai [http://www.9499.net]</TITLE>
<META http-equiv=Content-Type content=text/html;charset=gb_2312-80>
<META content="MSHTML 6.00.3790.2759" name=GENERATOR></HEAD>
<BODY>
<DIV
style="FONT-WEIGHT: bold; FONT-SIZE: 11pt; WIDTH: 700px; TEXT-ALIGN: center">高级查找/替换、正则表达式练习器、Javascript脚本程序调试器<BR><TEXTAREA id=text1 rows=18 cols=90></TEXTAREA><BR><SPAN
id=spanFirst>查询表达式</SPAN>：<INPUT id=txtFirst size=60><BR><SPAN
id=spanSecond>替换为</SPAN>：<INPUT id=txtSecond size=56><BR><INPUT id=chkLineMode
type=checkbox value=false>行模式运行 <INPUT id=btnExe type=button value=运行脚本程序> <INPUT id=btnSchRpl type=button value=执行查找/替换> <INPUT id=btnUndo disabled type=button value=撤消> <INPUT id=btnRedo disabled type=button value=重做> <BR></DIV>
<SCRIPT>
var aryUndo=[],aryRedo=[]
function btnExe.onclick()
{
    if(text1.value=="")return false
    if(!chkLineMode.checked)
    {try{
       eval(text1.value);
    }
    catch(e)
    {
    var msg=e.number+"\n"
    msg+=e.description+"\n"
    alert(msg)
    }
    return
}
    aryCommand=text1.value.split("\r\n")
    var line
try{
    for(line=0;line<=aryCommand.length-1;line++)
{
            eval(aryCommand[line]+";")
}
}
catch(e){
   var msg="执行脚本程序程序出错，在第"+(line+1)+"行。\n"
   msg+="错误代码："+e.number+"\n"
   msg+="错误信息："+e.description+"\n"
   alert(msg)
}
}

function btnSchRpl.onclick()
{
    if(txtFirst.value=="")
    {
       alert("请输入查询条件!")
       txtSecond.focus()
       return false
    }
   aryUndo[aryUndo.length]=text1.value
   aryRedo=[]
   btnRedo.disabled=true
   btnUndo.disabled=false

        var s=new RegExp(txtFirst.value,"ig")
   text1.value=text1.value.replace(s,txtSecond.value)
}
function btnUndo.onclick()
{
aryRedo[aryRedo.length]=text1.value
btnRedo.disabled=false
text1.value =aryUndo[aryUndo.length-1]
aryUndo.length--
if(aryUndo.length==0)btnUndo.disabled=true
}
function btnRedo.onclick()
{
aryUndo[aryUndo.length]=text1.value
btnUndo.disabled=false
text1.value=aryRedo[aryRedo.length-1]
aryRedo.length--
if(aryRedo.length==0)btnRedo.disabled=true
}
   </SCRIPT>
<BR>
<DIV style="WIDTH: 100%; TEXT-ALIGN: center">power by Alai <A
href="http://www.9499.net/">http://www.9499.net/</A></DIV></BODY></HTML>

posted @ 2010-10-11 00:21 superKiki 阅读(485) | 评论 (0) | 编辑收藏

常用正则表达式积累（四）

利用正则表达式限制网页表单里的文本框输入内容：

用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" ōnbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"

1.用正则表达式限制只能输入全角字符： ōnkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" ōnbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"

2.用正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

3.用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

4.计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}

5.javascrīpt中没有像vbscrīpt那样的trim函数，我们就可以利用这个表达式来实现，如下：

String.prototype.trim = function()
{
return this.replace(/(^\s*)|(\s*$)/g, "");
}

利用正则表达式分解和转换IP地址：

6.下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascrīpt程序：

function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("不是一个正确的IP地址!")
}
}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))
正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。

匹配中文字符的正则表达式： [\u4e00-\u9fa5]
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了

匹配双字节字符(包括汉字在内)：[^\x00-\xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

匹配空白行的正则表达式：\n\s*\r
评注：可以用来删除空白行

匹配HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? />
评注：上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力

匹配首尾空白字符的正则表达式：^\s*|\s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
评注：表单验证时很实用

匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用

匹配国内电话号码：\d{3}-\d{8}|\d{4}-\d{7}
评注：匹配形式如 0511-4405222 或 021-87888822

匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始

匹配中国邮政编码：[1-9]\d{5}(?!\d)
评注：中国邮政编码为6位数字

匹配身份证：\d{15}|\d{18}
评注：中国的身份证为15位或18位

匹配ip地址：\d+\.\d+\.\d+\.\d+
评注：提取ip地址时有用

匹配特定数字：
^[1-9]\d*$ //匹配正整数
^-[1-9]\d*$ //匹配负整数
^-?[1-9]\d*$ //匹配整数
^[1-9]\d*|0$ //匹配非负整数（正整数 + 0）
^-[1-9]\d*|0$ //匹配非正整数（负整数 + 0）
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ //匹配正浮点数
^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ //匹配负浮点数
^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$ //匹配浮点数
^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$ //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$ //匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正

匹配特定字符串：
^[A-Za-z]+$ //匹配由26个英文字母组成的字符串
^[A-Z]+$ //匹配由26个英文字母的大写组成的字符串
^[a-z]+$ //匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$ //匹配由数字和26个英文字母组成的字符串
^\w+$ //匹配由数字、26个英文字母或者下划线组成的字符串
评注：最基本也是最常用的一些表达式

匹配中文字符的正则表达式： [\u4e00-\u9fa5]

匹配双字节字符(包括汉字在内)：[^\x00-\xff]

匹配空行的正则表达式：\n[\s| ]*\r

匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/

匹配首尾空格的正则表达式：(^\s*)|(\s*$)

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

^\d+$ //匹配非负整数（正整数 + 0）
^[0-9]*[1-9][0-9]*$ //匹配正整数
^((-\d+)|(0+))$ //匹配非正整数（负整数 + 0）
^-[0-9]*[1-9][0-9]*$ //匹配负整数
^-?\d+$ //匹配整数
^\d+(\.\d+)?$ //匹配非负浮点数（正浮点数 + 0）
^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$ //匹配正浮点数
^((-\d+(\.\d+)?)|(0+(\.0+)?))$ //匹配非正浮点数（负浮点数 + 0）
^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$ //匹配负浮点数
^(-?\d+)(\.\d+)?$ //匹配浮点数
^[A-Za-z]+$ //匹配由26个英文字母组成的字符串
^[A-Z]+$ //匹配由26个英文字母的大写组成的字符串
^[a-z]+$ //匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$ //匹配由数字和26个英文字母组成的字符串
^\w+$ //匹配由数字、26个英文字母或者下划线组成的字符串
^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$

posted @ 2010-10-11 00:18 superKiki 阅读(355) | 评论 (0) | 编辑收藏

常用正则表达式积累（一）

1.由数字、26个英文字母或者下划线组成的字符串:
     ^[0-9a-zA-Z_]{1,}$
2.非负整数（正整数 + 0 ）:
     ^\d+$
3.正整数:
     ^[0-9]*[1-9][0-9]*$
4.非正整数（负整数 + 0）：
     ^((-\d+)|(0+))$
5.负整数 :
     ^-[0-9]*[1-9][0-9]*$
6.整数:
     ^-?\d+$
7.非负浮点数（正浮点数 + 0）:
     ^\d+(\.\d+)?$
8.正浮点数 :
     ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
9.非正浮点数（负浮点数 + 0）:
     ^((-\d+(\.\d+)?)|(0+(\.0+)?))$
10.负浮点数 :
     ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
11.浮点数 :
     ^(-?\d+)(\.\d+)?$
12.由26个英文字母组成的字符串 :
     ^[A-Za-z]+$
13.由26个英文字母的大写组成的字符串 :
     ^[A-Z]+$
14.由26个英文字母的小写组成的字符串 :
     ^[a-z]+$
15.由数字和26个英文字母组成的字符串 :
     ^[A-Za-z0-9]+$
16.由数字、26个英文字母或者下划线组成的字符串 :
     ^\w+$
17.email地址 :
     ^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$
18.url:
     ^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$
19. 年-月-日:
     /^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/
20.月/日/年:
     /^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/
21.Emil:
     ^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$
22.电话号码:
     (d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)?
23.IP地址:
     ^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$
24.匹配中文字符的正则表达式：
     [\u4e00-\u9fa5]
25.匹配双字节字符(包括汉字在内)：
     [^\x00-\xff]
26.匹配空行的正则表达式：
     \n[\s| ]*\r
27.匹配HTML标记的正则表达式：
     /<(.*)>.*<\/\1>|<(.*) \/>/
28.匹配首尾空格的正则表达式：
     (^\s*)|(\s*$)
29.匹配Email地址的正则表达式：
     \w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
30.匹配网址URL的正则表达式：
     ^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$
31.匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：
     ^[a-zA-Z][a-zA-Z0-9_]{4,15}$
32.匹配国内电话号码：
     (\d{3}-|\d{4}-)?(\d{8}|\d{7})?
33.匹配腾讯QQ号：
     ^[1-9]*[1-9][0-9]*$
34.只能输入数字：
     ^[0-9]*$
35.只能输入n位的数字：
     ^\d{n}$
36.只能输入至少n位的数字：
     ^\d{n,}$
37.只能输入m~n位的数字：
     ^\d{m,n}$
38.只能输入零和非零开头的数字：
     ^(0|[1-9][0-9]*)$
39.只能输入有两位小数的正实数：
     ^[0-9]+(.[0-9]{2})?$
40.只能输入有1~3位小数的正实数：
     ^[0-9]+(.[0-9]{1,3})?$
41.只能输入非零的正整数：
     ^\+?[1-9][0-9]*$
42.只能输入非零的负整数：
     ^\-[1-9][0-9]*$
43.只能输入长度为3的字符：
     ^.{3}$
44.只能输入由26个英文字母组成的字符串：
     ^[A-Za-z]+$
45.只能输入由26个大写英文字母组成的字符串：
     ^[A-Z]+$
46.只能输入由26个小写英文字母组成的字符串：
     ^[a-z]+$
47.只能输入由数字和26个英文字母组成的字符串：
     ^[A-Za-z0-9]+$
48.只能输入由数字和26个英文字母或者下划线组成的字符串：
     ^\w+$
49.验证用户密码(正确格式为：以字母开头，长度在5~17 之间，只能包含字符、数字和下划线)
     ^[a-zA-Z]\w{5,17}$
50.验证是否包含有^%&',;=?$\"等字符：
     [^%&',;=?$\x22]+
51.只能输入汉字：
     ^[\u4e00-\u9fa5]{0,}$
52、只含有汉字、数字、字母、下划线不能以下划线开头和结尾
     ^(?!_)(?!.*?_$)[a-zA-Z0-9_\u4e00-\u9fa5]+$
53、只含有汉字、数字、字母、下划线，下划线位置不限
     ^[a-zA-Z0-9_\u4e00-\u9fa5]+$
54、2~4个汉字
     ^[\u4E00-\u9FA5]{2,4}$

55. Zip :      /^[1-9]\d{5}$/
56.帐号(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
57.匹配身份证：\d{15}|\d{18}
58.匹配中国邮政编码：[1-9]\d{5}(?!\d)
59.手机号码：^(($\d{2,3}$)|(\d{3}\-))?13\d{9}$
60.匹配两个连续相同的字符：(.)\1
61.匹配包括“\n”在内的任意字符：[\s\S] 或[\d\D]或[\w\W]

posted @ 2010-10-11 00:17 superKiki 阅读(341) | 评论 (0) | 编辑收藏

常用正则表达式积累（二）

提取网页中的链接地址
(http:\/\/\[^" ']+)
href *= *['"]*(\S+)["']* *
((http|https|ftp):(\/\/|\\\\)((\w)+[.]){1,}(net|com|cn|org|cc|tv|[0-9]{1,3})(((\/[\~]*|\\[\~]*)(\w)+)|[.](\w)+)*(((([?](\w)+){1}[=]*))*((\w)+){1}([\&](\w)+[\=](\w)+)*)*) "精确匹配"

•匹配一个 HTML 标记
<(.*)>.*<\/\1>　　"第一个匹配的是(.*),后面的\1就引用他,所以就成了对称的"
<[^>]*>　　　　　 "html标记"

•从一段HTML代码中搜索其中的图片
/\/ig,"$1"

•匹配连续字符
(.)\1　　　匹配两个连续相同的字符,(.)\1第一个匹配的是(.),后面的\1就引用他，连起来就成了两个连续的
(.)\1\1　　匹配三个连续相同的字符,如果三个连续就用(.)\1\1,后面两个\1都引用前面的(.)

•替换"[abc]asdfasldkfjlasd[/abc]中的[abc]"
(/(^\[abc\])|(\[\/abc\]$)/gi,'')

•年月日的格式
/^(\d{4})-(\d{1,2})-(\d{1,2})$/ "yyyy-mm-dd"
/^(\d{4})/(\d{1,2})/(\d{1,2})$/ "yyyy/mm/dd"
(^[[igit:]]{4}-([1-9]|1[0-2])-([1-9]|[1-2][0-9]|3[0-1]))
(/^\d{4}-([1-9]|1[0-2])-([0-2]{0,1}[0-9]|3[0-1])$/g)

•Email邮件的格式
/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/
/^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)$/
/\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/
/(\w)+[@]{1}(\w)+[.]{1，3}(\w)+/

•身份证
/([0-9]){15}/ "15位数字"
/^\d+$/ "全数字"
/^(\d{14}|\d{17})(\d|x)$/ "15位或18位"

•手机电话号码
/^13[13567890](\d{8})$/ 　　　　　"13开头，第三位为1,3,5,6,7,8,9,0，后跟8个数字"
/^(\d{3,4}-){0,1}(\d{7,8})$/　　　"匹配3-4位区号和横杆，7-8位市内电话号码"
/^\d{3,4}-\d{7,8}(-\d{3,4})?$/　　"区号必填为3-4位的数字，区号之后用“-”与电话号码连接；电话号码为7-8位的数字；分机号码为3-4位的数字，非必填，但若填写则以“-”与电话号码相连接"

.匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
匹配Email地址的正则表达式：\w ([- .]\w )*@\w ([-.]\w )*\.\w ([-.]\w )*
匹配网址URL的正则表达式：http://([\w-] \.) [\w-] (/[\w- ./?%&=]*)?

.Email : /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/,
Phone : /^(($\d{2,3}$)|(\d{3}\-))?($0\d{2,3}$|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$/,
Mobile : /^(($\d{2,3}$)|(\d{3}\-))?13\d{9}$/,
Url : /^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/,
Currency : /^\d+(\.\d+)?$/,
Number : /^\d+$/,
Zip : /^[1-9]\d{5}$/,
QQ : /^[1-9]\d{4,8}$/,
Integer : /^[-\+]?\d+$/,
Double : /^[-\+]?\d+(\.\d+)?$/,
English : /^[A-Za-z]+$/,
Chinese : /^[\u0391-\uFFE5]+$/,

.
匹配中文字符的正则表达式： [u4e00-u9fa5]
匹配双字节字符(包括汉字在内)：[^x00-xff]
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
匹配空白行的正则表达式：ns*r
评注：可以用来删除空白行
匹配HTML标记的正则表达式：< (S*?)[^>]*>.*?|< .*? />
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力
匹配首尾空白字符的正则表达式：^s*|s*$
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式

匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
评注：表单验证时很实用
匹配网址URL的正则表达式：[a-zA-z]+://[^s]*
评注：网上流传的版本功能很有限，上面这个基本可以满足需求
匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
评注：表单验证时很实用
匹配国内电话号码：d{3}-d{8}|d{4}-d{7}
评注：匹配形式如 0511-4405222 或 021-87888822
匹配腾讯QQ号：[1-9][0-9]{4,}
评注：腾讯QQ号从10000开始
匹配中国邮政编码：[1-9]d{5}(?!d)
评注：中国邮政编码为6位数字
匹配身份证：d{15}|d{18}
评注：中国的身份证为15位或18位
匹配ip地址：d+.d+.d+.d+
评注：提取ip地址时有用
匹配特定数字：
^[1-9]d*$　　 //匹配正整数
^-[1-9]d*$ 　 //匹配负整数
^-?[1-9]d*$　　 //匹配整数
^[1-9]d*|0$　 //匹配非负整数（正整数 + 0）
^-[1-9]d*|0$　　 //匹配非正整数（负整数 + 0）
^[1-9]d*.d*|0.d*[1-9]d*$　　 //匹配正浮点数
^-([1-9]d*.d*|0.d*[1-9]d*)$　 //匹配负浮点数
^-?([1-9]d*.d*|0.d*[1-9]d*|0?.0+|0)$　 //匹配浮点数
^[1-9]d*.d*|0.d*[1-9]d*|0?.0+|0$　　 //匹配非负浮点数（正浮点数 + 0）
^(-([1-9]d*.d*|0.d*[1-9]d*))|0?.0+|0$　　//匹配非正浮点数（负浮点数 + 0）
评注：处理大量数据时有用，具体应用时注意修正
匹配特定字符串：
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
在使用RegularExpressionValidator验证控件时的验证功能及其验证表达式介绍如下:
只能输入数字：“^[0-9]*$”
只能输入n位的数字：“^d{n}$”
只能输入至少n位数字：“^d{n,}$”
只能输入m-n位的数字：“^d{m,n}$”
只能输入零和非零开头的数字：“^(0|[1-9][0-9]*)$”
只能输入有两位小数的正实数：“^[0-9]+(.[0-9]{2})?$”
只能输入有1-3位小数的正实数：“^[0-9]+(.[0-9]{1,3})?$”
只能输入非零的正整数：“^+?[1-9][0-9]*$”
只能输入非零的负整数：“^-[1-9][0-9]*$”
只能输入长度为3的字符：“^.{3}$”
只能输入由26个英文字母组成的字符串：“^[A-Za-z]+$”
只能输入由26个大写英文字母组成的字符串：“^[A-Z]+$”
只能输入由26个小写英文字母组成的字符串：“^[a-z]+$”
只能输入由数字和26个英文字母组成的字符串：“^[A-Za-z0-9]+$”
只能输入由数字、26个英文字母或者下划线组成的字符串：“^w+$”
验证用户密码:“^[a-zA-Z]w{5,17}$”正确格式为：以字母开头，长度在6-18之间，
只能包含字符、数字和下划线。
验证是否含有^%&’,;=?$”等字符：“[^%&',;=?$x22]+”
只能输入汉字：“^[u4e00-u9fa5],{0,}$”
验证Email地址：“^w+[-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*$”
验证InternetURL：“^http://([w-]+.)+[w-]+(/[w-./?%&=]*)?$”
验证电话号码：“^((d{3,4})|d{3,4}-)?d{7,8}$”
正确格式为：“XXXX-XXXXXXX”，“XXXX-XXXXXXXX”，“XXX-XXXXXXX”，
“XXX-XXXXXXXX”，“XXXXXXX”，“XXXXXXXX”。
验证身份证号（15位或18位数字）：“^d{15}|d{}18$”
验证一年的12个月：“^(0?[1-9]|1[0-2])$”正确格式为：“01”-“09”和“1”“12”
验证一个月的31天：“^((0?[1-9])|((1|2)[0-9])|30|31)$”
正确格式为：“01”“09”和“1”“31”。
匹配中文字符的正则表达式： [u4e00-u9fa5]
匹配双字节字符(包括汉字在内)：[^x00-xff]
匹配空行的正则表达式：n[s| ]*r
匹配HTML标记的正则表达式：/< (.*)>.*|< (.*) />/
匹配首尾空格的正则表达式：(^s*)|(s*$)
匹配Email地址的正则表达式：w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*
匹配网址URL的正则表达式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

posted @ 2010-10-11 00:17 superKiki 阅读(398) | 评论 (0) | 编辑收藏

常用正则表达式积累（三）

1、非负整数：^\d+$

2、正整数：^[0-9]*[1-9][0-9]*$

3、非正整数：^((-\d+)|(0+))$

4、负整数：^-[0-9]*[1-9][0-9]*$

5、整数：^-?\d+$

6、非负浮点数：^\d+(\.\d+)?$

7、正浮点数：^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$

8、非正浮点数：^((-\d+\.\d+)?)|(0+(\.0+)?))$

9、负浮点数：^(-((正浮点数正则式)))$

10、英文字符串：^[A-Za-z]+$

11、英文大写串：^[A-Z]+$

12、英文小写串：^[a-z]+$

13、英文字符数字串：^[A-Za-z0-9]+$

14、英数字加下划线串：^\w+$

15、E-mail地址：^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$

16、URL：^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$
或：^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$

17、邮政编码：^[1-9]\d{5}$

18、中文：^[\u0391-\uFFE5]+$

19、电话号码：^(($\d{2,3}$)|(\d{3}\-))?($0\d{2,3}$|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$

20、手机号码：^(($\d{2,3}$)|(\d{3}\-))?13\d{9}$

21、双字节字符(包括汉字在内)：^\x00-\xff

22、匹配首尾空格：(^\s*)|(\s*$)（像vbscript那样的trim函数）

23、匹配HTML标记：<(.*)>.*<\/\1>|<(.*) \/>

24、匹配空行：\n[\s| ]*\r

25、提取信息中的网络链接：(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

26、提取信息中的邮件地址：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

27、提取信息中的图片链接：(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

28、提取信息中的IP地址：(\d+)\.(\d+)\.(\d+)\.(\d+)

29、提取信息中的中国手机号码：(86)*0*13\d{9}

30、提取信息中的中国固定电话号码：($\d{3,4}$|\d{3,4}-|\s)?\d{8}

31、提取信息中的中国电话号码（包括移动和固定电话）：($\d{3,4}$|\d{3,4}-|\s)?\d{7,14}

32、提取信息中的中国邮政编码：[1-9]{1}(\d+){5}

33、提取信息中的浮点数（即小数）：(-?\d*)\.?\d+

34、提取信息中的任何数字：(-?\d*)(\.\d+)?

35、IP：(\d+)\.(\d+)\.(\d+)\.(\d+)

36、电话区号：/^0\d{2,3}$/

37、腾讯QQ号：^[1-9]*[1-9][0-9]*$

38、帐号(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$

39、中文、英文、数字及下划线：^[\u4e00-\u9fa5_a-zA-Z0-9]+$

40.javascript验证表单时常用的RE

"^-[0-9]*[1-9][0-9]*$"　　//负整数

"^-?\d+$"　　　　//整数

"^\d+(\.\d+)?$"　　//非负浮点数（正浮点数 + 0）

"^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数

"^((-\d+(\.\d+)?)|(0+(\.0+)?))$"　　//非正浮点数（负浮点数 + 0）

"^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数

"^(-?\d+)(\.\d+)?$"　　//浮点数

"^[A-Za-z]+$"　　//由26个英文字母组成的字符串

"^[A-Z]+$"　　//由26个英文字母的大写组成的字符串

"^[a-z]+$"　　//由26个英文字母的小写组成的字符串

"^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符串

"^\w+$"　　//由数字、26个英文字母或者下划线组成的字符串

"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"　　　　//email地址

"^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$"　　//url

41. 匹配空行： /^\s*$/
42. 匹配HTML标记：/<(\S+)(\s[^>]*)*>[\s\S]*<\/\1\s*>/
43 .匹配E-mail地址：/[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+/
44. 匹配两个相同的相邻单词： /\b([a-z]+) \1\b/
45 匹配IP地址：/^\d{1,2}|1\d\d|2[0-4]\d|25[0-5](\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])){3}$/
46. 匹配URL(仅用于提取各个组件信息)：/(\w+):\/\/([^/:]+)(?::(\d*))?([^# ]*)/

posted @ 2010-10-11 00:16 superKiki 阅读(208) | 评论 (0) | 编辑收藏

常用正则表达式积累

常用的正则表达式主要有以下几种：
　　匹配中文字符的正则表达式： [\u4e00-\u9fa5]
　　评注：匹配中文还真是个头疼的事，有了这个表达式就好办了哦
　　获取日期正则表达式：\d{4}[年|\-|\.]\d{1,2}[月|\-|\.]\d{1,2}日?
　　评注：可用来匹配大多数年月日信息。
　　匹配双字节字符(包括汉字在内)：[^\x00-\xff]
　　评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
　　匹配空白行的正则表达式：\n\s*\r
　　评注：可以用来删除空白行
　　匹配HTML标记的正则表达式：<(\S*?)[^>]*>.*?</>|<.*? />
　　评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力
　　匹配首尾空白字符的正则表达式：^\s*|\s*$
　　评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式
　　匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
　　评注：表单验证时很实用
　　匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
　　评注：网上流传的版本功能很有限，上面这个基本可以满足需求
　　匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
　　评注：表单验证时很实用
　　匹配国内电话号码：\d{4}-\d{7}|\d{3}-\d{8}
　　评注：匹配形式如 0511-4405222 或 021-87888822
　　匹配腾讯QQ号：[1-9][0-9]\{4,\}
　　评注：腾讯QQ号从10000开始
　　匹配中国邮政编码：[1-9]\d(?!\d)
　　评注：中国邮政编码为6位数字
　　匹配身份证：\d{17}[\d|X]|\d{15}
　　评注：中国的身份证为15位或18位
　　匹配ip地址：((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。
　　评注：提取ip地址时有用
　　匹配特定数字：
　　^[1-9]\d*$　//匹配正整数
　　^-[1-9]\d*$ //匹配负整数
　　^-?[1-9]\d*$　//匹配整数
　　^[1-9]\d*|0$　//匹配非负整数（正整数 + 0）
　　^-[1-9]\d*|0$　//匹配非正整数（负整数 + 0）
　　^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$　//匹配正浮点数
　　^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$　//匹配负浮点数
　　^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$　//匹配浮点数
　　^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$　//匹配非负浮点数（正浮点数 + 0）
　　^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$　//匹配非正浮点数（负浮点数 + 0）
　　评注：处理大量数据时有用，具体应用时注意修正
　　匹配特定字符串：
　　^[A-Za-z]+$　//匹配由26个英文字母组成的字符串
　　^[A-Z]+$　//匹配由26个英文字母的大写组成的字符串
　　^[a-z]+$　//匹配由26个英文字母的小写组成的字符串
　　^[A-Za-z0-9]+$　//匹配由数字和26个英文字母组成的字符串
　　^\w+$　//匹配由数字、26个英文字母或者下划线组成的字符串
　　评注：最基本也是最常用的一些表达式
　　Function IsRegu(Regu,s)
　　'正则表达式校验
　　If Regu="" Then
　　Exit Function
　　End if
　　Dim Re,Sre
　　Set Re = New RegExp
　　Re.Pattern = Regu
　　Sre = Re.Test(s)
　　If Sre = True Then
　　IsRegu = True
　　Else
　　IsRegu = False
　　End If
　　End Function
　　tmp="hao123@163.com"
　　if (IsRegu("\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*",tmp )) =false then
　　msgbox "E-mail地址不合法！"
　　FieldCheck#N=false
　　end if
　　不同的语言（如PHP和JAVA）、相同语言的不同类库（如来自Sun的Java Regular Expression类库跟Apache Jakarta的正则表达式类库）间，用法会有所差别，在使用的时候，要注意这些差别。

posted @ 2010-10-11 00:13 superKiki 阅读(302) | 评论 (0) | 编辑收藏

仅列出标题

dijkstra算法裸实现+heap优化

Dijkstra算法简述

Dijkstra算法流程

二叉树的各种遍历

数组分割问题

高精度类（有点小bug待解决）

小程序大作为：高级查找/替换、正则表达式练习器、Javascript脚本程序调试器

常用正则表达式积累（四）

常用正则表达式积累（一）

常用正则表达式积累（二）

常用正则表达式积累（三）

常用正则表达式积累

导航

统计

常用链接

留言簿

随笔档案

文章分类

我的好友

一些常去的网站

搜索

最新评论

阅读排行榜

评论排行榜