C++博客-. . . . . . . . . . . . . . Blog Garden' C plus plus (My technology Impire!)-文章分类-Algorithm & DataStruct

数据结构复习篇:队列

Technical Consultant — Tue, 03 Oct 2006 19:24:00 GMT

数据结构复习篇:队列

队列是一种先进先出（FIFO）的线性表。跟栈一样，它们的pop()、push()操作的时间复杂度都为1。同样有两种实现，基于数组的AQueue和链式LQueue的。难点在于基于数组的。为了保证pop()和push()的时间复杂度为1，要用到“循环存储”的思想。这个思想就是把一个固定长度数组看作是一个首尾相接的“圈”。这样，我们的“入队”push()和“出队”pop()操作，就可以直接向队尾加入一个元素或从队首取出一个元素。要在数组中，实现循环存储，需要用到一个小技巧：

例如，已知数组A长度为100，那么，当队尾为A[99]时，如果再执行一个push()操作（前提是，A[0]没有被队首元素占用），那么A[0]将成为新的队尾，怎么告诉计算机当队尾下标为99时，新加入的元素应该放在下标为0的地方而不是100呢？这里用到一个求余运算，可以解决“下标循环”的问题：

设数组长度为Len，队尾下标为rear，那么加入一个元素后，新的队尾下标为：

newRear = (rear+1)%Len

还有一点需要注意，因为队列是可以为空的，这个时候，队首与队尾的下标相等，那么当有一元素的时候，队尾下标指向那个元素的后面那个位置，这就是说，队尾下标所指的那个位置，是不存放元素的，所以数组的长度Len应比队列长度queSize大1。

链式队列很容易理解，我不多说了。

下面是我按照C＋＋标准库中queue的接口，自己写的代码：

/*
定义队列的共公接口
文件名：QueueInterface.h
*/
#ifndef QUEUEINTERFACK_H
#define QUEUEINTERFACK_H

#include "NodeInterface.h"
using namespace std;
namespace zyk
{


    template<class T> class Queue
    {
    public:
        //从今天开始,我决定采用STL的接口,
        //这样有利于我们熟悉标准库函数
        virtual T & back() = 0;        //返回队尾元素
        virtual T & front() = 0;    //返回队首元素
        virtual void pop() = 0;        //出队
        virtual void push(const T&) = 0;//进队
        virtual bool empty() = 0;    //返回值指示队列是否为空
        virtual int size() = 0;        //返回队中元素个数
    };

    //基于数组的队列AQueue
    template<class T> class AQueue : Queue<T>
    {
    private:
        int maxSize;    //队列的最大容量,由于采用循环存储的方式,
                //它比实际值大1,以保证队尾rear所指的位置,
                //是队尾元素的下一个位置
        int mfront;    //指示队首元素的在数组中的下标
        int mrear;    //队尾元素的在数组中的下标的下一个位置
        T * listArray;    //数组指针

    public:
        AQueue(int size = 100)
        {
            maxSize = size + 1;    //这一点很关键
            mfront = mrear = 0;
            listArray = new T[maxSize];
        }
        ~AQueue()
        {
            delete [] listArray;
        }

        T & back()
        {
            //当rear=0里,(rear-1)%maxSize将会成为负-1,而(mrear-1+maxSize)%maxSize可以解决这个问题
            return listArray[(mrear - 1 + maxSize)%maxSize];
        }

        T & front()
        {
            return listArray[mfront];
        }

        void pop()
        {
            mfront = (mfront+1)%maxSize;
        }
        void push(const T & item)
        {
            listArray[mrear] = item;
            mrear = (mrear+1)%maxSize;
        }
        bool empty()
        {
            if (mrear == mfront)
                return true;
            else return false;
        }
        int size()
        {
            return (mrear - mfront + maxSize)%maxSize;
        }

    };

    //链式队列
    template<class T> class LQueue : Queue<T>
    {
    private:
        int queSize;    //队元素的个数
        Node<T> * pfront;    //指向队首元素
        Node<T> * prear;    //指向队尾元素
    public:
        LQueue()
        {
            queSize = 0;
            pfront = prear = NULL;
        }
        ~LQueue()
        {
            while (pfront != NULL)
            {
                Node<T> * tmp;
                tmp = pfront;
                pfront = pfront->next;
                delete tmp;
            }
        }

        T & back()
        {
            return prear->element;
        }

        T & front()
        {
            return pfront->element;
        }

        void pop()
        {
            Node<T> * tmp;
            tmp = pfront;
            if (queSize == 1)    //只有一个元素.
            {
                prear = pfront->next;
            }
            pfront = pfront->next;
            delete tmp;
            --queSize;
        }
        void push(const T & item)
        {
            if (queSize == 0)    //第一个元素入栈,这时情况比较特殊
            {
                pfront = prear = new Node<T>(item);    //一同指向第一个元素
                ++queSize;
                return;
            }
            prear->next = new Node<T>(item);
            prear = prear->next;
            ++queSize;
        }
        bool empty()
        {
            if (queSize == 0)
                return true;
            else
                return false;
        }
        int size()
        {
            return queSize;
        }

    };
}

#endif

Technical Consultant 2006-10-04 03:24 发表评论

案例讨论：不规则树算法

Technical Consultant — Tue, 03 Oct 2006 10:54:00 GMT

案例讨论：不规则树算法

有如下的数据，parentid表示父节点id，totalchilren表示该节点有几个子节点，total表示数量

id filecode parentid total children total
1 ws112           0       3         0
2 01              1       1         2
3 02              1       1         2
4 03              1       1         2
5 0101            2       0         3
6 0201            3       0         3
7 0301            4       0         3

     我想输入ws112，得到如下的结果：
     0101 6（2*3）
     0201 6（2*3）
     0301 6（2*3）
     即不管01、02、03这些节点，直接得到ws112最低级的节点情况，请各位帮忙了。

讨论一：

create table A
(
   id int,
   filecode varchar(10),
   parentid int,
   totalchildren int,
   total int
)

insert A select 1,'ws112',0,3,0
insert A select 2,'01',1,1, 2
insert A select 3,'02',1,1, 2
insert A select 4,'03',1,1, 2
insert A select 5,'0101',2,0, 3
insert A select 6,'0201',3,0, 3
insert A select 7,'0301',4,0, 3

create Function Find_num(@Code varchar(10))
returns @A table(filecode varchar(10),num int)
as
begin
declare @T table(id int,filecode varchar(10),parentid int,totalchildren int,total int,lev int,num int)
declare @lev int
set @lev=1
insert @T select id,filecode,parentid,totalchildren,total,@lev as lev,@lev as num from A where filecode=@Code
while @@rowcount>0
begin
set @lev=@lev+1
insert @T select A1.id,A1.filecode,A1.parentid,A1.totalchildren,A1.total,@lev,A1.total*T.num from A A1, (select * from @T where lev=@lev-1) T where T.id=A1.parentid
end
insert @A select T.filecode,T.num from @T T where T.lev=(select top 1 lev from @T order by lev DESC )
return
end

select * from dbo.Find_num('ws112')

      点评：例子好像只能实现规则的树，应该说，这个例子是特例，其实你的树是一颗不规则的树，叶子的深度可能不一样.你想想实现的目标是：
      1、查找到任一节点的全部叶子；
      2、然后每一个叶子到目标节点之间的所有节点的total值相乘；
      0101 6（2*3）
       0201 6（2*3）
       0301 6（2*3）

      讨论二：

create table A
(
   id int,
   filecode varchar(10),
   parentid int,
   totalchildren int,
   total int
)

create function List_Leaf(@filecode varchar(10))
returns @LeafDetail table(filecode varchar(10),num int)
As
begin
declare @TempTable table(id int, filecode varchar(10),parentid int,totalchildren int,total int,lev int,num int)
declare @level int
set @level = 0
insert @TempTable select *,@level,1 from A where filecode = @filecode
while @@RowCount>0
begin
set @level = @level + 1
insert @TempTable select A.*,@level,A.total*(T.num) from @TempTable T,A where T.lev = @level-1 and A.parentid = T.id
end
insert @LeafDetail select filecode,num from @TempTable where totalchildren = 0
return
end

select * from List_Leaf('ws112')
go

测试结果：
filecode   num
---------- -----------
04         5
0101       6
0201       6
0301       6

（所影响的行数为 4 行）

点评：办法实现了需要的功能,不过,用了两个临时表,效率方面让人有点不满意.

讨论三：

create table filedir
(
   id int,
   filecode varchar(10),
   pid int,
   totalchildren int,
   total int
)
insert filedir select 1,'ws112',0,3,0
insert filedir select 2,'01',1,1, 2
insert filedir select 3,'02',1,1, 2
insert filedir select 4,'03',1,1, 2
insert filedir select 5,'0101',2,0, 3
insert filedir select 6,'0201',3,0, 3
insert filedir select 7,'0301',4,0, 3
insert filedir select 8,'0401',1,0, 2
go

--创建用户定义函数
create function f_getChild(@ID VARCHAR(10))
returns @t table(ID VARCHAR(10),PID VARCHAR(10),Level INT)
as
begin
    declare @i int,@ret varchar(8000)
    set @i = 1
    insert into @t select ID,pid,@i from filedir where pid = @ID

    while @@rowcount<>0
    begin
        set @i = @i + 1

        insert into @t
        select
            a.ID,a.PID,@i
        from
            filedir a,@t b
        where
            a.PID=b.ID and b.Level = @i-1
    end
    return
end
go

create   function f_getparenttotal(@id int,@topid int)
returns int
as
begin
declare   @pid   int
declare   @re    int
set @re=1
select   @pid=pid   from   filedir   where   id=@id
while    @pid>@topid
begin
select   @pid=pid,@re=@re*[total]   from   filedir   where   id=@pid
end
return @re
end
go

--执行查询,dbo.f_getparenttotal(id,1)和f_getChild(1)代表根节点id

select id,filecode,bb=dbo.f_getparenttotal(id,1)*total from filedir where id in( select ID from dbo.f_getChild(1) where id not in(select pid from filedir))

drop function f_getparenttotal
drop function f_getChild
drop table filedir

点评：此办法考虑到了功能的实现和执行的效率问题，但这是SQL Server2000的传统思维，下面介绍一下SQL Server 2005在这方面的应用：

--SQL Sever 2005 用(公共表表达式,实现递归方法)如下:

--测试环境
create table A
(
   id int,
   filecode varchar(10),
   parentid int,
   totalchildren int,
   total int
)
insert A select 1,'ws112',0,3,0
insert A select 2,'01',1,1, 2
insert A select 3,'02',1,1, 2
insert A select 4,'03',1,1, 2
insert A select 5,'0101',2,0, 3
insert A select 6,'0201',3,0, 3
insert A select 7,'0301',4,0, 3
insert A select 8,'04',1,0,5

--建递归CTE
DECLARE @FILECODE AS VARCHAR(20)
SET @FILECODE='ws112';
WITH ACTE(ID,FILECODE,PARENTID,TOTALCHILDREN,TOTAL,LVL)
AS
(
SELECT ID,FILECODE,PARENTID,TOTALCHILDREN,TOTAL,0
FROM A WHERE FILECODE=@FILECODE
UNION ALL
SELECT TA.ID,TA.FILECODE,TA.PARENTID,TA.TOTALCHILDREN,TA.TOTAL,TB.LVL+1
FROM A TA INNER JOIN ACTE TB
    ON TA.PARENTID=TB.ID
)
SELECT FILECODE,值=TOTAL*LVL FROM ACTE WHERE TOTALCHILDREN=0
--结果
/*
FILECODE   值
---------- -----------
04         5
0301       6
0201       6
0101       6

(4 行受影响)
*/
--删除环境 Drop table A

Technical Consultant 2006-10-03 18:54 发表评论

SQL与最短路径算法

Technical Consultant — Tue, 03 Oct 2006 10:40:00 GMT

SQL与最短路径算法

　　题目:空间有若干个点，每个点之间的联系都是随机的，现求任意一个点(设为A)到另一任意点(设为Z)之间间隔最少其他点的最佳算法(可用SQL数据库)

　　约束:在一个点中只可以直接找出和它有直接联系的点

　　用途:通过朋友列表以最快的速度认识一个认识的人(MM/GG)

　　比如5的好友列表中有1，30，3

　　7的好友列表中有9，5，8

　　10的好友列表中有7，21，30

　　11的好友列表中有7，5，30

　　21的好友列表中有7，30，66

　　30的好友列表中有21，88，99

　　如果5要和7交朋友，则可通过5-11-7。而5-30-21-7是较长的路径。

　　各位大虾有什么绝招能在SQL里实现这算法?

　　--如果全部建立双向关联，可以试试看下面的语句

declare @t table
(
id int,
f_id varchar(20)
)
insert into @t
select 5,'1,7,30,3' union all
select 7,'11,21,9,5,8' union all
select 11,'7,21,30' union all
select 21,'7,11,30,66' union all
select 30,'5,11,21,88,99'
--select * from @t
declare @start int
declare @end int
declare @node int
declare @count int
declare @result varchar(100)
set @count=0
set @start=5
set @end=11
set @result=''
declare @tmp table
(
id int,
f_id varchar(20),
step int
)
insert into @tmp select @start,'',@count
while @end not in (select id from @tmp)
begin
set @count=@count+1
insert into @tmp
select distinct a.id,a.f_id,@count from @t a,@tmp b where charindex(rtrim(b.id),a.f_id)>0 and a.id not in (select id from @tmp)
end
select @result=rtrim(@count)+':'+rtrim(@end)
while @count>1
begin
set @count=@count-1
select top 1 @end=id from @tmp where step=@count and charindex(rtrim(@end),f_id)>0
select @result=rtrim(@count)+':'+rtrim(@end)+'/'+@result
end
select @result='0:'+rtrim(@start)+'/'+@result
select @result

/*
0:5/1:7/2:11
*/
点评：上面的方法的缺点是不能列出所有的路径，只能列出最短路径其中一条

5的列表中没有7，是不是可以认为5不认识7，那么5也不认识11，谈何5-11-7是最短路径？

--按照你说的逻辑，步骤如下

--1.建立查询函数
CREATE FUNCTION dbo.F_RouteSearch
(
@START INT,
@END INT
)
RETURNS VARCHAR(200)
AS
BEGIN
DECLARE @NODE INT
DECLARE @COUNT INT
DECLARE @RESULT VARCHAR(100)
SET @COUNT=0
SET @RESULT=''
DECLARE @TMP TABLE
(
ID INT,
F_ID VARCHAR(20),
STEP INT
)
INSERT INTO @TMP SELECT @START,(SELECT F_ID FROM LIST WHERE ID=@START),@COUNT
WHILE @END NOT IN (SELECT ID FROM @TMP)
BEGIN
SET @COUNT=@COUNT+1
INSERT INTO @TMP
SELECT DISTINCT a.ID,a.F_ID,@COUNT FROM List a,@TMP b WHERE CHARINDEX(','+RTRIM(a.ID)+',',','+b.F_ID+',')>0 and a.ID not in (SELECT ID FROM @TMP)
IF @@ROWCOUNT=0
BEGIN
SELECT @RESULT='NO ROUTE FIND'
GOTO RETURNHANDLE
END
END
SELECT @RESULT=RTRIM(@COUNT)+':'+RTRIM(@END)
WHILE @COUNT>1
BEGIN
SET @COUNT=@COUNT-1
SELECT TOP 1 @END=ID FROM @TMP WHERE STEP=@COUNT AND CHARINDEX(','+RTRIM(@END)+',',','+F_ID+',')>0
SELECT @RESULT=RTRIM(@COUNT)+':'+RTRIM(@END)+'→'+@RESULT
END
SELECT @RESULT='0:'+RTRIM(@START)+'→'+@RESULT
RETURNHANDLE:
RETURN @RESULT
END
GO

--准备测试数据（与LZ提供数据相同）
insert into list
select 5,'1,30,3' union all
select 7,'9,5,8' union all
select 10,'7,21,30' union all
select 11,'7,5,30' union all
select 21,'7,66,30' union all
select 30,'21,88,99'
go
--测试

select dbo.F_RouteSearch(5,7) --从5开始，到7为止

--结果
/*
0:5→1:30→2:21→3:7
注解
5通过30，21最后找到7，耗费3步完成
5不认识11，因此LZ所说的路径5-11-7不成立
*/

--List表生成脚本

CREATE TABLE [List] (
[id] [int] NULL ,
[f_id] [varchar] (40) COLLATE Chinese_PRC_CI_AS NULL
) ON [PRIMARY]
GO

Technical Consultant 2006-10-03 18:40 发表评论