文章目錄

實驗性質：綜合性實驗

要求：

（1）採用鄰接矩陣/鄰接表建立圖；
（2）採用深度優先/廣度優先搜索方式遍歷圖；
（3）編程實現Dijkstra最短路徑算法。

目的：

（1）掌握圖的鄰接矩陣和鄰接表存儲方式；
（2）掌握圖的遍歷算法；
（3）掌握圖的實際應用——最短路徑算法。

代碼

#include <iostream>
using namespace std;
//**折半查找**//
typedef struct {
    int key;//查找表中每個數據元素的值
}ElemType;
typedef struct{
    ElemType *elem;//存放查找表中數據元素的數組
    int length;//記錄查找表中數據的總數量
}SSTable;
//**二叉排序樹**//
int m=-1;   //二叉排序樹初始化計數
int n=0;    //二叉排序樹關鍵字序列下標和查找次數計數
typedef struct {
    string key;//查找表中每個數據元素的值
    int position;//結點在關鍵字序列中的位置
}ElemType2;
typedef struct BSTNode
{
    ElemType2 data;
    struct BSTNode *lchild,*rchild; //左右孩子指針
}BSTNode,*BSTree;
//**排序**//
#define MAXSIZE 100
typedef  struct {
    int  key;   //關鍵字項
}RedType;                     //記錄類型
typedef  struct {
    RedType  r[MAXSIZE+1]; //r[0]閒置
    int  length;  //順序表長度
}SqList;  //順序表類型


void CreateList(SSTable &ST);   //創建有序線性表
void Search_Bin(SSTable ST,int key);   //折半查找
void CreateTree(BSTree &T); //創建二叉鏈表
void InOrderTraverse(BSTree T); //中序遍歷
BSTree SearchBST(BSTree T,  string key);//二叉樹的遞歸查找
void InitList(SqList &L);//初始化及賦初始值
void OutputKey(SqList &L);  //輸出當前順序表數值
void InsertSort(SqList &L);//直接插入排序
void BInsertSort(SqList &L);  //折半插入排序
void Menu();  //文字菜單提示信息

int main()
{
    SSTable ST;
    BSTree T;
    SqList L;
    Menu();
    int i;  //輸入的數字
    int key;string key2;    //輸入的待查元素
    cout<<"請輸入操作代碼：";
    cin>>i;
    while(true)
    {
        switch(i)
        {
            case 1:
                CreateList(ST);
                break;
            case 2:
                cout<<"請輸入待查元素:";
                cin>>key;
                Search_Bin(ST,key);
                break;
            case 3:
                CreateTree(T);
                cout<<"二叉排序樹創建成功"<<endl;
                cout<<"其中序遍歷結果爲:";
                n=0;    //置二叉排序樹關鍵字序列下標從0開始
                InOrderTraverse(T);
                cout<<endl;
                break;
            case 4:
                cout<<"請輸入待查元素:";
                cin>>key2;
                n=0;    //置查找次數爲0
                cout<<"待查元素爲第"<<SearchBST(T,key2)->data.position+1<<"個元素,";
                cout<<"共查找了"<<n<<"次"<<endl;
                break;
            case 5:
                cout<<"順序表初始化成功,";
                InitList(L);
                break;
            case 6:
                InsertSort(L);
                break;
            case 7:
                BInsertSort(L);
                break;
            default:
                if(i<0)
                    return 0;
                else
                {
                    cout<<"輸入的位置非法，請重新輸入";
                    break;
                }
        }
        cout<<"請輸入操作代碼：";
        cin>>i;
    }
    return 0;
}
//**折半查找**//
void CreateList(SSTable &ST)
{
    ST.elem=new ElemType[MAXSIZE];
    if(!ST.elem)    cout<<"存儲分配失敗"<<endl;
    ST.length=11;
    int a[11]={5,16,20,27,30,36,44,55,60,67,71};
    cout<<"有序線性表創建成功，其數值爲:";
    for (int i=1; i<=ST.length; i++)    //從下標1開始存儲
    {
        ST.elem[i].key=a[i-1];    //設置初始順序表數值
        cout<<ST.elem[i].key<<" ";
    }
    cout<<endl;
}
void Search_Bin(SSTable ST,int key)
{
    int low=1;int high=ST.length;int mid;
    int times=0;bool isHave=false;
    while(low<=high)
    {
        mid=(low+high)/2;
        times++;    //查找次數
        if(key==ST.elem[mid].key)
        {
            cout<<"待查元素爲第"<<mid<<"個元素,共查找了"<<times<<"次"<<endl;
            isHave=true;
            break;
        }
        else if(key<ST.elem[mid].key)   high=mid-1; //在前面找
        else low=mid+1; //在後面找
    }
    if(!isHave)
        cout<<"待查元素不在有序表中，共查找了"<<times<<"次"<<endl;
}
//**二叉排序樹**//
void CreateTree(BSTree &T)
{
    string ch[13]={"45","24","12","#","#","37","#","#","53","#","93","#","#"};
    m+=1;
    if(ch[m]=="#")
        T=NULL;
    else
    {
        T=new BSTNode;
        T->data.key=ch[m];
        CreateTree(T->lchild);    //遞歸創建左子樹
        CreateTree(T->rchild);    //遞歸創建右子樹
    }
}
void InOrderTraverse(BSTree T) //中序遍歷
{
    if(T)
    {
        InOrderTraverse(T->lchild); //中序遍歷左子樹
        cout<<T->data.key<<" ";  //訪問根節點
        T->data.position=n;
        n++;
        InOrderTraverse(T->rchild);
    }
}
BSTree SearchBST(BSTree T,  string key)//二叉樹的遞歸查找
{
    n++;
    if((!T) || key==T->data.key) return T;
    else if (key<T->data.key)
        return SearchBST(T->lchild,key); //在左子樹中繼續查找
    else
        return SearchBST(T->rchild,key); //在右子樹中繼續查找
}
//**排序**//
void InitList(SqList &L)//初始化且賦初始值
{
    int a[8]={49,38,65,97,76,13,27,49};
    L.length=0;
    for(int i=1;i<=8;i++)
    {
        L.r[i].key=a[i-1];
        L.length++;
    }
    OutputKey(L);
}
void OutputKey(SqList &L) //輸出當前順序表數值
{
    cout<<"當前順序表值爲:";
    for(int i=1;i<=8;i++)
    {
        cout<<L.r[i].key<<" ";
    }
    cout<<endl;
}
void InsertSort(SqList &L)//直接插入排序
{
    for(int i=2;i<=L.length;++i)
    {
        if( L.r[i].key<L.r[i-1].key)//將L.r[i]插入有序子表
        {
            L.r[0]=L.r[i]; // 複製爲哨兵
            L.r[i]=L.r[i-1];
            int j;
            for(j=i-2; L.r[0].key<L.r[j].key;--j)
                L.r[j+1]=L.r[j]; // 記錄後移
            L.r[j+1]=L.r[0]; //插入到正確位置
        }
    }
    cout<<"直接插入排序成功,";
    OutputKey(L);
}
void BInsertSort(SqList &L )  //折半插入排序
{
    for (int i = 2;i<=L.length; ++i )
    {
         L.r[0] = L.r[i];
         int low = 1 ; int high = i-1 ;
         while (low <=high)
         {
            m=( low + high )/2 ;
            if(L.r[0].key < L.r[m]. key)
                high = m -1 ;
            else
                low = m + 1;
         }
        for (int j=i-1; j>=high+1; --j)
            L.r[j+1] = L.r[j];
        L.r[high+1] = L.r[0];
     }
     cout<<"折半插入排序成功,";
     OutputKey(L);
}
void Menu()
{
    cout << "---------------------------" << endl;
    cout << "********by 夏日********" << endl;
    cout << "---------------------------" << endl;
    cout << "1-----創建有序線性表(折半查找前提)"<< endl;
    cout << "2-----折半查找" << endl;
    cout << "3-----創建二叉排序樹 "<< endl;
    cout << "4-----二叉排序樹查找" << endl;
    cout << "5-----順序表初始化及賦初始值" << endl;
    cout << "6-----直接插入排序" << endl;
    cout << "7-----折半插入排序" << endl;
    cout << "   退出,輸入一個負數！" << endl;
}