数据结构---习题（C++）

1、请写出对下面序列进行快速排序的每一趟结果。

46 74 16 53 14 26 40 38 86 65 27 34

 

答：      1、 34  27  16  38  14  26  40  46  86  65  53  74

            2、 26  27  16  14  34  38  40  46  86  65  53  74

            3、 14  16  26  27  34  38  40  46  86  65  53  74

            4、 14  16  26  27  34  38  40  46  86  65  53  74

            5、 14  16  26  27  34  38  40  46  86  65  53  74

            6、 14  16  26  27  34  38  40  46  74  65  53  86

            7、 14  16  26  27  34  38  40  46  53  65  74  86

            8、 14  16  26  27  34  38  40  46  53  65  74  86

 

 

2、如果现在要对一个实际问题进行最小生成树的计算机求解，就意味着要把这个实际问题转换为一个图：并把该图采用邻接矩阵的存储方法进行存储，接着用prim方法即可求出对应的最小生成树。但实际问题对应的图结点一般可能是一个名字，那就需要有方法存储这些名字，并在需要的时候快速查找出来。我们又知道在一般情况下，散列查找方法的查找速度最快，散列查找方法中最需要解决的两个问题分别是：构造散列函数和冲突解决方案。请为下面的名字构造散列函数并画出相应的散列表（冲突解决方案自定）

Jones, Smiths, Howards, Wangs, Toms, HarFord, Fox,Pixar, kitty

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

二、链表算法分析设计题

1、实验一中需要进行完成的功能有“向学生健康表插入学生信息”，请写出用单链表进行插入操作所需要的存储结构及算法。

 

答：

#include “stdafx.h”

 

struct Student

{

public:

      long Num;

      char Name;

      char Health;

};   学生结构体

 

typedefStudent DataType;

 

class ListNode

{

public::

      DataType data;

      ListNode *next;

      ListNode(const DataType &itemval,ListNode *ptrnext=NULL)

{data=itemval, next=ptrnext; }

ListNode(ListNode *ptrnext=NULL)

{next=ptrnext; }

};   //结点类

 

class LinkList

{

public:

      ListNode *head;

      ListNode *tail;

      ListNode *currptr;

public:

      LinkList(void);

      ~LinkList(void);

      void InsertAfter(DataType &itemval);

};   //链表类                         

 

 

 

 

 

LinkList::InsertAfter(DataType&itemval)

{

      ListNode *TempNode;

      TempNode=new ListNode(itemval, NULL);

      If(currptr= =NULL)

      {

           TempNode->next=head;

           If(head= =NULL)

                 tail=TempNode;

           head=TempNode;

           currptr=TempNode;

}

else

{

      TempNode->next=currptr->next;

      Currptr->next=TempNode;

}

}    //尾插入

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

三、二叉树算法分析设计题

1、实验二中需要把键盘从键盘中输入的学生信息存储到二叉链式结构中，而对应的建立算法又不少，请写出你在实验二中建立二叉链式结构所用的存储结构及算法。

 

答：

#include “stdafx.h”

 

struct Student

{

public:

      long Num;

      char Name;

      char Health;

};   //学生结构体

 

typedefStudent DataType;

 

 

classBTreeNode

{

public:

      DataType data;

      BTreeNode *lchild;

      BTreeNode *rchild;

};   //二叉链式树结点结构体

 

 

classBLinkTree

{

public:

      BTreeNode *head;

      int NodeNum;

public:

      BLinkTree(void);

      ~BLinkTree(void);

      void Insert_CC(DataType x);

};   //二叉链式树结构体

 

 

 

 

 

 

BLinkTree::Insert_CC(DataTypex)

{

      BTreeNode *current;

      BTreeNode *T;

      int FLAG=1;                                 //1表示插入；0表示遍历

      T=new BTreeNode(t);

      NodeNum++;                                 //初始值为0（初始化在它出完成）

      queue q=queue(NodeNum);

      if(head==NULL){head=T;}              //若表空则插入根结点

      else q.EnQueue(head);

      while(!q.IsEmpty())

      {

           current=q.DelQueue();

           if(current->lchild!=NULL)

           {

                 q.EnQueue(current->lchild);

                 if(current->rchild!=NULL)

                      q.EnQueue(current->rchild);

                 else

                 {

                      if(FLAG){current->rchild=T;FLAG=0;}   //右插入

                 }

           }

           else

           {

                 if(FLAG){current->lchild=T;FLAG=0;}         //左插入

           }

      }

}    //层次插入

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

四、哈夫曼算法分析设计题

1、实验三中需要进行完成的功能有“编译功能（Encoding）”，即利用已建立好的哈夫曼数（假设已存在计算机内存中），对文件tobetran.dat中的正文进行编码，然后将结果存入文件“codefile.dat”中，请写出完成该功能所需要的存储结构及算法。

 

答：

#include “stdafx.h”

#include<iostream.h>

#include<fstream.h>

 

ifstreaminput_f;

ofstreamoutput_f;

 

classHuffmanNode

{

public:

int weight;

      int parent;

      int lchild,rchild;

};

 

classHuffmanTree

{

public:

      struct HuffmanNode *Node;

      char *Info;

      int LeafNum;

public:

      HuffmanTree(int WeightNum);

      ~HuffmanTree(void);

      void Encoder(char ch);

};

 

void HuffmanTree::Encoder(charch)

{

int add=0;

char *Tree;

int loop=0;

      char *code;

      int i,j,start=0;

      code=new char[LeafNum];

 

 

      input_f.open(“tobetran.dat”);

      if(!input_f)

{

      cout<<”文件打开失败”<<endl;

      break;

}

while(input_f.get(ch))

{

      add++;

}    //计算tobetran.dat里面的字符数

input_f.close();

Tree=new char[add]; //保存需要编码的字符内容

 

input_f.open(“tobetran.dat”);

      while(input_f.get(ch))

{

      Tree[loop]=ch;

      loop++;

}

Tree[add]=’\0’;  //置串结束符

 

      output_f.open(codefile.dat);

      if(!output_f)

{

      cout<<”文件写入失败!”<<endl;

      break;

}

      for(loop=0;loop<add;loop++)

{

            for(i=0;i<LeafNum;i++)

                 if(Info[i]==Tree[i])  //求出该文字所在的单元编号

                 break;

j=i;

while(Node[j].parent!=-1)

{

            j=Node[j].parent;

            if(Node[j].lchild=i)

                  code[start++]=’0’;

            else

                  code[start++]=’1’;

}

code[start]=’\0’;

 

 

for(i=0;i<start/2;i++)

{

            j=code[i];

            code[i]=code[start-i-1];

            code[start-i-1]=j;

}

output_f<<code; //将编码后的结果写入codefile文件中

}

}

 

 

五、图算法分析设计题

1、实验四需要完成的功能是：要求采用深度优先搜索方法进行迷宫问题的求解。我们都知道图的搜索方法有广度优先搜索，请写出采用广度优先搜索方法进行迷宫问题求解的搜索算法及所需要的存储结构。（提示，路径输出算法可以不用考虑）

 

答：

#include<fstream>

#include<iostream>

#include<stack>

usingnamespace std;

 

//迷宫用二维整型数组存储

#define row9     //迷宫的行列数

#define column8

 

intmaze[row+2][column+2];  //迷宫外加一层障碍

 

voidmazewithstack(); //用栈走迷宫的函数声明，其定义见main()之后

 

 

 

struct ss{

      int x;

      int y;

}move[8]={{1,0},{1,-1},{1,1},{0,1},{-1,0},{-1,-1},{-1,0},{0,-1}};

     

typedefstruct{

      int x;

      int y;

      int pre;

}Datatype;

 

void  mazewithstack(){

      int m,n;

    cout<<"Please input m andn:";

      cin>>m>>n;

    Datatype temp1,temp2;

      int x,y,loop;

      temp1.x=m;

      temp1.y=n;

      temp1.pre=-1;

      stack<Datatype>s;

      s.push(temp1);

      maze[m][n]=-1;

 

      int i;

    while(!s.empty())

      {  

           temp2=s.top();

          

           i=0;

           for(loop=0;loop<8;loop++)

           {

                 x=temp2.x+move[loop].x;

                 y=temp2.y+move[loop].y;

                 if(maze[x][y]==0)

                 {

                      temp1.x=x;

                      temp1.y=y;

                      maze[x][y]=-1;

                      s.push(temp1);

                      i=1;

                 }

                 if((temp2.x==1)&&(temp2.y==1))

                 { 

                      while(!s.empty())

                      {

                            cout<<"("<<s.top().x<<","<<s.top().y<<")";

                            s.pop();

                            if(!s.empty())

                            {

                                  cout<<"-->";

                            }

                           

                      }

                      cout<<endl;

                      return ;

                 }

                 if(i==1)break;  

           }

           if(i!=1) s.pop();

           if(s.empty())

                 cout<<"There is noway!"<<endl;

      }

}