C++博客-blacktusk--期待收获的季节-文章分类-数据结构

闭散列法组织的散列表

heidaizx — Sun, 02 Dec 2007 06:58:00 GMT

---------------hashing .h-------------------

#include<iostream>
#include<stdlib.h>
using namespace std;
const int DefaultSize=100;
enum KindOfStatus{Active,Empty,Deleted};  //元素分类(活动/空/删)
template<class E,class K>
class HashTable
{
public:

    HashTable(const int d,int sz=DefaultSize);
    ~HashTable(){delete []ht;delete []info;}
    bool Insert(const E &e1);  //在散列表中插入e1
    bool Remove(const K k1); //在散列表中删除
    E Search(const K k1,E& e1)const;//在散列表搜索k1
    void makeEmpty();       //置散列表为空
private:
    int divitor;          //散列表的除数
    int CurrentSize,TableSize;  //当前桶数及最大桶数
    E *ht;                     //散列表存储数组
    KindOfStatus *info;        //状态数组
    int FindPos(const K k1)const; //散列函数,计算初始桶号

};

---------------hashing.cpp----------------------------

#include"hashing.h"
template<class E,class K>
HashTable<E,K>::HashTable(const int d,int sz)
{
    divitor=d;
    TableSize=sz;
    CurrentSize=0;
    ht=new E[TableSize];
    info=new KindOfStatus[TableSize];
    for(int i=0;i<TableSize;i++)
        info[i]=Empty;
};

template<class E,class K>
int HashTable<E,K>::FindPos(const K k1)const
{
    int i=k1%divitor;//计算初始桶号
    int j=i;       //检测下一空桶下标
    do
    {
        if(info[j]==Empty||info[j]==Active&&ht[j]==k1)    return j;   //找到
        j=(j+1)%TableSize;            //当做循环表处理，找下一个空桶
    }while(j!=i);
    return j;
};

template<class E,class K>
bool HashTable<E,K>::Insert(const E& e1)
{
    K k1=e1;       //重载函数::抽取函数
    int i=FindPos(k1); //用散列函数计算桶号
    if(info[i]!=Active)
    {
        ht[i]=e1;
        info[i]=Active;
        CurrentSize++;
        return true;
    }
    if(info[i]==Active&&ht[i]==e1)
    {
        cout<<"表中已有元素,不能插入!"<<endl;
        return false;
    }
    cout<<"表已满,不能插入数据!";
    return false;
};

template<class E,class K>
bool HashTable<E,K>::Remove(const K k1)
{
    int i=FindPos(k1);
    if(info[i]==Active)
    {
        info[i]=Deleted;
        CurrentSize--;
        return true;
    }
    else return false;
};

template<class E,class K>
E HashTable<E,K>::Search(const K k1,E& e1)const
{
    int i=FindPos(k1);
    if(info[i]!=Active||ht[i]!=k1) return false;
    e1=ht[i];
    return e1;
};

template<class E,class K>
void HashTable<E,K>::makeEmpty()
{
    for(int i=0;i<TableSize;i++)
        info[i]=Empty;
    CurrentSize=0;
};

---------------main.cpp--------------------------

#include"hashing.cpp"
int menu()
{
   int choice;

   cout<<"               *************散列函数的基本操作************"<   cout<<"                         在散列表插入元素，请按1"<   cout<<"                         逻辑删除散列表元素，请按2"<   cout<<"                         在散列表中搜索关键码的值，请按3"<   cout<<"                         退出，请按4"<   cout<<"               *****************************************"<
   cout<<"                          请选择:";
   cin>>choice;
   return choice;
}

int main()
{
   HashTable hash(2,10);
   bool exit=false;
   while(true)
   {
       int choice=menu();
       switch(choice)
       {
       case 1:
           int s;
           cout<<"                   请输入要插入值关键码:";
           cin>>s;
           cout<<"                   "<       case 2:
           int c;
           cout<<"                   请输入要输出值关键码:";
           cin>>c;
           cout<<"                   "<       case 3:
           int y;
           cout<<"                   请输入要查询值的关键码:";
           cin>>y;
           int z;
           cout<<"                   "<       case 4:
           exit=true;break;

        }
        system("pause");
        system("cls");

        if(exit==true)
            break;
    }
    return 0;
}

heidaizx 2007-12-02 14:58 发表评论

二叉树的简单操作

heidaizx — Sun, 02 Dec 2007 06:54:00 GMT

--------------------BinaryTree.h-------------------------------

#include<iostream>
#include<stdlib.h>
using namespace std;
template<class T>
struct BinTreeNode
{
    T data;
    BinTreeNode<T> *leftChild,*rightChild;  //左右孩子指针
    BinTreeNode():leftChild(NULL),rightChild(NULL){}
    BinTreeNode(T x,BinTreeNode<T> *l=NULL,BinTreeNode<T> *r=NULL):data(x),leftChild(l),rightChild(r){}
};

template<class T>
class BinaryTree
{
public:

//    BinaryTree():root(NULL){}
    BinaryTree():root(NULL){CreateBinTree(root);}
    void PreOrder(){PreOrder(root);}    //前序遍历
    void inOrder(){inOrder(root);}    //中序遍历
    void postOrder(){postOrder(root);}    //后序遍历


protected:
    BinTreeNode<T> *root;                 //二叉树的根结点指针
//    void Print(BinTreeNode<T> *p);       //输出二叉树每个结点的值
    void CreateBinTree(BinTreeNode<T> *&subTree);//利用二叉树前序遍历生成二叉树
    void PreOrder(BinTreeNode<T> *&subTree);
    void inOrder(BinTreeNode<T> *&subTree);
    void postOrder(BinTreeNode<T> *&subTree);
};

template<class T>
void BinaryTree<T>::CreateBinTree(BinTreeNode<T> *&subTree)
{
    char value;
    cin>>value;
    if(value=='#') subTree=NULL;
    else
    {
        subTree=new BinTreeNode<T>(value);
        if(subTree==NULL)
        {
            cerr<<"内存分配错误!";
            exit(1);
        }

        CreateBinTree(subTree->leftChild);
        CreateBinTree(subTree->rightChild);
    }

};

template<class T>
void BinaryTree<T>::PreOrder(BinTreeNode<T> *&subTree)
{
    if(subTree!=NULL)
    {
        cout<<subTree->data<<" ";
        PreOrder(subTree->leftChild);
        PreOrder(subTree->rightChild);
    }
};

template<class T>
void BinaryTree<T>::inOrder(BinTreeNode<T> *&subTree)
{
    if(subTree!=NULL)
    {

        inOrder(subTree->leftChild);
        cout<<subTree->data<<" ";
        inOrder(subTree->rightChild);
    }
};

template<class T>
void BinaryTree<T>::postOrder(BinTreeNode<T> *&subTree)
{
    if(subTree!=NULL)
    {

        postOrder(subTree->leftChild);
        postOrder(subTree->rightChild);
        cout<<subTree->data<<" ";
    }
};

--------------------------main.cpp----------------------------------

#include"BinaryTree.h"

int menu()
{
    int choice=0;
    cout<<"               ****************二叉树练习******************"<<endl<<endl;

    cout<<"                          前序遍历输出二叉树，请按1:"<<endl;
    cout<<"                          中序遍历输出二叉树，请按2:"<<endl;
    cout<<"                          后序遍历输出二叉树，请按3:"<<endl;
    cout<<"                          退出请按4:"<<endl<<endl;
    cout<<"               ********************************************"<<endl<<endl;
    cout<<"               Please enter the number:";
    cin>>choice;
    return choice;
}
int main()
{
    cout<<"前序遍历建立二叉树:"<<endl;
    BinaryTree<char> tree;

    bool exit=false;

    while(true)
    {
        int choice=menu();

        switch(choice)
        {
            case 1:
                tree.PreOrder();break;
            case 2:
                tree.inOrder();break;
            case 3:
                tree.postOrder();;break;

            case 4:exit=true;break;
            default:cout<<"           您的输入有误，请重新输入!";break;

        }
        system("pause");             //暂停
        system("cls");               //清屏
        if(exit==true) break;
    }
    return 0;
}

heidaizx 2007-12-02 14:54 发表评论

Josephus的链表实现

heidaizx — Sun, 18 Nov 2007 06:42:00 GMT

-----------------------------Josephus.h---------------------------------------------

#include<iostream>
#include<stdlib.h>
using namespace std;

template<class T>
struct CircLinkNode
{
    T data;
    CircLinkNode<T> *link;
    CircLinkNode(CircLinkNode<T> *next=NULL):link(next){}
    CircLinkNode(T d,CircLinkNode<T>*next=NULL):data(d),link(next){}
};

template<class T>
class CircList
{
public:

    CircList(){first=new CircLinkNode<T>(1),first->link=first;}//定义为循环链表
    ~CircList(){}
    CircLinkNode<T> *getHead()const{return first;}
    CircLinkNode<T> *Locate(int &i);
    bool Insert(int &i);
private:
    CircLinkNode<T> *first;
};

template<class T>
CircLinkNode<T> *CircList<T>::Locate(int &i)
{
    if(i<0) return NULL;
    CircLinkNode<T> *current=first;
    int k=2;
    while(current!=NULL&&k<i)
    {
        current=current->link;
        k++;
    }
    return current;
};

template<class T>
bool CircList<T>::Insert(int &i)
{
    CircLinkNode<T> *current=Locate(i);
    if(current==NULL) return false;
    CircLinkNode<T> *newNode=new CircLinkNode<T>(i);
    if(newNode==NULL)
    {
        cerr<<"存储分配错误!"<<endl;
        exit(1);
    }
    newNode->link=first;
    current->link=newNode;

    return true;
};

-------------------------------main.cpp-----------------------------------

#include"CircList.h"
template<class T>
void Josephus(CircList<T>&Js ,int n,int m)
{
    CircLinkNode<T> *p=Js.getHead(),*pre=NULL;
    int i,j;
    for(i=0;i<n-1;i++)
    {
        for(j=1;j<m;j++)
        {
            pre=p;
            p=p->link;
        }
        cout<<"出列的人是"<<p->data<<endl;
        pre->link=p->link;
        delete p;
        p=pre->link;
    }
};

int main()
{
    CircList<int> clist;

    int i,n,m;
    cout<<"输入游戏人数和报数者间隔: ";
    cin>>n>>m;
    for(i=2;i<=n;i++)
        clist.Insert(i);
    Josephus(clist,n,m);
    return 0;
}

刚学数据结构就应该实现的程序，呵呵，到现在才去做.

下面是以前没学数据结构之前所写的代码

#include<iostream>
using namespace std;
int main()
{
    int count=0;
    int s=0;//记录退出的人的个数
    int i;
    int N;
    int key;
    int a[100];
    cout<<"游戏人数和数字分别是:";
    cin>>N>>key;
    for(i=0;i<N;i++)
        a[i]=i+1;
    for(i=0;i<N;i++)
    {
        if(a[i]==-1)
        {
            if(i==N-1)//防止continue使循环退出
                i=-1;
            continue;
        }
        count++;

        if(count==key)
        {
            a[i]=-1;
            s++;
            count=0;
        }
        if(i==N-1)
            i=-1;
        if(s==N-1)
            break;

    }
    cout<<"留下的人是:";
    for(i=0;i<N;i++)
        if(a[i]!=-1)
            cout<<a[i];
    cout<<endl;

    return 0;
}

heidaizx 2007-11-18 14:42 发表评论

队列实现杨辉三角形算法（非金字塔形）待改进

heidaizx — Sun, 28 Oct 2007 07:28:00 GMT

#include"LinkedQueue.h"
void YANGVI(int n)
{
    LinkedQueue<int> q;
    int k;
    int i=1,j,s=k=0,t,u;         //计算下一行系数时用到的工作单元
    q.EnQueue(i);q.EnQueue(i);   //预先放入第一行的两个系数
    for(i=1;i<=n;i++)
    {
        cout<<endl;              //换行
        q.EnQueue(k);             //各行间插入一个0
        for(j=1;j<=i+2;j++)      //处理第i行的i+2个系数(包括一个0)
        {
            q.DeQueue(t);        //读取一个系数
            u=s+t;              //计算下一行的系数
            q.EnQueue(u);        //进队列
            s=t;                //每次记录刚才出队列的值，便于与下次出队列的值相加
            if(j!=2+i) cout<<s<<' ';//打印一个系数，第i+2个是0
        }
    }
}

heidaizx 2007-10-28 15:28 发表评论

循环队列的链表表示

heidaizx — Sun, 28 Oct 2007 03:39:00 GMT

#include"LinkedList.h"
#include"Queue.h"
template<class T>
class LinkedQueue
{
public:
    LinkedQueue():rear(NULL),front(NULL){}
    ~LinkedQueue(){makeEmpty();}
    bool EnQueue(const T& x);
    bool DeQueue(T& x);
    bool getFront(T& x)const;
    void makeEmpty();
    bool IsEmpty()const{return(front==rear)?true:false;}
    int getSize()const;
//    bool IsFull()const{return((rear+1)%maxSize==front)?true:false;}
    friend ostream& operator<<(ostream& os,LinkedQueue<T>& Q);
protected:
    LinkNode<T> *front, *rear;
};

template<class T>
void LinkedQueue<T>::makeEmpty()
{
    LinkNode<T> *p;
    while(front!=NULL)
    {
        p=front;
        front=front->link;
        delete p;
    }
};

template<class T>
bool LinkedQueue<T>::EnQueue(const T& x)
{
    if(front==NULL)
    {
        front=rear=new LinkNode<T>(x);//空队列时，新结点成为队列的第一个结点，既是对头也是队尾
        if(front==NULL) return false;
    }
    else
    {
        rear->link=new LinkNode<T>(x);//非空时在链尾追加新的结点并更新队尾指针
        if(rear->link==NULL) return false;
        rear=rear->link;
    }
    return true;
};

template<class T>
bool LinkedQueue<T>::DeQueue(T& x)
{
    if(IsEmpty()==true) return false;
    LinkNode<T> *p=front;
    x=front->data;
    front=front->link;
    delete p;
    return true;
};

template<class T>
bool LinkedQueue<T>::getFront(T& x)const
{
    if(IsEmpty()==true) return false;
    x=front->data;
    return true;
};

template<class T>
int LinkedQueue<T>::getSize()const
{
    LinkNode<T> *p=front;
    int k=0;
    while(p!=NULL)
    {
        p=p->link;
        k++;
    }
    return k;
};

template<class T>
ostream& operator<<(ostream& os,LinkedQueue<T>& Q)
{
    os<<"队列中的元素个数有"<<Q.getSize()<<endl;
    LinkNode<T> *p=Q.front;
    int i=0;
    while(p!=NULL)
    {
        os<<++i<<":"<<p->data<<endl;
        p=p->link;
    }
    return os;
}

heidaizx 2007-10-28 11:39 发表评论

循环队列的数组表示函数的实现

heidaizx — Sun, 28 Oct 2007 02:41:00 GMT

#include<assert.h>
#include<iostream.h>
#include<stdlib.h>
#include"Queue.h"
template<class T>
class SeqQueue
{
public:
    SeqQueue(int sz=10);
    ~SeqQueue(){delete[]elements;}
    bool EnQueue(const T& x);
    bool DeQueue(T& x);
    bool getFront(T& x);
    void makeEmpty(){front=rear=0;}
    bool IsEmpty()const{return(front==rear)?true:false;}
    bool IsFull()const{return((rear+1)%maxSize==front)?true:false;}
    friend ostream& operator<<(ostream& os,SeqQueue<T>& Q);     //输出重载
protected:
    int rear,front;              //队尾指针与对头指针
    T *elements;
    int maxSize;                //队列最大可容纳个数
};

template<class T>
SeqQueue<T>::SeqQueue(int sz):front(0),rear(0),maxSize(sz)
{
    elements=new T[maxSize];
    assert(elements!=NULL);
};

template<class T>
bool SeqQueue<T>::EnQueue(const T& x)
{
    if(IsFull()==true) return false;          //队列满，插入失败
    elements[rear]=x;                         //按照队尾指针指示插入位置
    rear=(rear+1)%maxSize;                    //队尾指针+1
    return true;
};

template<class T>
bool SeqQueue<T>::DeQueue(T& x)
{
    if(IsEmpty()==true) return false;
    x=elements[front];
    front=(front+1)%maxSize;
    return true;

}

template<class T>
bool SeqQueue<T>::getFront(T& x)
{
    if(IsEmpty()==true) return false;
    x=elements[front];
    return true;
};

template<class T>
ostream& operator<<(ostream& os,SeqQueue<T>& Q)
{
    os<<"front="<<Q.front<<",rear="<<Q.rear<<endl;
    for(int i=Q.front;i!=Q.rear;i=(i+1)%maxSize)
        os<<i<<":"<<Q.elements[i]<<endl;
    return os;
}

heidaizx 2007-10-28 10:41 发表评论

栈实现fib算法

heidaizx — Sun, 28 Oct 2007 02:39:00 GMT

///////////////////
//FIB数列的栈实现//
///////////////////
#include"LinkedStack.h"
#include
struct Node
{
    long n;
    int tag;
};

long Fibnacci(long n)
{
    LinkedStack S;
    Node *w=new Node;    //分配动态内存，如果不分配则程序错误
    if(w==NULL)
    {
        cerr<<"分配内存失误!"<        exit(1);
    }
    long sum=0;
    do
    {
        while(n>1)          //不断的将结构体压入栈
        {
            w->n=n;
            w->tag=1;
            S.Push(*w);
            n--;
        }
        sum=sum+n;


        while(S.IsEmpty()==false)
        {
            S.Pop(*w);
            if(w->tag==1)
            {
                w->tag=2;
                S.Push(*w);
                n=w->n-2;
                break;
            }
        }
    }while(S.IsEmpty()==false);
    return sum;
}

heidaizx 2007-10-28 10:39 发表评论

汉诺塔问题

heidaizx — Mon, 15 Oct 2007 11:52:00 GMT

终于搞清了它的过程，但是还是不知道其中编写的奥妙，再仔细想想为什么要这样

#include<iostream.h>
#include<string.h>
void Hanoi(int n,char A,char B,char C);

void main()
{
    Hanoi(3,'A','B','C');
}

void Hanoi(int n,char A,char B,char C)
{
    if(n==1)
        cout<<"Move top disk from peg "<<A<<" to peg "<<C<<endl;
    else
    {
        Hanoi(n-1,A,C,B);
        cout<<"Move top disk from peg "<<A<<" to peg "<<C<<endl;
        Hanoi(n-1,B,A,C);
    }
}

heidaizx 2007-10-15 19:52 发表评论

括号匹配问题

heidaizx — Sun, 14 Oct 2007 09:01:00 GMT

void PrintMatchedPairs(char *expression)//////////////////////////////////////////////////////////括号匹配算法
{
    linkedStack s;
    int j,length=strlen(expression);
    for(int i=1;i<=length;i++)
    {
        if(expression[i-1]=='(') s.Push(i);
        else if(expression[i-1]==')')
        {
            if(s.Pop(j)==true)
                cout<<j<<"与"<<i<<"匹配"<<endl;
            else
                cout<<"没有与第"<<i<<"个括号匹配的左括号!"<<endl;
        }
    }
    while(s.isEmpty()==false)
    {
        s.Pop(j);
        cout<<"没有与第"<<j<<"个左括号相匹配的右括号!"<<endl;
    }
}

别人写的代码

char stack[200];/*   栈空间   */
int  size=0;    /*   入栈个数   */
int PrintMatchedPairs(char *expression)
{
    int i;
    for(i=0;i<strlen(expression);i++)
    {
        char c=expression[i];


        if(c=='('||c=='['||c=='{')   /*   遇到左括号   */
        {
            stack[size]=c;   /*   stack   push   */
            size++;
        }

        else if(c==')')  /*   遇到右括号   */
        {

            if(size==0||stack[size-1]!='(')  /*   检查   stack   最后一个是否是   '('   */
            {
                size=0;
                return 0;

            }
            else
                size--;   /*   stack   pop   */
        }
        else if(c==']')
        {

            if(size==0||stack[size-1]!='[')  /*   检查   stack   最后一个是否是   '['   */
            {
                size=0;
                return 0;

            }
            else
                size--;   /*   stack   pop   */
        }
        else if(c=='}')
        {

            if(size==0||stack[size-1]!='{')   /*   检查   stack   最后一个是否是   '{'   */
            {
                size=0;
                return 0;

            }
            else
                size--;   /*   stack   pop   */
        }
    }

    if(size==0)
        return 1;
    else
    {

        size=0;
        return 0;
    }

}

heidaizx 2007-10-14 17:01 发表评论

栈的简单实现

heidaizx — Sun, 14 Oct 2007 07:17:00 GMT

#include<iostream>
#include<assert.h>
using namespace std;

struct linkNode
{
    int data;
    linkNode *link;
    linkNode(linkNode *pre=NULL):link(pre){}
    linkNode(int d,linkNode *pre=NULL):link(pre),data(d){}

};

class linkedStack
{
public:
    linkedStack():top(NULL){}
    ~linkedStack(){makeEmpty();};
    void Push(const int &x);
    bool Pop(int &x);
    int getTop(int &x)const;
    bool isEmpty()const {return (top==NULL)?true:false;}
    int getSize()const;
    void makeEmpty();
    void output();
private:
    linkNode *top;
};

void linkedStack::makeEmpty()
{
    linkNode *p;
    while(top!=NULL)
    {
        p=top;
        top=top->link;
        delete p;
    }
}

void linkedStack::Push(const int &x)
{
    top=new linkNode(x,top);
    assert(top!=NULL);
}

bool linkedStack::Pop(int &x)
{
    if(isEmpty()==true) return false;
    linkNode *p=top;
    top=top->link;
    x=p->data;
    delete p;
    return true;
}

int linkedStack::getTop(int &x)const
{
    if(isEmpty()==true) return false;
    x=top->data;
    return x;
}

int linkedStack::getSize()const
{
    linkNode *p=top;
    int i=0;
    while(p!=NULL)
    {
        p=p->link;
        i++;
    }
    return i;
}

void linkedStack::output()
{
    linkNode *p=top;
    while(p!=NULL)
    {
        cout<<p->data<<endl;
        p=p->link;
    }
}

int menu()
{
    int choice;

    cout<<"*************链式栈的基本操作************"<<endl<<endl;
    cout<<"插入结点，请按1"<<endl;
    cout<<"删除结点，请按2"<<endl;
    cout<<"返回栈顶元素的值，请按3"<<endl;
    cout<<"求栈的元素个数，请按4"<<endl;
    cout<<"清空栈的元素，请按5"<<endl;
    cout<<"打印栈的元素，请按6"<<endl;
    cout<<"退出，请按7"<<endl<<endl;
    cout<<"*****************************************"<<endl<<endl;

    cout<<"请选择:";
    cin>>choice;
    return choice;
}

int main()
{
    linkedStack obj;
    bool exit=false;
    while(true)
    {
        int choice=menu();
        switch(choice)
        {
        case 1:
            int s;
            cout<<"请输入要推入元素的数据域:";
            cin>>s;
            obj.Push(s);break;
        case 2:
            int x;
            cout<<"请任意输入一个数:";
            cin>>x;
            cout<<obj.Pop(x)<<endl;break;
        case 3:
            int y;
            cout<<"请任意输入一个数,用做返回栈顶元素的容器:";
            cin>>y;
            cout<<obj.getTop(y)<<endl;break;
        case 4:
            cout<<obj.getSize()<<endl;break;
        case 5:
            obj.makeEmpty();break;
        case 6:
            obj.output();break;
        case 7:
            exit=true;break;
        }
        if(exit==true)
            break;
    }
    return 0;
}

heidaizx 2007-10-14 15:17 发表评论