2. 程式人生 > >c++連結串列實現佇列，深搜加寬搜，加模版類實現迷宮問題；

c++連結串列實現佇列，深搜加寬搜，加模版類實現迷宮問題；

阿新 • • 發佈：2019-02-19

資料結構作業二，用連結串列實現佇列，用深搜寬搜解決迷宮問題，另是模版類的用法；
模版類用法舉例：
栗子一：

template<class bbb>
class Node{
public:
    bbb data;
    Node *next;
    Node(){next=NULL;}
};//只在前面加template關鍵字就可以；

栗子二：

template<class ttt>
class Linkquuue{
public:
    Linkquuue();
    ~Linkquuue();
    void Enqueue(ttt x);
    int  Dequeue
 
();
    ttt Getqueue();
    int Empty(){if(Front==Rear)return 1;return 0 ;}
private:
    Node<ttt>*Front,*Rear;
};
template<class ttt>
Linkquuue<ttt>::Linkquuue(){
    Node<ttt> *s=new Node<ttt>;
    s->next=NULL;
    Front=Rear=s;
}
template<class ttt>
Linkquuue
 
<ttt>::~Linkquuue(){
    while(Rear!=Front){
        Node<ttt> *p;
        ttt x;
        p=Front->next;
        Front->next=p->next;
        if(p->next==NULL)Rear=Front;
        delete p;
    }
}

template<class ttt>
void Linkquuue<ttt>::Enqueue(ttt x){
    Node<ttt> *s=new Node
 
<ttt>;
    s->data=x;
    s->next=NULL;
    Rear->next=s;
    Rear=s;
}
template<class ttt>
int Linkquuue<ttt>::Dequeue()
{
    if(Rear==Front)return 0;
    Node<ttt> *p;
    ttt x;
    p=Front->next;
    x=p->data;
    Front->next=p->next;
    if(p->next==NULL)Rear=Front ;
    delete p;
    return 1;
}
template<class ttt>
ttt Linkquuue<ttt>::Getqueue(){
    return Front->next->data;
}///類裡只在類外加一個模版類宣告即可，類外，在哪裡加就在哪裡加引數表；
///所以模版類宣告的有效範圍只在當前區域內有效；

連結串列實現佇列：
程式碼：

template<class bbb>
class Node{
public:
    bbb data;
    Node *next;
    Node(){next=NULL;}
};
template<class ttt>
class Linkquuue{
public:
    Linkquuue();
    ~Linkquuue();
    void Enqueue(ttt x);
    int  Dequeue();
    ttt Getqueue();
    int Empty(){if(Front==Rear)return 1;return 0 ;}
private:
    Node<ttt>*Front,*Rear;
};
template<class ttt>
Linkquuue<ttt>::Linkquuue(){
    Node<ttt> *s=new Node<ttt>;
    s->next=NULL;
    Front=Rear=s;
}
template<class ttt>
Linkquuue<ttt>::~Linkquuue(){
    while(Rear!=Front){
        Node<ttt> *p;
        ttt x;
        p=Front->next;
        Front->next=p->next;
        if(p->next==NULL)Rear=Front;
        delete p;
    }
}

template<class ttt>
void Linkquuue<ttt>::Enqueue(ttt x){
    Node<ttt> *s=new Node<ttt>;
    s->data=x;
    s->next=NULL;
    Rear->next=s;
    Rear=s;
}
template<class ttt>
int Linkquuue<ttt>::Dequeue()
{
    if(Rear==Front)return 0;
    Node<ttt> *p;
    ttt x;
    p=Front->next;
    x=p->data;
    Front->next=p->next;
    if(p->next==NULL)Rear=Front ;
    delete p;
    return 1;
}
template<class ttt>
ttt Linkquuue<ttt>::Getqueue(){
    return Front->next->data;
}

深搜加寬搜實現迷宮問題（舉例說明），
///實驗問題及具體舉例說明；
/*
迷宮問題。以一維陣列Maze[m+2][n+2]陣列描述一個迷宮，元素。值為0表示通道，值為1表示牆壁，以 Maze[1][1]表示迷宮的入口，maze[m][n]表示迷宮的出口，外層資料全為1表示外圍牆壁，Maze陣列內層資料表達一個迷宮（資料來源於輸入或隨機賦值），列印一條如何從Maze[1][1]到達出口Maze[m][n]的路徑，若無解，則列印“無解”資訊
迷宮問題舉例：
設：
1）：圖大小給出，n行m列1<=n,m<=20，圖中1為牆壁，0為可走的路；
2）：從當前點可移動到上下左右四點（如果沒有障礙及可走的情況下）
3）：求（1,1）到（m，n）所走的最短路，如有多條輸出任意一條，沒有輸出”no a way!”；
4）：描述：多組資料讀到文件尾，輸入n，m，表示圖的大小為n行m列，接下來n行每行有m個數；
輸出：輸出最短路徑，每行一個座標表示走過的點，多組解輸出任意一組，無解情況輸出”no a way!”，然後換行；
樣例：
樣例輸入

2 5
0 1 0 0 0
0 0 0 1 0
4 6
0 1 1 0 0 0
0 0 1 0 1 1
0 1 1 1 1 0
0 1 1 1 0 0
2 2
0 1
1 0

樣例輸出1

1 1
2 1
2 2
2 3
1 3
1 4
1 5
2 5

no a way!

no a way!

*/
具體程式碼：
簡版：

#include <bits/stdc++.h>
using namespace std;
template<class bbb>
class Node{
public:
    bbb data;
    Node *next;
    Node(){next=NULL;}
};
template<class ttt>
class Linkquuue{
public:
    Linkquuue();
    ~Linkquuue();
    void Enqueue(ttt x);
    int  Dequeue();
    ttt Getqueue();
    int Empty(){if(Front==Rear)return 1;return 0 ;}
private:
    Node<ttt>*Front,*Rear;
};
template<class ttt>
Linkquuue<ttt>::Linkquuue(){
    Node<ttt> *s=new Node<ttt>;
    s->next=NULL;
    Front=Rear=s;
}
template<class ttt>
Linkquuue<ttt>::~Linkquuue(){
    while(Rear!=Front){
        Node<ttt> *p;
        ttt x;
        p=Front->next;
        Front->next=p->next;
        if(p->next==NULL)Rear=Front;
        delete p;
    }
}

template<class ttt>
void Linkquuue<ttt>::Enqueue(ttt x){
    Node<ttt> *s=new Node<ttt>;
    s->data=x;
    s->next=NULL;
    Rear->next=s;
    Rear=s;
}
template<class ttt>
int Linkquuue<ttt>::Dequeue()
{
    if(Rear==Front)return 0;
    Node<ttt> *p;
    ttt x;
    p=Front->next;
    x=p->data;
    Front->next=p->next;
    if(p->next==NULL)Rear=Front ;
    delete p;
    return 1;
}
template<class ttt>
ttt Linkquuue<ttt>::Getqueue(){
    return Front->next->data;
}
struct zuobiao
{
    int x,y;
    zuobiao(int a,int b){x=a;y=b;}
    zuobiao(){};
};
const int maxn=22;
int tu[maxn][maxn];
int lu[maxn][maxn];
int n,m;
int showlu(int x,int y)
{
    if(x==0&&y==0){
        cout<<x+1<<" "<<y+1<<endl;
        return 0;
    }
    for(int i=-1;i<2;i++){
        for(int j=-1;j<2;j++){
          if((i==0||j==0)&&i^j!=0)
            {
                int si=x+i,wai=y+j;
                if(si>=0&&si<n&&wai>=0&&j<m){
                    if(lu[si][wai]==(lu[x][y]-1)){
                        showlu(si,wai);
                        cout<<x+1<<" "<<y+1<<endl;
                        return 0;
                    }
                }
            }
        }
    }
    return 0;
}
int main()
{
    while(cin>>n>>m){
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                cin>>tu[i][j];
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(tu[i][j]==1)
                    lu[i][j]=-1;
                if(tu[i][j]==0)
                    lu[i][j]=0;
            }
        }
        lu[0][0]=1;
        Linkquuue<zuobiao>qu;
        qu.Enqueue(zuobiao(0,0));
        while(!qu.Empty()){
            zuobiao now=qu.Getqueue();
            qu.Dequeue();
            for(int i=-1;i<2;i++){
                for(int j=-1;j<2;j++){
                    if((i==0||j==0)&&i^j!=0){
                        int si=now.x+i,wai=now.y+j;
                        if(si>=0&&si<n&&wai>=0&&wai<m){
                            if(lu[si][wai]==0){lu[si][wai]=lu[now.x][now.y]+1;
                            qu.Enqueue(zuobiao(si,wai));
                                }
                            }
                        }
                    }
                }

            }
        if(lu[n-1][m-1]==0||lu[n-1][m-1]==-1)
            cout<<"no a way!"<<endl;
        else{
            showlu(n-1,m-1);
            cout<<endl;
        }
    }
    return 0;
}

加註釋版：

#include <bits/stdc++.h>
using namespace std;
template<class bbb>
class Node{                 ///連結串列裡的節點；
public:
    bbb data;
    Node *next;
    Node(){next=NULL;} ///可直接生成節點；
};
template<class ttt>
class Linkquuue{            ///佇列類，用連結串列結構儲存；
public:
    ///建構函式，生成了一個標誌節點，沒注意這個，debug到天亮；
    Linkquuue();
    ///解構函式，因為是通過new申請的記憶體，必須要自己動手釋放，
    ///否則解構函式一般不用寫東西；
    ~Linkquuue();
    ///入隊；
    void Enqueue(ttt x);
    ///出隊，先入者先出；
    int  Dequeue();
    ///得到隊頭的元素，注意對頭有標誌節點；
    ttt Getqueue();
    ///判斷是否為空；為空輸出1，不為空輸出0；
    int Empty(){if(Front==Rear)return 1;return 0 ;}
private:
    ///佇列元素，只記錄隊首和隊尾即可；
    Node<ttt>*Front,*Rear;
};
template<class ttt>
///建構函式，申請一個新節點，其實不用，但是改動麻煩，注意即可；
Linkquuue<ttt>::Linkquuue(){
    Node<ttt> *s=new Node<ttt>;
    s->next=NULL;
    Front=Rear=s;
}
template<class ttt>
///解構函式，析構掉申請的記憶體，主要構造時候申請的空節點；
Linkquuue<ttt>::~Linkquuue(){
    while(Rear!=Front){
        Node<ttt> *p;
        ttt x;
        p=Front->next;
        Front->next=p->next;
        if(p->next==NULL)Rear=Front;
        delete p;
    }
    delete Front;
}

template<class ttt>
///入隊操作，在隊首新增即可，注意空節點；
void Linkquuue<ttt>::Enqueue(ttt x){
    Node<ttt> *s=new Node<ttt>;
    s->data=x;
    s->next=NULL;
    Rear->next=s;
    Rear=s;
}
///出隊操作，去掉隊尾申請的記憶體即可；
template<class ttt>
int Linkquuue<ttt>::Dequeue()
{
    if(Rear==Front)return 0;
    Node<ttt> *p;
    ttt x;
    p=Front->next;
    x=p->data;
    Front->next=p->next;
    if(p->next==NULL)Rear=Front ;
    delete p;
    return 1;
}
///根據先入先出的原則，拿出隊首元素，
///主要第一個為空節點，返回第二個節點
template<class ttt>
ttt Linkquuue<ttt>::Getqueue(){
    return Front->next->data;
}
///上面的操作均在模版類中實現，這裡具體到類；
///為下面的程式開個座標類，記錄處理到的座標；
struct zuobiao
{
    int x,y;
    ///支援型別強轉；
    zuobiao(int a,int b){x=a;y=b;}
    ///支援直接建立座標類，不必賦值；
    zuobiao(){};
};
///本程式的引數，及地圖的最大是多少，後期可調；
const int maxn=22;
///存圖，即原始的資料；
int tu[maxn][maxn];
///存路，之後的操作在這裡進行，可保護原始資料；
int lu[maxn][maxn];
///引數允許範圍內具體地圖的大小，這裡開全域性是為深搜的呼叫；
int n,m;
///輸出路徑，寬搜跑地圖得到路徑，深搜可反向進行搜尋，輸出路徑；
int showlu(int x,int y)
{
    ///深搜結束條件，即搜尋到起始位置；
    if(x==0&&y==0){
        cout<<x+1<<" "<<y+1<<endl;
        return 0;
    }
    ///從高位向低位進行搜尋,因為高位是低位寬搜來的，所以一定有路，
    ///關係如同，根可以找到n多葉子，葉子只能找到一個根；
    for(int i=-1;i<2;i++){
        for(int j=-1;j<2;j++){
          if((i==0||j==0)&&i^j!=0)
            {
                int si=x+i,wai=y+j;
                if(si>=0&&si<n&&wai>=0&&j<m){
                    if(lu[si][wai]==(lu[x][y]-1)){
                        ///找到下個點時進行遞迴操作；
                        showlu(si,wai);
                        ///因為要正著輸出路徑，所以，
                        ///放在遞迴的後面，可以從低位輸出；
                        cout<<x+1<<" "<<y+1<<endl;
                        ///這裡符合條件就返回，保證了只輸出一條路徑；
                        return 0;
                        }
                    }
                }
            }
        }
    return 0;
}
int main()
{
    ///保證有資料就可以讀入操作；
    while(cin>>n>>m){
        ///讀入資料結構；其實可以寫成函式，不過意義不大；
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                cin>>tu[i][j];
            }
        }
        ///路徑的初始化操作；
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(tu[i][j]==1)
                    lu[i][j]=-1;
                if(tu[i][j]==0)
                    lu[i][j]=0;
            }
        }
        ///因為下面的入隊條件是等零，所以這裡初始化下；
        lu[0][0]=1;
        ///首先宣告佇列，入隊起點；
        Linkquuue<zuobiao>qu;
        qu.Enqueue(zuobiao(0,0));
        while(!qu.Empty()){
            ///得到隊首元素；
            zuobiao now=qu.Getqueue();
            ///隊首處理完成，出隊；
            qu.Dequeue();
            for(int i=-1;i<2;i++){
                for(int j=-1;j<2;j++){
                    if((i==0||j==0)&&i^j!=0){
                        int si=now.x+i,wai=now.y+j;
                        if(si>=0&&si<n&&wai>=0&&wai<m){
                            if(lu[si][wai]==0){lu[si][wai]=lu[now.x][now.y]+1;
                            qu.Enqueue(zuobiao(si,wai));
                            ///搜尋到下個符合條件的位置入隊；
                                }
                            }
                        }
                    }
                }

            }
        ///lu陣列沒有改變，說明到達不到，輸出no a way！；
        if(lu[n-1][m-1]==0||lu[n-1][m-1]==-1)
            cout<<"no a way!"<<endl<<endl;
        ///有路及輸出路徑；
        else{
            showlu(n-1,m-1);
            cout<<endl;
        }
    }
    return 0;
}

相關推薦

c++連結串列實現佇列，深搜加寬搜，加模版類實現迷宮問題；

資料結構作業二，用連結串列實現佇列，用深搜寬搜解決迷宮問題，另是模版類的用法； 模版類用法舉例： 栗子一： template<class bbb> class Node{ public: bbb data; Node *ne

連結串列和順序表（參考stl原始碼，使用c語言實現）

順序表 優點：可以隨機訪問，cpu快取記憶體利用率高，不涉及（較少）進行插入和刪除操作，應該使用順序表。 順序表，不論是動態開闢，還是固定大小，一般放置在棧上，不用程式設計師手動開闢空間 連結串列：主要運用2種，A單向不帶頭結點的非迴圈連結串列      B雙向帶頭

連結串列實現佇列的出隊和入隊，棧的入棧和出棧

佇列的出隊和入隊 queue.h #ifndef QUEUE_H_ #define QUEUE_H_ #include<iostream> typedef struct tagstude

單鏈表——求兩個集合的差集 A，B集合求差集放到C連結串列中

#include <stdio.h> #include <malloc.h> typedef struct Node { int data; struct Node *next; }LNode,*LinkList; void list

Python3 連結串列、佇列和棧的實現

# -!- coding: utf-8 -!- # ！/usr/bin/env python 3.6.3 # author: Vivian # time: 2018/9/16 # 使用list列表構造棧 class Stack(object): def __init

新手上路，勿噴。C++連結串列的建立，遍歷，刪除，插入等等

//list.h #pragma once template<typename T>class slistNode { public:  slistNode() { next = nullptr; cout << "呼叫了slistnode的建構函式

帶頭結點的迴圈連結串列表示佇列, 並且只設一個指標指向隊尾元素結點， 試編寫相應的佇列初始化,入佇列和出佇列的演算法

資料結構演算法題(假設以帶頭結點的迴圈連結串列表示佇列, 並且只設一個指標指向隊尾元素結點(注意不設頭指標) 試編寫相應的佇列初始化,入佇列和出佇列的演算法!) /* 資料結構演算法題

基於連結串列的佇列實現

1.建立鏈節點類link 只有一種資料int型別，和對下一個鏈節點的引用next public class Link { public int a; public Link next; public Link(int m){ a=m; }

【演算法】C++連結串列的實現以及常見的連結串列操作和測試

自己實現連結串列常見的操作，用作記錄，以備以後檢視#include <iostream> #include <string.h> using namespace std; //定義節點 class Node { public: int m_data

C++ 連結串列棧及常用函式實現

#include<iostream> using namespace std; typedef struct Node { int data; struct Node* next; }Node; typedef struct Stack { Node* to

二叉樹C++ | 連結串列遞迴實現二叉樹（插入、搜尋）_1

遞迴實現二叉樹（插入、搜尋） // Binary Search Tree - Implemenation in C++ // Simple program to create a BST of integers and search an element in it #include<i

【C++資料結構】模版類實現雙迴圈連結串列的基本操作

單鏈表結構為我們提供方便分資料插入和刪除工作，美中不足的是查詢資料不方便，對於單鏈表查詢資料至少要遍歷一邊．　　為此我們提出雙鏈表結構，從而方便的查詢資料． 給出雙鏈表的一般結構： 一種是帶頭結點（哨兵位）的管理方式，另一種是帶管理節點管理方式。 但是我們不建議採用

基於連結串列的佇列、基於順序表的佇列 C語言

基於連結串列的佇列： //LinkQueue.h #pragma once #include<stdio.h> #include<stdlib.h> #include<

C++連結串列類的運用，簡單實用。

// ------------------------------------------------------------------------- // 檔名 : list1.cpp // 建立者 : 方煜寬 // 　郵箱 ： [

使用python實現陣列、連結串列、佇列、棧

引言 什麼是資料結構？ 資料結構是指相互之間存在著一種或多種關係的資料元素的集合和該集合中資料元素之間的關係組成。 簡單來說，資料結構就是設計資料以何種方式組織並存儲在計算機中。 比如：列表，集合和字典等都是資料結構 N.Wirth：“程式=資料結構+演算法” 資料結構按照其邏輯結

C 連結串列中從第s節點到第e節點的逆置

//結構體 typedef struct Node { ElementType data; struct Node * next; } LNode, * LinkNode; //逆置從i到m個節點的串 Status reversFromstoe(LinkNode *L,

C 連結串列前n個是不是中心對稱就像 arrfrra

前面相關操作在這呢，這個函式依託於此 //結構體 typedef struct Node { ElementType data; struct Node * next; } LNode, * LinkNode; //連結串列前n個是不是中心對稱 Status isS

線性表——連結串列、佇列、堆疊

主要內容  連結串列        連結串列相加/連結串列部分翻轉/連結串列去重        連結串列劃分/連結串列公共結點  佇列        

java 連結串列的氣泡排序，排序之後連結串列的結構是已經發生變化的，可以直接根據head+temp +next節點列印全部

package interview.datastructure; /** * 實現連結串列的插入和刪除結點的操作 */ public class Link_list { //定義一個結點 class Node { Node next = null; int d

關於陣列/連結串列/棧/佇列的形象解釋

“棧”：       我是一個棧，先來跟你介紹一下我的家族，我的家族是一個很古老的家族，家族成員很多，外界稱呼我們這個家族為資料結構。我們是計算機世界中儲存和組織資料的。資料結構家族在計算機世界中是至關重要的，因為我們家族功能的強大，現代程式