C++博客-Tauruser-随笔分类-算法与数据结构

双链表模版类的实现

Tauruser — Mon, 08 May 2006 04:47:00 GMT

在模版类加入curpt与curloc两个变量加速对链表的定位

#ifndef linklist_h_
#define linklist_h_
#include <iostream>
using namespace std;

template <class T> struct Element
{
    T content;
    Element* prelink; //predecesser link
    Element* suclink; //successor link
};

template <class T> class dLinkList
{
public:
    dLinkList();
    ~dLinkList();
    void insert(const T &x,int loc);
    void del(int loc);
    void modify(const T &x, int loc);
    bool IsEmpty();
    //void list();
    int search(const T &x,const int startloc );
    int getsum();
    T get(int loc);
private:
    void locate(const int loc);//curpt定位于loc
    Element<T>* head;//头指针
    Element<T>* rear;//尾指针
    Element<T>* curpt;//当前指针
    int curloc;//当前指针位置
    int sum;//链表元素总数

};

template <class T> dLinkList<T>::dLinkList()
{
    head=NULL;
    rear=NULL;
    curpt=NULL;
    curloc=0;
    sum=0;
}
template <class T> dLinkList<T>::~dLinkList()
{
    //如果堆栈非空，则不断del第一个元素直到为空
    while(!IsEmpty())
    {
        del(1);
    }
}
template <class T> void dLinkList<T>::locate(const int loc)
{
    if(loc<1 || loc>sum)
    {
        cout<<"locate error"<<endl;
    }else
    {
        int curlocdistance= (curloc-loc>0)?(curloc-loc):(loc-curloc); //当前位置与loc点距离
        int rearlocdistance = sum-loc;//loc位置与表尾距离

        //令curpt指向位置loc的节点
        if( (loc-1<curlocdistance))//loc距离表头最近　｛(loc-1)为loc与表头的距离｝
        {
            curpt=head;
            for(int i=0; i<loc-1;i++)
                curpt=curpt->suclink;
        }else if( rearlocdistance<loc-1 && rearlocdistance < curlocdistance)//loc距离表尾最近
        {
            curpt=rear;
            for(int i=0;i<rearlocdistance;i++)
                curpt=curpt->prelink;
        }else if(curloc-loc>0)//loc在curloc前面
        {
            for(int i=0;i<curlocdistance;i++)
                curpt=curpt->prelink;
        }else//loc在curloc后面
        {
            for(int i=0;i<curlocdistance;i++)
                curpt=curpt->suclink;
        }
        curloc=loc;
    }
    return;
}
template <class T> void dLinkList<T>::insert(const T &x,int loc)
{
    if( (loc<1) || (loc>sum+1))
    {
        cout<<"loc is out of range."<<endl;
        return;
    }

    Element<T>* temp=new Element<T>;
    temp->content=x;

    if (sum==0)
    {
        temp->prelink=NULL;
        temp->suclink=NULL;
        head=temp;
        rear=temp;

    }else if(loc==sum+1)
    {
        rear->suclink=temp;
        temp->suclink=NULL;
        temp->prelink=rear;
        rear=temp;
    }else if(loc==1)
    {
        temp->prelink=NULL;
        head->prelink=temp;
        temp->suclink=head;
        head=temp;

    }else
    {
        locate(loc);//调用私用成员函数定位

        //完成链接元素重新链接
        temp->prelink=curpt->prelink;
        curpt->prelink=temp;
        temp->suclink=curpt;
        temp->prelink->suclink=temp;
        //令curpt指向当前插入元素。
    }
    sum++;
    curpt=temp;
    curloc=loc;
    return;
}
template <class T> void dLinkList<T>::del(int loc)
{
    if(loc<1 || loc>sum)
    {
        cout<<"del location error"<<endl;
        return;
    }
    if(sum=1)
    {
        delete head;
        head=NULL;
        rear=NULL;
        curpt=NULL;
        curloc=0;
        sum--;

    }else if(loc==1)
    {
        curpt=head;
        head=head->suclink;
        head->prelink=NULL;
        delete curpt;
        curpt=head;
        curloc=1;
        sum--;
    }else if(loc==sum)
    {
        curpt=rear;
        rear=rear->prelink;
        rear->suclink=NULL;
        delete curpt;
        curpt=rear;
        curloc=sum-1;
        sum--;
    }else
    {
        locate(loc);
        curpt->prelink->suclink=curpt->suclink;
        curpt->suclink->prelink=curpt->prelink;
        curpt=curpt->suclink;
        curloc=loc;
        sum--;
    }
    return;
}

template <class T> void dLinkList<T>::modify(const T &x,int loc)
{
    if(loc<1 || loc>sum)
    {
        cout<<"modify location error"<<endl;
        return;
    }
    locate(loc);
    curpt->content=x;
}

template <class T> bool dLinkList<T>::IsEmpty()
{
    return (!sum);
}
template <class T> T dLinkList<T>::get(int loc)
{
    if(loc<1 || loc>sum)
    {
        cout<<"get location error"<<endl;
        return NULL;
    }
    locate(loc);
    return curpt->content;
}

template <class T> int dLinkList<T>::search(const T &x,const int startloc=1)
{
    if(startloc<1 || startloc>sum)
    {
        cout<<"search start location error"<<endl;
        return;
    }
    locate(startloc);
    while(curpt->content!=x)
    {
        if(curpt->suclink==NULL)
        {
            return 0;
        }
        curpt=curpt->suclink;
        curloc++;
    }
    return curloc;
}
template <class T> int dLinkList<T>::getsum()
{
    return sum;
}

#endif

Tauruser 2006-05-08 12:47 发表评论

C风格字符串与标准库string类型性能对比

Tauruser — Mon, 01 May 2006 15:58:00 GMT

　　今天在看c++ primer书中挺到C风格字符串与标准库string类型的效率问题。推荐使用string类型，不但因为其更安全，且因其效率更高。最后有提到一个数据。
　　“平均来说，使用string类型的程序执行速度要比用C风格字符串的快很多，在我们用了五年的PC机上其平均执行速度分别是：
　　user 0.47 #string class
user 2.55 #C-style haracter string”
　　对这个数据表示相当的惊讶。于是自已写了个程序，测试一下两个类型的效率。

#include <iostream>
#include <string>
#include <ctime>
using namespace std;
const size_t retime=1000000;
int main()
{
    clock_t start, finish;
    start=clock();
    const char *pc="a very long literal string";
    const size_t len = strlen(pc);
    for(size_t ix=0; ix!=retime;++ix)
    {
        char *pc2= new char[len+1];
        strcpy(pc2,pc);
        if(strcmp(pc2,pc))
          ;
        delete []pc2;
    }
    finish=clock();
    cout<<"C-style string run "<<retime<<" times needs "<<finish-start<<" clock times";
    cout<<endl;

    start=clock();
    string str("a very long literal string");
    for(size_t ix=0;ix!=retime;++ix)
    {
        string str2=str;
        if(str!=str2)
          ;
    }
    finish=clock();
    cout<<"C++ string run "<<retime<<" times needs "<<finish-start<<" clocks";
    cout<<endl;
    return ０;

}

　　上述程序在CentOS下编译并运行测试得数据平均在：
C-style string run 1000000 times needs 240000 clock times
C++ string run 1000000 times needs 110000clocks
在这个数据下明显string的效率要高。
　　而在windows下使用vc6.0 release编译并运行，数据平均在：
C-style string run 1000000 times needs 350 clock times
C++ string run 1000000 times needs 350 clocks
　　两种类型的效率差不多
　　继续在vs2005下release编译，数据平均在：
C-style string run 1000000 times needs 320 clock times
C++ string run 1000000 times needs 370 clocks
　　string效率要低一个。
在Linux平台下，string的效率比C-style的要整整高出一倍有多。
而在windows平台下，sting不但效率上的优势没有了，反而比C-style还要差。
不知道这是什么原因。为什么在unix下要比在windows下快如此的多。而在windows上却不行？
快的原因在哪呢？
PS:
不知道我的测试程序这样子写是否可以。

Tauruser 2006-05-01 23:58 发表评论

算法与数据结构实验(二)

Tauruser — Wed, 22 Mar 2006 04:18:00 GMT

摘要: 数组空间组织与链表空间组织的堆栈实现为了增强实现的堆栈通用性，用堆栈实现进行模板化。代码如下： /**/ //////////// //stack.h /////////////// / ////////////////////////////... 阅读全文

Tauruser 2006-03-22 12:18 发表评论

为什么在VS2005重载输出运算符那么难？

Tauruser — Tue, 14 Mar 2006 15:48:00 GMT

　　最近在VS2005下实现一个模版堆栈时，想重载一下输出运算符。结果老是遇到问题，如何都过不去，想不想去都不明白。还望高手指教。
　　一开始同样的程序在VC2005和VC6.0下编译都没问题，但是一到链接的时候就出现问题了。都提示如下错误：

error LNK2019: 无法解析的外部符号 "class std::basic_ostream > & __cdecl operator<<(class std::basic_ostream > &,class SegStack const &)" (??6@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@std@@AAV01@ABV?$SegStack@H@@@Z)，该符号在函数 _main 中被引用

　　死活都运行不了。后来发现如果在程序中不使用“cout<<”重载的运算符进行输出，在两个平台下都没有问题。可以重载的方式我已经全部按语法写了。
　　今晚，又在VC6.0下再生成一次，奇迹般成功了。（PS:难道今晚的RP比较高　^-^）但是还是没有解决在VC2005下的问题，还是提示如上错误，VC2005到底还改了什么，与VC6.0不同了？一模一样的程序，为什么在VC2005下都不行，在VC2005下的重载输入输出应该如何应该如何？
下面贴一下例程，麻烦有时候的大牛帮我看一下，很简单的一个程序。
Ex2_2.rar
里面有三个文件分别如下：(ex2_2.cpp,stack.cpp,stack.h)下面贴一下文件的内容。

//////////ex2_2.cpp///////////
//////////////////////////////
#include "stack.cpp"

SegStack<int> iStack(10);
int main()
{
    for(int i(0);i<10;i++)
        iStack.push(i);

    cout<<iStack;
    iStack.output(cout);
    for(i=0;i<5;i++)
        iStack.pop();
    cout<<iStack;

    return 0;

}

///////////stack.h//////////
///////////////////////////////
#ifndef stack_h_
#define stack_h_
#include <iostream>
using namespace std;

template <class T> class stack
{
public:
    virtual void push(const T &x)=0;
    virtual void pop()=0;
    virtual T Top() const = 0;
    virtual bool IsEmpty() const =0;
    virtual bool IsFull() const=0;

};

template <class T> class SegStack: public stack<T>
{
public:
    SegStack(int mSize);
    ~SegStack();
    bool IsEmpty() const;
    bool IsFull() const;
    void push(const T &x);
    void pop();
    T Top() const;
    friend ostream& operator << (ostream& out,const SegStack<T>& seg);
    void output(ostream& out) const;

private:
    T *s;
    int maxSize;
    int top;
};

#endif

////////////stack.cpp////////////
///////////////////////////////////
#include "stack.h"

template <class T> SegStack<T>::SegStack(int mSize):top(-1)
{
    maxSize=mSize;
    s = new T[maxSize];

}
template <class T> SegStack<T>::~SegStack()
{
    delete []s;
}

template <class T> bool SegStack<T>::IsFull() const
{
    return (top==(maxSize-1));
}

template <class T> bool SegStack<T>::IsEmpty() const
{
    return (top==-1);
}

template <class T> void SegStack<T>::push(const T &x)
{
    if(IsFull())
    {
        cout<<"The stack is full"<<endl;
    }else
    {
        s[++top]=x;
    }
}

template <class T> void SegStack<T>::pop()
{
    if(IsEmpty())
    {
        cout<<"The stack is empty"<<endl;
    }else
    {
        top--;
    }
}
template <class T> T SegStack<T>::Top() const
{
    return s[top];
}

template <class T> void SegStack<T>::output(ostream& out) const
{
    out<<"The stack list is:";
    for(int i(0);i<=top;i++)
        out<<" "<<s[i];
    out<<endl;
}

template <class T> ostream& operator << (ostream& out,const SegStack<T>& seg)
{
    out<<"The stack list is:";
    for(int i(0);i<=seg.top;i++)
        out<<" "<<seg.s[i];
    out<<endl;
    //seg.output(out);
    return out;
}

　　在最后，我还想问的一个问题是：为什么在ex2_2.cpp里#include "stack.h"时会无法编译通过，而#include "stack.cpp"时就可以了呢？
　　记得我刚学Ｃ＋＋的时候，老师跟我说把头文件和源程序文件分开，最主要的是要进行知识产权保护，当你写好一个子程序时，发布就不要给对方源程序，只要给对方头文件和编译过来的相应obj文件就可以了。但是从上面的例子上看来，如果不#include "stack.cpp"就无法编译通过，这不就代表一定要给源程序对方吗？为什么会这样子的。我应该如何做呢？如果我想实现源程序的保存。

Tauruser 2006-03-14 23:48 发表评论

我的算法与数据结构学习(三)

Tauruser — Tue, 07 Mar 2006 15:26:00 GMT

线性结构之典型——堆栈

　　正如前面所说，同样的逻辑结构，在上面赋予的操作不同，就是不同的数据结构。一个数据结构要同时包含这两方面的内容。
　　作为线性结构的典型——堆栈，堆栈首先就是一个线性结构，但是对这个线性结构上进行的操作进行一定的限制，就成为了堆栈。堆栈只能在表的一端进行插入和删除。摘下《The Art of Computer Progrmming》上对典型的三种线性结构的操作描述。

A stack is a linear list for which all insertions and deletions (and usually all accesses) are made at one end of the list.(堆栈）
A queue is a linear list for which all insertions are made at one end of the list; all deletions (and usually all accesses) are made at the other end.（队列）
A deque ("double-ended queue") is a linear list for which all insertions and deletions (and usually all accesses) are made at the ends of the list.（这种在中文教材里没看到，我暂且叫它为两头蛇 ^ ^）

　　堆栈的存储结构实现和前面说的一样，可以用数组方式，目录表，或链表方式实现。具体的实现和操作的实现同样会在实验中提到，这里就不再重复。

　　再谈一下，堆栈在实现应用当中的使用。
　　实例，对子程序的调用及返回的处理。调用子程序时，将其断点依次压入堆栈，返回时再依次弹出。如递归的调用。
　　另外一个实例就是实现“＋－×÷”四功能的计算器程序。

这里就先介绍两个基本概念，以后再另行补上实现程序。

中缀表达式：运算符放在两个运算对象之间，称为中缀表达式。计算时先算括号内，再算括号外，多层括号从内层向外层算。无括号或同层括号内由左向右顺序执行。
后缀表达式：不再引入括号，运算符放在两个操作对象后面，称为后缀表达式。计算时所有运算按运算符出现的顺序，严格从左向右，每个运算符取其前面两个操作数，运算后的结果仍为下次的操作数，这样做与中缀表达式计算严格等价，即计算次序和结果完全相同。下面罗列几个等价的中缀表达式和后缀表达式：
中缀表达式，后缀表达式
A                     A
A+B　　　　AB+
A+B*C           ABC*+
A*(B-C)+D    ABC-*D+
D+A/(B-C)     DABC-/+

That's all for today. THX.

Tauruser 2006-03-07 23:26 发表评论

Josephus问题

Tauruser — Sun, 05 Mar 2006 06:52:00 GMT

摘一下题目：
　　试用递归和非递归的方法编写程序解决Josephus问题：设有n个人围坐一个圆桌周围，，现从第S人开始报数，数到第m的人出列，然后从出列的下一个重新开始报数，数列的第m个人又出列……如此重复，直到所有的人全部出列为止。对任意给定的n、s、m，求按出列次序得到的n个人员的顺序表。

使用两种方法：
　　方法１：用整数i来代替pi，将初始序列看成一个整数序列存储在向量p中，pi出列，将p[i+1]，……，p[n]前移一个元素，将pi放入p[n]中，最后出列放在p[1]中，再作逆序。
　　方法２：每出列一个元素存入另一个向量中，不移位，设置标志，全部出列后，打印出出列顺序表。

详细解决办法请点下面的链接。
      Josephus问题非递归方法１解决办法
      Josephus问题递归方法１解决办法
      Josephus问题非递归方法２解决办法
       Josephus问题递归方法２解决办法

Tauruser 2006-03-05 14:52 发表评论

算法与数据结构实验(一)

Tauruser — Sat, 04 Mar 2006 05:14:00 GMT

题目：
１、试编写在数组中插入一个元素和删除一个元素的函数，并调用此函数作一个整型数组的插入和删除，要求整形数组开始含有１０个元素，插入的位置可在任意两个数组元素之间、第一个元素前和最后一个元素后，删除任意指定位置的元素，并将各元素的位置及相应的元素值打印出来。

正如《我的算法与数据结构学习(二) 》中谈到，在顺序存储中，插入与删除操作的实现其关键在于对顺序存储空间的管理。作为顺序存储，较为典型的是在数组中进行。当进行插入和删除操作时，都要涉及到各个数组元素的移位，移位的顺序是关键的，一不小心搞错了移位的顺序就可能导致数组元素内容的丢失。

1#include <iostream>
2using namespace std;
3int a[20];
4int count;
5int choice;
6bool Exit(0);
7void insert(int *line);
8void del(int *line);
9void display(int *line);
10
11
12int _tmain(int argc, _TCHAR* argv[])
13{
14    for(int i(0);i<10;i++)
15        a[i]=i;
16    count=10;
17    while(!Exit)
18    {
19        cout<<"1.insert a num"<<endl;
20        cout<<"2.delete a num"<<endl;
21        cout<<"3.dispaly the list"<<endl;
22        cout<<"0.exit"<<endl;
23        cout<<"please input your choice:";
24        cin>>choice;
25        if(choice==1)
26        {
27            insert(a);
28        }
29        else if(choice ==2)
30        {
31            del(a);
32        }
33        else if(choice==3)
34        {
35            display(a);
36        }
37        else if(choice==0)
38        {
39            Exit=true;
40        }
41    }
42    cout<<"Power by Tauruser";
43    return 0;
44
45}
46
47void insert(int *line)
48{
49    int loc,num;
50    cout<<"where you would like to insert:";
51    cin>>loc;
52    if(loc<1 || loc>count+1)
53    {
54        cout<<"data overflow";
55        return;
56    }
57    cout<<"what num you would like to insert:";
58    cin>>num;
59    for(int i=count;i>loc-1;i--)
60    {
61        line[i]=line[i-1];
62    }
63    count++;
64    line[loc-1]=num;
65}
66
67void del(int *line)
68{
69    int loc;
70    cout<<"which num you would like to delete:";
71    cin>>loc;
72    if(loc<1 || loc>count)
73    {
74        cout<<"data overflow";
75        return;
76    }
77    for(int i=loc-1;i<count-1;i++)
78    {
79        line[i]=line[i+1];
80    }
81    count--;
82}
83
84void display(int *line)
85{
86    for(int i(0);i<count;i++)
87    {
88        cout<<"No."<<i+1<<" num is "<<line[i]<<endl;
89    }
90}
91

从insert()与del()两个函数来看，在数组里进行移位的顺序刚才相反。插入从后到前，删除从前到后。这样的顺序确保了，元素值不会给覆盖丢失。其实如果再提供一个temp的变量，也可以实现移动顺序的改变。但就要再引入一个变量了。

PS:另外说一点，有同学问我为什么在VS.net平台里老是没有办法#include 。我想可能VS.net已经在C++中放弃支持这个了。可以换成

#include <iostream>
using namespace std;

使用ISO C++的库就行了。不知道我的见解是否正确。

Tauruser 2006-03-04 13:14 发表评论

我的算法与数据结构学习(二)

Tauruser — Fri, 03 Mar 2006 09:20:00 GMT

简单的数据结构

　　几何上的学习从点，到线，到面。而在数据结构上，就从最简单的线性结构开始。

２、１线性结构　从逻辑上来看是线性关系
　　　每一个节点都有一个唯一的前驱也后继，节点之间有先后的之分。
一些对应的中英文：
　　　linear list 线性表 predecesser 直接前驱　successor 直接后继

基本概念有：
①结点
②典型的存储方式：顺序存储即物理与逻辑顺序一致
③基本运算
　⑴取
　⑵修改
　⑶插入
　⑷删除
　⑸排序
　⑹查找
　⑺测试
其中⑶⑷主要涉及空间的重新组织，⑸⑹主要涉及时间复杂度问题。

关于插入与删除的算法，将在数据结构的实验中谈到。

④算法复杂度估计（关键在于计算基本运算进行的次数）

算法复杂度估计基于假设：插入和删除的位置是随机的。即任意位置上发生的可能性一致。
通过概率与统计学的知识，可以求出基本运算的平均运行次数。这就是算法复杂度的计算。
一般情况，都可以把一些循环语句中的语句作为基本运算。（我自己的见解）

数组方式实现的线性表有不足，可通过用目录表的形式加以克服。

将结点的序号存储在顺序表中，而结点的内容则可用各种方式随机存储，既可解决存储空间的分散性问题，也可以实现快速查找。

Tauruser 2006-03-03 17:20 发表评论

我的算法与数据结构学习(一)

Tauruser — Fri, 03 Mar 2006 08:48:00 GMT

　　已经进入了第二个星期的大二第二个学期的课程，这个学期的主要课程之一就是《算法与数据结构》。从我大学以来的学习当中，还没有学习数据结构这门课程，对于数据结构的重要性，我已经有所了解。所以我想尽我最大的能力学好这门课程。在学习中，我就将我学习过程中的一些经历写写。权当是对这门课程的总结，也当是对这门课程的加深理解吧！
　　
　　算法与数据结构在程序设计中的份量是不言而喻的。

数据结构主要包括三方面的内容：逻辑结构、存储结构、有关操作。逻辑结构与存储结构的转化。同样一种逻辑结构和存储结构，如果在它们上面赋予不同的操作，它们也是不同的数据结构。就如队列，堆栈之间的差别。

逻辑结构包括有线性结构和非线性结构。而非线结构又可分为树、图、网几种

存储结构有：⑴顺序方法　⑵链接方法　⑶索引方法　⑷散列方法

算法表示形式有：⑴自然语言表示法　⑵伪代码方法　⑶流程图　⑷结构化流程图　⑸PAD图

Tauruser 2006-03-03 16:48 发表评论