bl双性强迫侵犯h_国产在线观看人成激情视频_蜜芽188_被诱拐的少孩全彩啪啪漫画

數據結構--棧與隊列-創新互聯

一 .棧

一.順序棧的實現
A.棧的定義
1.棧是一種特殊的線性表
2.棧僅能在線性表的一端進行操作
a.棧頂：允許操作的一端
b.棧底：不允許操作的一端
B.棧的特性
后進先出(圖示)
數據結構--棧與隊列
C.棧的操作
1.創建棧
2.銷毀棧
3.清空棧
4.進棧
5.出棧
6.獲取棧頂元素
7.獲取棧的大小
D.棧的實現
數據結構--棧與隊列

成都創新互聯堅持“要么做到，要么別承諾”的工作理念，服務領域包括：做網站、網站設計、企業官網、英文網站、手機端網站、網站推廣等服務，滿足客戶于互聯網時代的潛山網站設計、移動媒體設計的需求，幫助企業找到有效的互聯網解決方案。努力成為您成熟可靠的網絡建設合作伙伴！
template <typename T>
class Stack:public Object
{
    public:
        virtual void push(const  T&e)=0;//入棧的操作
        virtual void pop()=0;//出棧的操作
        virtual T top()const =0;//棧頂元素
        virtual void clear()=0;//清除
        virtual int size()const=0;//棧的大小
};

棧的順序實現
數據結構--棧與隊列
E.StaticStack設計要點
類模板：
1.使用原生數組作為棧的存儲空間
2.使用模板參數決定棧的大容量
部分代碼如下

template <typename T,int N>
class StaticStack:public Stack<T>
{
    protected:
        T m_space[N];//棧的存儲空間
        int m_top;//棧頂標識
        int m_size;//當前棧的大小
    public:
        StaticStack();//初始化成員變量
        int capacity()const;
        //..............
}

完整實現代碼

#include "Stack.h"
#include "Exception.h"

namespace MyLib
{
    template<typename T,int N>
    class StaticStack: public Stack<T>
    {
    protected:
        T m_space[N];//棧存儲空間
        int m_top;//棧頂元素標識
        int m_size;//表示當前棧里面的數據個數
    public:
        StaticStack()//構造函數初始化成員
        {
            m_top=-1;
            m_size=0;
        }

        int capacity()const
        {
            return N;//返回大存儲量
        }

        void push(const T &e)
        {//入棧的操作
            if(m_size<N)
            {
                m_space[m_top+1]=e;
                m_top++;
                m_size++;
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        void pop()
        {
            if(m_size>0)
            {//出棧的操作
                m_top--;
                m_size--;
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        T top() const
        {
            if(m_size>0)
            {
                return m_space[m_top];
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        void clear()
        {
            m_top=-1;
            m_size=0;
        }

        int size()const
        {
            return m_size;
        }
    };
}

二.鏈式棧的實現
A.鏈式棧的設計要點
1.類模板，抽象類Stack的直接子類
2.在內部組合使用LinkList類，實現類的鏈式存儲
3.知道單鏈表成員對象的頭部進行操作
數據結構--棧與隊列
代碼實現如下

#include "Stack.h"
#include "LinkList.h"
namespace MyLib
{
    template <typename T>
    class LinkStack:public Stack<T>
    {
    protected:
        LinkList<T>m_list;
    public:
        void push(const T&e)
        {
            m_list.insert(0,e);
        }

        void pop()
        {
            if(m_list.length()>0)
            {
                m_list.remove(0);
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        T top() const
        {
            if(m_list.length()>0)
            {
                return m_list.get(0);
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        void clear()
        {
            m_list.clear();
        }

        int size() const
        {
            return m_list.length();
        }
    };
}

二.隊列

一.順序隊列的實現
A.隊列的特性
1.先進先出
數據結構--棧與隊列
2.隊列是一種特殊的線性表
3.隊列僅能在線性表的兩端進行操作
a.隊頭：取出數據元素的一端
b.隊尾：插入數據元素的一端
B.隊列的操作
1.創建隊列
2.銷毀隊列
3.情空隊列
4.進隊列
5.出隊列
6.獲取隊頭元素
7.獲取隊列的長度
C.隊列的實現
數據結構--棧與隊列

template <typename T>
class Queue:public Object
{
    public:
        virtual void add(const T&e)=0;
        virtual void remove()=0;
        virtual T front()const=0;
        virtual void clear()=0;
        virtual int length()const=0;
};

隊列的順序實現
數據結構--棧與隊列
D.StaticQueue設計要點
類模板
1.使用原生數組作為隊列的存儲空間
2.使用模板參數決定隊列的大容量

template<typename T,int  N>
class StaticQueue:public Queue<T>
{
    protected:
        T m_space[N];//隊列存儲空間
        int m_front;//隊頭元素
        int m_rear;//隊尾元素
        int m_length;//隊列的長度
    public:
        StaticQueue();//初始化成員變量
        int capacity()const;
        //....

StaticQueue實現要點(循環計數法)
1.關鍵操作
進隊列：m_space[m_rear]=e;m_rear=(m_rear+1)%N
出隊列：m_front=(m_front+1)%N
2.隊列的狀態
隊空:(m_length==0)&&(m_front==m_rear)
隊滿:(m_length==N)&&(m_front==m_rear)
實現代碼如下：

#include "Queue.h"
#include "Exception.h"
//根據存儲空間的分配方式可以分為使用原生數組實現的靜態隊列和使用動態分配的堆空間實現的動態隊列。
namespace MyLib
{
    template <typename T,int N>
    class StaticQueue:public Queue<T>
    {
    protected:
        T m_space[N];//隊列的存儲空間
        int m_front;//隊頭元素的標識
        int m_rear;//隊尾元素的標識
        int m_length;//隊列長度
    public:
        StaticQueue()
        {//初始化成員為0
            m_length=0;
            m_front=0;
            m_rear=0;
            //m_space[N]=0;
        }

        int capacity()const
        {
            return N;
        }

        void add(const T&e)
        {
            if(m_length<N)
            {
                m_space[m_rear]=e;
                m_rear=(m_rear+1)%N;
                m_length++;
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        void remove()
        {
            if(m_length>0)
            {
                m_front=(m_front+1)%N;
                m_length--;
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        T front()const
        {
            if(m_length>0)
            {
                return m_space[m_front];
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        void clear()
        {
            m_front=0;
            m_rear=0;
            m_length=0;
        }

        int length()const
        {
            return m_length;
        }
    };
}

二.隊列的鏈式存儲實現
數據結構--棧與隊列
A.鏈式隊列的設計要點
1.類模板，抽象父類Queue的直接子類
2.在內部使用鏈式結構實現元素的存儲
3.只在鏈表的頭部和尾部進程操作
數據結構--棧與隊列
完整的實現代碼如下

#include "Queue.h"
#include "LinkList.h"
#include  <iostream>

using namespace std;

namespace MyLib
{
    template<typename T>
    class LinkQueue:public Queue<T>
    {
    protected:
        LinkList<T>m_list;
    public:
        LinkQueue()
        {

        }

        void add(const T&e)
        {
            m_list.insert(e);
        }

        void remove()
        {
            if(m_list.length()>0)
            {
                m_list.remove(0);
            }
            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        T front() const
        {
            if(m_list.length()>0)
            {
                return m_list.get(0);
            }

            else
            {
                THROW_EXCEPTION(InvalidOperationException,"...");
            }
        }

        void clear()
        {
            m_list.clear();
        }

        int length() const
        {
            return m_list.length();
        }
    };
}

小結：
1.棧是一種特殊的線性表
2.棧只允許在線性表的一端進行操作
3.StaticStack使用原生數組作為內部存儲空間
4.StaticStack的大容量由模板參數決定
5.鏈式棧的實現組合使用了單鏈表的對象
6.在單鏈表的頭部進行操作能夠實現高效的入棧和出棧操作
7.是一種特殊的線性表，具有先進先出的特性
8.隊列只允許在線性表的兩端進行操作，一端進，一端出
9.StaticQueue使用原生數組作為內部存儲空間
10.StaticQueue的大容量由模板參數決定
11.StaticQueue采用循環計數法提高隊列操作的效率

另外有需要云服務器可以了解下創新互聯scvps.cn，海內外云服務器15元起步，三天無理由+7*72小時售后在線，公司持有idc許可證，提供“云服務器、裸金屬服務器、高防服務器、香港服務器、美國服務器、虛擬主機、免備案服務器”等云主機租用服務以及企業上云的綜合解決方案，具有“安全穩定、簡單易用、服務可用性高、性價比高”等特點與優勢，專為企業上云打造定制，能夠滿足用戶豐富、多元化的應用場景需求。

分享題目：數據結構--棧與隊列-創新互聯
文章網址：http://vcdvsql.cn/article36/ddpepg.html

成都網站建設公司_創新互聯，為您提供移動網站建設、電子商務、營銷型網站建設、微信公眾號、全網營銷推廣、網站維護

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯

網站建設網站維護公司