数据结构--顺序表、链表、栈

最新推荐文章于 2024-08-09 20:16:54 发布
最新推荐文章于 2024-08-09 20:16:54 发布
阅读量196 收藏 2
点赞数 2
文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53455348/article/details/120598523
版权

此代码为笔者数据结构作业，仅供学习使用。

1、顺序表

#include <iostream>
#include <cassert>
#include <cstdlib>
#include <ctime>

using namespace std;

const int defaultSize = 100;
template<class T>
class SeqList
{
private:
    T* data;//指向动态内存分配数组的指针
    int maxSize;//动态内存分配数组的容量
    int last;//标识顺序表中最后一个元素的位置(反映顺序表中的元素个数)
    void Resize(int newSize);
public:
    SeqList(int sz=defaultSize);//构造函数
    SeqList(const SeqList<T>& L);//拷贝构造函数
    SeqList& operator=(const SeqList<T>& L);//赋值运算符函数

    ~SeqList();//析构函数

    int Size() const;//返回顺序表的容量
    int Length() const;//返回顺序表中元素的个数
    bool IsEmpty() const;//顺序表是否为空
    bool IsFull() const;//顺序表是否为满
    bool Locate(int i) const;//检验顺序表中是否存在第i个元素
    bool GetData(int i, T& x) const;//获取顺序表中第i个位置的元素
    void SetData(int i, T& x);//将顺序表中第i个位置的元素赋值为x

    int Search(T & x) const;//在顺序表中搜索x
    bool Insert(int i, const T& x) ;//在顺序表的第i个元素的位置插入x
    bool Remove(int i, T&x) ;//删除顺序表第i个位置的元素

    void Sort() ;//对顺序表中元素进行排序
    void Reverse ();//逆置顺序表中的元素
    template<class _T>
    friend istream& operator>>(istream& in, SeqList<_T> & L);//输入运算符重载
    template<class _T>
    friend ostream& operator<<(ostream& out, const SeqList<_T>& L);//输出运算符重载

    T & operator[] ( int index );
    const T & operator[] ( int index ) const;
    void Push_Back ( const T& x);
    void Pop_Back( );
    typedef T * iterator;
    typedef const T * const_iterator;
    iterator Begin( )
    {
        return &data[0];
    }
    const_iterator Begin( ) const
    {
        return &data[0];
    }
    iterator End( )
    {
        return &data[ Length() ];
    }
    const_iterator End( ) const
    {
        return &data[ Length() ];
    }
};
template<class T>
SeqList<T>::SeqList(int sz)
{

    this->maxSize = sz;

    this->data = new T[maxSize];

    if(data==NULL)
    {
        exit(1);
    }
    else
    {
        cout<<"distribute successfully！"<<endl;
    }

    this->last = -1;

}
template<class T>
void SeqList<T>:: Resize(int newSize)
{
    if(newSize<last+1)
        return;
    else
        this->maxSize = newSize;


    T tempdata = new T[last+1];
    for(int i=0; i<=last; i++)
    {
        tempdata[i] = data[i];
    }
    this->data = new T[newSize];
    if(data==NULL)
    {
        exit(1);
    }
    else
    {
        cout<<"distribute successfully！"<<endl;
    }

    for(int i=0; i<=last; i++)
    {
        this->data = tempdata[i];
    }
}
template<class T>
SeqList<T>:: SeqList(const SeqList<T>& L)
{

    this->maxSize = L.maxSize;
    this->data = new T[maxSize];
    this->last = L.last;
    for(int i=0; i<=last; i++)
        this->data[i] = L.data[i];

}
template<class T>
SeqList<T>&  SeqList<T>::operator=(const SeqList<T>& L)
{

    this->maxSize = L.maxSize;
    delete[] this->data;
    this->data = new T[maxSize];
    if(data==NULL)
    {
        exit(1);
    }
    else
    {
        cout<<"distribute successfully！"<<endl;
    }
    this->last = L.last;
    for(int i=0; i<=last; i++)
        this->data[i] = L.data[i];
    return *this;

}
template<class T>
SeqList<T>::~SeqList()
{

    delete[] this->data;

    this->last = -1;

    this->maxSize=0;

}
template<class T>
int SeqList<T>:: Size() const
{
    return this->maxSize;
}
template<class T>
int SeqList<T>::Length() const
{
    return this->last+1;
}
template<class T>
bool SeqList<T>::IsEmpty() const
{
    if(this->last==-1)
        return true;
    else
        return false;
}
template<class T>
bool SeqList<T>::IsFull() const
{

    if((this->last+1) == this->maxSize)
        return true;
    else
        return false;
}
template<class T>
bool SeqList<T>::Locate(int i) const
{

    if(i<=0||i>last+1)
        return false;
    else
        return true;
}
template<class T>
bool SeqList<T>::GetData(int i, T& x) const
{

    if(i<=0||i>this->last+1)
        return false;
    else
        x = this->data[i-1];
    return true;

}
template<class T>
void SeqList<T>::SetData(int i, T& x)
{
    if(i>0&&i<=this->maxSize)
    {
        this->data[i-1] = x;
        return;
    }
    else  if(i==maxSize+1)
    {
        T* temp=new T[last];

        if(temp==NULL)
        {
            exit(1);
        }
        else
        {
            cout<<"distribute successfully！"<<endl;
        }

        for(int j=0; j<last+1; j++)
        {
            temp[j] = this->data[j];
        }
        this->data = new T[maxSize*3];
        if(data==NULL)
        {
            exit(1);
        }
        else
        {
            cout<<"distribute successfully！"<<endl;
        }

        this->maxSize = 3*maxSize;
        for(int j=0; j<last+1; j++)
        {
            this->data[j] = temp[j];
        }
        this->data[i-1]=x;
        last++;
        return;
    }
    else
        exit(1);
}
template<class T>
int SeqList<T>::Search(T & x) const
{

    for(int i=0; i<=this->last; i++)
    {

        if(this->data[i]==x)
            return i+1;
    }
    return false;
}
template<class T>
bool SeqList<T>::Insert(int i, const T& x)
{

    if(i<=0||i>last+1)
        return false;
    else
    {
        for(int j=last; j>=i-1; j--)
        {
            this->data[j+1]=data[j];
        }
        this->data[i-1]=x;
        last++;
        return true;
    }
}
template<class T>
bool SeqList<T>::Remove(int i, T&x)
{

    if(i<=0||i>last+1)
        return false;
    x= this->data[i-1];
    for(int j=i-1; j<last; j++)
        this->data[j]=data[j+1];

    last--;
    return true;

}
template<class T>
void SeqList<T>::Sort()
{

    for(int i=0; i<last+1; i++)
        for(int j=0; j<last; j++)
        {

            if(data[j]>data[j+1])
            {
                T temp=data[j];
                data[j] = data[j+1];
                data[j+1]=temp;
            }
        }
}
template<class T>
void SeqList<T>::Reverse ()
{
    int j=last;
    for(int i=0; i<last/2+1; i++)
    {
        T temp = this->data[i];
        data[i] = data[j-i];
        data[j-i]=temp;
    }
}
template<class _T>
istream& operator>>(istream& in, SeqList<_T> & L)
{
int i =1;

    while(i++!=L.maxSize)
    {
        in>>L.data[++L.last];
        if(getchar()=='\n')
            break;
    }


    return in;
}
template<class _T>
ostream& operator<<(ostream& out, const SeqList<_T>& L)
{

    for(int i=0; i<=L.last; i++)
    {

        out<<L.data[i]<<" ";
    }
    out<<endl;

    return out;

}
int main()
{
    SeqList<int> sList;

    cin>>sList;
    int i, val;
    cin>>i>>val;
    sList.Insert(i,val);
    cout<<sList;
    cin>>i;
    sList.Remove(i,val);
    cout<<sList;
    cin>>val;
    i=sList.Search(val);
    if(i==0)
        cout<<"Not found"<<endl;
    else
        cout<<i<<endl;
    sList.Reverse();
    cout<<sList;
}

2、链表

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
typedef int T;
struct LinkNode //结点定义
{
    T data;//数据域
    LinkNode* next;//链域
    LinkNode(const T& item, LinkNode* ptr=NULL)
    {
        data=item;
        next=ptr;
    }
    LinkNode(LinkNode* ptr=NULL)
    {
        next=ptr;
    }
};
class List
{
private:
    LinkNode * first;
public:
    List()//构造函数
    {
        this->first= new LinkNode();
    }
    List(const T& x)
    {
        this->first = new LinkNode();
        this->first->next = new LinkNode(x);
    }

//      List(int n,);
    List(const List& L)//拷贝构造函数
    {
        LinkNode* q = this->first =new LinkNode();
        for(LinkNode *p=L.first->next; p!=NULL; p=p->next)
        {
            q ->next = new LinkNode(p->data);
            q= q->next;
        }
    }
    List& operator=(const List& L)//赋值运算符函数
    {
        LinkNode* q = this->first =new LinkNode();
        for(LinkNode *p=L.first->next; p!=NULL; p=p->next)
        {
            q ->next = new LinkNode(p->data);
            q= q->next;
        }
        return *this;
    }
    ~List()//析构函数
    {
        this->MakeEmpty();
        delete []first;
    }

    void InputFront(const T& elem)//头插法
    {
        LinkNode *pre = this->first->next;

        LinkNode* newNode = new LinkNode(elem);
        newNode->next = pre;
        this->first->next = newNode;
    }
    void InputRear(const T& elem)//尾插法
    {
        LinkNode* p=NULL;

        for( p=this->first->next; p!=NULL; p=p->next) {}

        p=new LinkNode(elem);


    }

    void MakeEmpty()//清空链表
    {
        LinkNode*p = this->first;

        while(p!=NULL)
        {
            LinkNode*q = p->next->next;
                if(q==NULL)
                    break;
            delete p->next;

            p = q;
        }
    }
    int Length() const//返回链表中结点个数
    {
        LinkNode *pre = first->next;
        int num=0;
        while(pre!=NULL)
        {
            ++num;
            pre=pre->next;
        }
        return num;
    }

    LinkNode* Search(const T& x)//在链表中查找元素x，找到返回它所在结点的地址，否则返回空
    {
        LinkNode * p =first->next;

        while(p->data!=x)
        {
            p=p->next;
            if(p==NULL)
	return;
        }
       
        return p;
    }
    LinkNode* Locate(int i)//返回链表中第i个结点的地址，i取值不合法则返回空
    {

        if(i<=0||i>this->Length())
        {
            cout<<"输入非法！"<<endl;
            return;
        }
        int j=0;
        LinkNode* p = first->next;
        for(j=1; j!=i; j++)
        {
            p=p->next;
        }
        return p;

    }

    bool GetData(int i, T& x)const//获取链表第i个元素，将它赋值给x
    {
        if(i<=0)
        {
            cout<<"输入非法！"<<endl;
            return false;
        }
        int j=0;
        LinkNode* p = first->next;
        for(j=1; j!=i; j++)
        {
            p=p->next;
        }
        x = p->data;
        return true;
    }
    void SetData(int i, const T& x)//设置链表第i个元素为x
    {
        if(i<=0||i>Length())
        {
            cout<<"输入非法！"<<endl;
            return;
        }
        int j=0;
        LinkNode* p = first->next;
        for(j=1; j!=i; j++)
        {
            p=p->next;
        }
        p->data = x;

        return;
    }

    bool Insert(int i, const T& x)//在链表的第i个位置上插入元素x
    {
        if(i<=0)
        {
            cout<<"输入非法！"<<endl;
            return false;
        }
        int j=0;
        LinkNode* p = first;
        for(j=0; j<i-1; j++)
        {
            p=p->next;
        }
        LinkNode* newNode = new LinkNode(x,p->next);
        if(NULL==newNode)
        {
            cout<<"无足够空间可分配"<<endl;
            return false;
        }
        p->next = newNode;
        return true;
    }
    bool Remove(int i, T& x)//删除链表第i个位置的元素，并将它的值赋值给x
    {
        if(i<=0||i>Length())
        {
            cout<<"输入非法！"<<endl;
            return false;
        }
        int j=0;
        LinkNode* p = first->next;
        for(j=1; j!=i-1; j++)
        {
            p=p->next;
        }
        LinkNode *q = p->next->next;
        x = p->next->data;
        delete p->next;
        p->next = q;
        return true;
    }

    bool IsEmpty() const//返回链表是否为空
    {
        return first->next==NULL;
    }
    bool IsFull() const//返回链表是否为满
    {
        return  (new LinkNode)==NULL;
    }
    void CopyList(const List& L)//复制链表
    {
        this->MakeEmpty();
        LinkNode* pre = L.first;
        LinkNode* prev = first;
        while(pre!=NULL)
        {
            prev->next= new LinkNode(pre->next->data);
	pre= pre->next;
        }
    }
    void Sort()//对链表中结点进行排序
    {
        LinkNode * p =first->next;
        LinkNode *q=NULL;
        if(NULL==p)
            return ;

        int num = this->Length();
        int maxIndex=1;

        int Max =0;
        for(int i=1; i<num; i++)
        {
            int j=1;
            Max=0;
            for(; j<num-i+2; j++)
            {
               if(Max<=p->data)
               {
                   maxIndex = j;
                   Max = p->data;
               }
               q=p;
                p=p->next;
            }

            SetData(maxIndex,q->data);
            SetData(num,Max);
        }
    }
    friend ostream& operator<<(ostream& out, const List& L)//输出流运算符重载
    {
        LinkNode * p =L.first->next;
        while(p!=NULL)
        {
            out<<p->data<<" ";
            p=p->next;
        }
        out<<endl;
        return out;
    }
    friend istream& operator>>(istream& in, List& L)//输入流运算符重载
    {
        int x;
        do{

            in>>x;
            L.InputRear(x);
        }
        while(getchar()!='\n');

            return in;
    }
};

int main()
{
    List lst;
    srand(time(NULL));
    for(int i=1; i<=2; i++)
        lst.Insert(i,rand()%50);
    lst.Sort();
    cout<<lst;
    int val;
    lst.Remove(2,val);
    cout<<lst;
    List lst1=lst;
    lst.MakeEmpty();
    lst=lst1;
    cout<<lst;
}

3、循环链表

#include <iostream>
#include <cassert>
 #include <fstream>
using namespace std;
enum InsMod {INF, INR};//头插还是尾插
template <typename T>class CircLinkNode{
public:
	T data;
	CircLinkNode<T> *link;
	CircLinkNode(CircLinkNode<T> *ptr = NULL){//建立空结点
		link = ptr;
	}
	CircLinkNode(const T &item, CircLinkNode<T> *ptr = NULL){//建立非空结点
		data = item;
		link = ptr;
	}
};

template <typename T>class CircList{
public:
	CircList()
	{
	    this->first = new CircLinkNode<T>();
	    first->link=first;

        last=first;
	}
	CircList(CircList<T> &L)//复制一个环链表
	{
	    CircLinkNode<T>* p = L.first->link;
	    CircLinkNode<T>*q = this->first->link;
	    while(p!=first)
        {
            q= new CircLinkNode<T>(p->data);
            q=q->link;
            p=p->link;
        }
        last = q;
	}
	~CircList()
	{
	    this->makeEmpty();
	    delete this->first;
	}
	void makeEmpty()
	{
	    CircLinkNode<T>*p = this->first->link;
	    CircLinkNode<T>*q = p->link;
	    while(p!=first)
        {
            delete p;
            p = q;
            q=q->link;
        }
	}
	int Length()const
	{
	    int num =0;
	    CircLinkNode<T>* p = first->link;

	    while(p!=first)
        {
            ++num;
            p=p->link;
        }
        return num;
	}
	CircLinkNode<T> *Search(T x)
	{
	    CircLinkNode<T>* p = first->link;

	    while(p->data!=x)
        {
            p=p->link;
            if(p==first)
                exit(1);
        }
        return p;
	}
	CircLinkNode<T> *Locate(int i)
	{
	    if(i<1||i>Length())
        {
            exit(1);
        }
        int num=0;
        CircLinkNode<T>*p = first->link;
        while(p!=first)
        {
            ++num;
            if(num==i)
                return p;
            p=p->link;
        }
        return p;
	}
	bool getData(int i,T&x)const
	{
	    if(i<1||i>Length())
        {
            return false;
        }
        int num=0;
        CircLinkNode<T>*p = first->link;
        while(p!=first)
        {
            ++num;
            if(num==i)
                x = p->data;
            p=p->link;
        }
        return true;
	}
	void setData(int i, T &x)
	{
	    if(i<1||i>Length())
        {
            return;
        }
        int num=0;
        CircLinkNode<T>*p = first->link;
        while(p!=first)
        {
            ++num;
            if(num==i)
            p->data=x;
            p=p->link;
        }
	}
	bool Insert(int i, T &x)
	{
        if(i<1||i>Length()+1)
        {
            return false;
        }
        CircLinkNode<T>* p =NULL;
        if(i==1)
            p = first;
        else
	     p = Locate(i-1);

	    CircLinkNode<T>* q = p->link;

	    CircLinkNode<T> *newNode = new CircLinkNode<T>(x);

	    p->link = newNode;

	    newNode->link = q;
        if(i==Length()+1)
        {
        last = newNode;
        }
	    return true;

	}
	bool Remove(int i, T &x)
	{
        if(i<=0||i>Length())
        {
            return false;
        }
        int j=0;
        CircLinkNode<T>* p = first;
        for(j=1; j<i; j++)
        {
            p=p->link;
        }
        CircLinkNode<T> *q = p->link->link;
        x = p->link->data;
        if(i==Length())
            last = p;
        delete p->link;
        p->link = q;
        return true;
	}
	bool IsEmpty()const
	{
	    return first->link==last;
	}
	bool IsFull()const
	{
	    return (new CircLinkNode<T>() )==NULL;
	}
	void Sort()
	{
        CircLinkNode<T> * p =first->link;
        CircLinkNode<T> *q=NULL;
        if(NULL==p)
            return ;

        int num = this->Length();
        int maxIndex=1;

        int Max =p->data;
        for(int i=1; i<num; i++)
        {
            int j=1;
            for(; j<num-i+2; j++)
            {
               if(Max<=p->data)
               {
                   maxIndex = j;
                   Max = p->data;
               }
               q=p;
                p=p->link;
            }

            setData(maxIndex,q->data);
            setData(num,Max);
        }
	}
	void Inverse()//不要返回
	{
        int num = this->Length();
        for(int i=1; i<num/2+1; i++)
        {
            int j=num-i+1;
            CircLinkNode<T> * p = Locate(i);
            CircLinkNode<T>* q = Locate(j);

            T temp = p->data;
            p->data = q->data;
            q->data = temp;
        }
	}
	void input(T endTag, InsMod im = INR)
	{
	    if(im==INR)
        {
        Insert(Length()+1,endTag);
        }
        else{
        Insert(1,endTag);
        }
	}
	void output()
	{
	    CircLinkNode<T>* p =first->link;

	    while(p!=first)
        {
          cout<<p->data<<" ";

          p=p->link;
        }
        cout<<endl;
	}
	CircList<T> &operator = (CircList<T> &L)
	{
	    this->makeEmpty();

    CircLinkNode<T>* q =  L.first->link;
    while(q!=L.first)
    {
        input(q->data,INR);
        q=q->link;
    }

	}
	friend ostream& operator << (ostream &out, CircList<T> &L){
		CircLinkNode<T> *current = L.first->link;
		while (current != L.first){
			out << current->data <<'\t';
			current = current->link;
		}
		out<<endl;
		return out;
	}
	friend istream& operator >> (istream &in, CircList<T> &L){//重新输入数据，向后生成
		T val;
		L.makeEmpty();//先清空
		while (!in.eof()){
			in >> val;
			L.last->link = new CircLinkNode<T>(val);
			assert(L.last->link);
			L.last = L.last->link;
		}
		L.last->link = L.first;
		in.clear();//当以ctrl_Z结束，流关闭，必须重新打开
		return in;
	}
protected:
	CircLinkNode<T> *first, *last;
	void inputFront(T endTag);
	void inputRear(T endTag);
};


int main(){
	CircList<int> list;
	ifstream fin("D:\\cb代码\\Data&Structure\\list.txt");
	//assert(fin);
	fin >> list;
	cout << "The initial list in the file is:\n" << list << endl;
	list.Inverse();
	cout << "Inverse the list, then the list is:\n" << list << endl;

	cout << "========================================\n";
	int i, elem;
	cout << "Test the Insert, Remove and Search function:\n";
	cout << "Each test will terminate by an invaid input.";
	cout << "\n----------------------------------------\n";

	cout << "1. Test the Insert(int i, T &elem):\n";
	while (1){
		cout << "Input the index i and data elem to insert: ";
		cin >> i >> elem;
		if (!cin){//流不正常

			cin.clear();//恢复正常
			cin.ignore(100,'\n');
			break;
		}
		if (i < 0)	break;
		if (list.Insert(i, elem)) cout << "Insert successful!\n";
		else	cout << "Insert failed!\n";
	}
	cout << "\nAfter inserted\n" << list << endl;

	cout << "----------------------------------------\n";
	cout << "2. Test the Remove(int i, T &elem):\n";
	while (1){
		cout << "Input the index i in which you want to remove: ";
		cin >> i;
		if (!cin){
			cin.clear();
			cin.ignore(100,'\n');
			break;
		}
		if (i < 0)	break;
		if (list.Remove(i, elem))	cout << "The element " << elem << " has been removed!\n";
		else	cout << "Remove failed!\n";
	}
	cout << "\nAfter removed\n" << list << endl;

	cout << "----------------------------------------\n";
	cout << "3. Test the Search(T &elem):\n";
	while (1){
		cout << "Input the element you want to search: ";
		cin >> elem;
		if (!cin){
			cin.clear();
			cin.ignore(100,'\n');
			break;
		}
		if (elem < 0)	break;
		CircLinkNode<int> *p = list.Search(elem);
		if (p)	cout << "The element " << elem << " is in the list.\n";
		else cout << "The element is not exist!\n";
	}
	cout << "\n----------------------------------------\n";
	cout << "End test!" << endl;
	return 0;
}

4、双向循环链表

#include <iostream>

using namespace std;

template<typename Type>
struct DoubleLinkNode
{
      Type data;
      DoubleLinkNode<Type>* lLink;
      DoubleLinkNode<Type>* rLink;
      DoubleLinkNode(DoubleLinkNode<Type>* pre=NULL,DoubleLinkNode<Type>*suc=NULL)
      {
            lLink=pre;
            rLink=suc;
      }
      DoubleLinkNode(const Type& elem, DoubleLinkNode<Type>* pre=NULL,DoubleLinkNode<Type>* suc=NULL)
      {
            data=elem;
            lLink=pre;
            rLink=suc;
      }
};
template<typename Type>
class CircleDoubleLinkedList
{
private:
      DoubleLinkNode<Type>* first;
public:
      CircleDoubleLinkedList()
      {
          first = new DoubleLinkNode<Type>();
          first->rLink = first;
          first->lLink = first;
      }
      void MakeEmpty()
      {
          DoubleLinkNode<Type>* p = first->rLink;
          DoubleLinkNode<Type>* q = p;
          while(p->rLink!=first)
          {
              q = p->rLink;
              delete p;
              p = q;
          }

      }

      ~CircleDoubleLinkedList()
      {
          this->MakeEmpty();
          delete first;
      }
      int Length()
      {
          int num=0;
          DoubleLinkNode<Type>* p  = first->rLink;
          while(p!=first)
          {
              ++num;
              p=p->rLink;
          }
          return num;
      }
      void InputRear(const Type& elem)
      {
        Insert(Length()+1,elem,1);
      }
       void CopyList(const CircleDoubleLinkedList<Type>& lst)
       {
           this->MakeEmpty();
           DoubleLinkNode<Type>* p  = lst->first->rLink;

           DoubleLinkNode<Type>* q = first->rLink;

           while(p!=first)
           {
               q = new DoubleLinkNode<Type>(p->data);
               p=p->rLink;

               q=q->rLink;
           }
       }
      CircleDoubleLinkedList(const CircleDoubleLinkedList<Type>& lst)
      {
        DoubleLinkNode<Type>* p  = lst->first->rLink;

        DoubleLinkNode<Type>* q =  first->rLink;

           while(p!=first)
           {
               DoubleLinkNode<Type>* newNode =  new DoubleLinkNode<Type>(p->data,q->lLink,q->rLink);
               p=p->rLink;
               q = newNode;
               q=q->rLink;
           }
      }
      CircleDoubleLinkedList<Type>& operator=(const CircleDoubleLinkedList<Type>& lst)
      {
          CopyList(lst);
          return *this;
      }
      DoubleLinkNode<Type>* Locate(int loc, int sign)
      {
        if(loc<1||loc>Length()+1)
            exit(1);
        DoubleLinkNode<Type>* p = first;
          int num=0;
          if(sign)
          {
              p=p->rLink;
              while(p!=first)
              {
                  ++num;
                  if(loc==num)
                    return p;
                  p=p->rLink;
              }
          }else
          {
                p=p->lLink;
              while(p!=first)
              {
                  ++num;
                  if(loc==num)
                    return p;
                  p=p->lLink;
              }
          }
          return p;
      }
      bool Insert(int loc, const Type& elem,int sign)
      {
          if(loc<1||loc>Length()+1)
            return false;

              DoubleLinkNode<Type>* p = Locate(loc,sign);
              DoubleLinkNode<Type>* newNode = new DoubleLinkNode<Type>(elem);

              newNode->lLink = p->lLink;
              p->lLink->rLink = newNode;
              newNode->rLink = p;
              p->lLink = newNode;

        return true;

      }
      bool Remove(int loc, Type& elem, int sign)
      {
          DoubleLinkNode<Type>* p = Locate(loc,sign);

          p->lLink->rLink=p->rLink;
          p->rLink->lLink = p->lLink;
          delete p;
          return true;
      }
      DoubleLinkNode<Type>* Search(const Type& elem, int sign) const
      {
          DoubleLinkNode<Type>* p = first;
          if(sign)
          {
              p=p->rLink;

              while(p!=first)
              {
                if(p->data ==elem)
                    return p;
                    p=p->rLink;
              }
          }
          else
          {
              p=p->lLink;
              while(p!=first)
              {
                if(p->data ==elem)
                        return p;
                p=p->lLink;
              }
          }
      }
      bool GetData(int loc, Type& elem, int sign) const
      {
          if(loc<1)
            return false;
            DoubleLinkNode<Type>* p = Locate(loc,sign);
            elem=p->data;
            return true;
      }
      bool SetData(int loc, const Type& elem, int sign)
      {
            if(loc<1)
            return false;
            DoubleLinkNode<Type>* p = Locate(loc,sign);
            p->data=elem;
            return true;
      }
      void OutPut(int sign=0)
      {
          DoubleLinkNode<Type>* p = first;
        if(sign)
        {
            p=p->rLink;
            while(p!=first)
            {
                cout<<p->data<<" ";
                p=p->rLink;
            }
            cout<<endl;
        }
        else{
            p=p->lLink;
            while(p!=first)
            {
                cout<<p->data<<" ";
                p=p->lLink;
            }
            cout<<endl;
        }
      }
};
int main()
{
    CircleDoubleLinkedList<int> lst;
    for(int i=1;i<=10;i++)
    {
          lst.Insert(i,i,1);
    }
    lst.OutPut(0);
    lst.OutPut(1);
    if(lst.Search(5,0))
    {
          cout<<"yes"<<endl;
    }
    else
    {
          cout<<"no"<<endl;
    }
    lst.SetData(10,100,0);
   lst.OutPut();
    int val;
    for(int i=10;i>0;i--)
    {
          lst.Remove(i,val,1);
          lst.OutPut(0);
    }
    return 0;
}

5、静态链表

#ifndef STATICList_H
#define STATICList_H
#include <cassert>
#include <iostream>
using namespace std;

const int defaultSize = 100;
template <typename T>struct SLinkNode{
	T data;
	int link;
};

template <typename T>class StaticList{
	SLinkNode<T> *elem;
	int maxSize;
	int avil;//可用结点链链首下标
	int *freeIndex;
public:
	StaticList(int sz = defaultSize)
	{
	    elem = new SLinkNode<T>[sz];
	    freeIndex = new int[sz];
	    for(int i=0;i<sz;i++)
        {
            elem[i].link = -1;
            elem[i].data = 0;
            freeIndex[i] = 1;
        }
	    maxSize = sz;
	    avil = -1;

	}
	~StaticList()
	{
	    delete[] elem;
	    delete[] freeIndex;
	    maxSize =0;
	    avil = -1;
	}
	int Length()//返回表长
	{
	    int pre = avil;
	    int num=0;
	    while(pre!=-1)
        {
            ++num;
            pre=elem[pre].link;
        }
        return num;
	}
	int Search(T x)//搜索x
	{
	    int pre = avil;
	    while(pre!=-1)
        {
            if(elem[pre].data==x)
                return pre+1;
            pre=elem[pre].link;
        }
        return -1;
	}
	int Locate(int i)//定位第i个元素
	{
	    if(i<1||i>Length())
            return -1;
	    int pre = avil;
	    int num=0;
	    while(pre!=-1)
        {
            ++num;
            if(num==i)
                return pre;
            pre = elem[pre].link;
        }
        return -1;
	}
	bool getelem(int i, T &x)//获取第i个元素的值
	{
	    if(i<1||i>Length())
            return false;
        int num=0;
        int pre = avil;
        while(pre!=-1)
        {
            ++num;
            if(num==i)
            {
                x = elem[pre].data;
                return true;
            }
            pre=elem[pre].link;
        }
        return false;
	}
	bool Append(T x)         //在表尾添加新结点
	{
	    if(maxSize==Length())
            return false;
	    int pre=avil;
	    if(avil!=-1)
        {
	    while(elem[pre].link!=-1)
        {
            pre=elem[pre].link;
        }
        int i=0;
        for(;i<maxSize;i++)
            if(freeIndex[i]==1)
            {
                freeIndex[i] = 0;
                break;
            }
        elem[pre].link=i;
        elem[i].data = x;
        }else
        {
        elem[0].data=x;
        avil=0;
        freeIndex[0]=0;
        }
        return true;
	}
	bool Insert(int i, T x)   //在第i个位置上插入元素x
	{
	    int j=0;
	    for(;j<maxSize;j++)
        if(freeIndex[j]==1)
        {
            freeIndex[j]=0;
            break;
        }
       int ind1 = Locate(i);
       int ind2 = Locate(i-1);
       if(i==1)
        {
        elem[j].link=ind1;
        elem[j].data=x;
        avil=j;
        }
       else{
        elem[j].link=ind1;
        elem[ind2].link=j;
        elem[j].data=x;
       }
	}
	bool Remove(int i)//删除第i个位置上元素
	{
	    if(IsEmpty())
            return false;
       int ind1 = Locate(i);
       int ind2 = Locate(i-1);
        elem[ind1].data=0;
	    elem[ind2].link=elem[ind1].link;
	    elem[ind1].link = -1;
	    freeIndex[ind1]=1;
	    return  true;
	}
	bool IsEmpty()//判断表是否为空
	{
	    return avil==-1;
	}
	void output(int type = 0)//按指定格式输出
	{
	    int pre = avil;
	    if(type==0)
        {
            while(pre!=-1)
            {
                cout<<elem[pre].data<<" ";
                pre=elem[pre].link;
            }
            cout<<endl;
        }
        else
        {
            for(int i=0;i<maxSize;i++)
              {
                if(elem[i].data>0)
                {
                    cout<<elem[i].data<<" ";
                }

              }
              cout<<endl;
        }
	}
    friend istream& operator >> (istream& in, StaticList<T> &stl){
		T elem;
		while (!in.eof()){//在原链表后添加，与其他线性表不同
			in >> elem;
			stl.Append(elem);
		}
		return in;
	}
	friend ostream & operator<<(ostream &out, StaticList <T> &stl){
		int p = stl.elem[0].link;//elem[0]为附加头结点
		while(p != -1){
			cout << stl.elem[p].elem << endl;
			p = stl.elem[p].link;
		}
		cout << endl;
		return out;
	}
};


#endif
int main(){
	StaticList<int> List(10);
	List.Append(25);
	List.Append(92);
	List.Append(57);
	List.Append(36);
	List.Append(78);
	List.Insert(3, 11);
	List.Insert(1, 49);

	// Print the List
	List.output();
	List.output(1);

	cout << "search 36: " << List.Search(36) << endl;
	cout << "search 25: " << List.Search(25) << endl;
	cout << "search 78: " << List.Search(78) << endl;
	cout << "search 50: " << List.Search(50) << endl;
	cout << endl;

	if (List.Remove(5)){
		cout << "Remove the 5th elem:\n";
		List.output();
		List.output(1);
	}

	List.Append(11);
	cout << "After Insert 11 in the rear:\n";
	List.output();
	List.output(1);
	return 0;
}

6、循环链表

#include <iostream>
#include <cassert>
 #include <fstream>
using namespace std;
enum InsMod {INF, INR};//头插还是尾插
template <typename T>class CircLinkNode{
public:
	T data;
	CircLinkNode<T> *link;
	CircLinkNode(CircLinkNode<T> *ptr = NULL){//建立空结点
		link = ptr;
	}
	CircLinkNode(const T &item, CircLinkNode<T> *ptr = NULL){//建立非空结点
		data = item;
		link = ptr;
	}
};

template <typename T>class CircList{
public:
	CircList()
	{
	    this->first = new CircLinkNode<T>();
	    first->link=first;

        last=first;
	}
	CircList(CircList<T> &L)//复制一个环链表
	{
	    CircLinkNode<T>* p = L.first->link;
	    CircLinkNode<T>*q = this->first->link;
	    while(p!=first)
        {
            q= new CircLinkNode<T>(p->data);
            q=q->link;
            p=p->link;
        }
        last = q;
	}
	~CircList()
	{
	    this->makeEmpty();
	    delete this->first;
	}
	void makeEmpty()
	{
	    CircLinkNode<T>*p = this->first->link;
	    CircLinkNode<T>*q = p->link;
	    while(p!=first)
        {
            delete p;
            p = q;
            q=q->link;
        }
	}
	int Length()const
	{
	    int num =0;
	    CircLinkNode<T>* p = first->link;

	    while(p!=first)
        {
            ++num;
            p=p->link;
        }
        return num;
	}
	CircLinkNode<T> *Search(T x)
	{
	    CircLinkNode<T>* p = first->link;

	    while(p->data!=x)
        {
            p=p->link;
            if(p==first)
                exit(1);
        }
        return p;
	}
	CircLinkNode<T> *Locate(int i)
	{
	    if(i<1||i>Length())
        {
            exit(1);
        }
        int num=0;
        CircLinkNode<T>*p = first->link;
        while(p!=first)
        {
            ++num;
            if(num==i)
                return p;
            p=p->link;
        }
        return p;
	}
	bool getData(int i,T&x)const
	{
	    if(i<1||i>Length())
        {
            return false;
        }
        int num=0;
        CircLinkNode<T>*p = first->link;
        while(p!=first)
        {
            ++num;
            if(num==i)
                x = p->data;
            p=p->link;
        }
        return true;
	}
	void setData(int i, T &x)
	{
	    if(i<1||i>Length())
        {
            return;
        }
        int num=0;
        CircLinkNode<T>*p = first->link;
        while(p!=first)
        {
            ++num;
            if(num==i)
            p->data=x;
            p=p->link;
        }
	}
	bool Insert(int i, T &x)
	{
        if(i<1||i>Length()+1)
        {
            return false;
        }
        CircLinkNode<T>* p =NULL;
        if(i==1)
            p = first;
        else
	     p = Locate(i-1);

	    CircLinkNode<T>* q = p->link;

	    CircLinkNode<T> *newNode = new CircLinkNode<T>(x);

	    p->link = newNode;

	    newNode->link = q;
        if(i==Length()+1)
        {
        last = newNode;
        }
	    return true;

	}
	bool Remove(int i, T &x)
	{
        if(i<=0||i>Length())
        {
            return false;
        }
        int j=0;
        CircLinkNode<T>* p = first;
        for(j=1; j<i; j++)
        {
            p=p->link;
        }
        CircLinkNode<T> *q = p->link->link;
        x = p->link->data;
        if(i==Length())
            last = p;
        delete p->link;
        p->link = q;
        return true;
	}
	bool IsEmpty()const
	{
	    return first->link==last;
	}
	bool IsFull()const
	{
	    return (new CircLinkNode<T>() )==NULL;
	}
	void Sort()
	{
        CircLinkNode<T> * p =first->link;
        CircLinkNode<T> *q=NULL;
        if(NULL==p)
            return ;

        int num = this->Length();
        int maxIndex=1;

        int Max =p->data;
        for(int i=1; i<num; i++)
        {
            int j=1;
            for(; j<num-i+2; j++)
            {
               if(Max<=p->data)
               {
                   maxIndex = j;
                   Max = p->data;
               }
               q=p;
                p=p->link;
            }

            setData(maxIndex,q->data);
            setData(num,Max);
        }
	}
	void Inverse()//不要返回
	{
        int num = this->Length();
        for(int i=1; i<num/2+1; i++)
        {
            int j=num-i+1;
            CircLinkNode<T> * p = Locate(i);
            CircLinkNode<T>* q = Locate(j);

            T temp = p->data;
            p->data = q->data;
            q->data = temp;
        }
	}
	void input(T endTag, InsMod im = INR)
	{
	    if(im==INR)
        {
        Insert(Length()+1,endTag);
        }
        else{
        Insert(1,endTag);
        }
	}
	void output()
	{
	    CircLinkNode<T>* p =first->link;

	    while(p!=first)
        {
          cout<<p->data<<" ";

          p=p->link;
        }
        cout<<endl;
	}
	CircList<T> &operator = (CircList<T> &L)
	{
	    this->makeEmpty();

    CircLinkNode<T>* q =  L.first->link;
    while(q!=L.first)
    {
        input(q->data,INR);
        q=q->link;
    }

	}
	friend ostream& operator << (ostream &out, CircList<T> &L){
		CircLinkNode<T> *current = L.first->link;
		while (current != L.first){
			out << current->data <<'\t';
			current = current->link;
		}
		out<<endl;
		return out;
	}
	friend istream& operator >> (istream &in, CircList<T> &L){//重新输入数据，向后生成
		T val;
		L.makeEmpty();//先清空
		while (!in.eof()){
			in >> val;
			L.last->link = new CircLinkNode<T>(val);
			assert(L.last->link);
			L.last = L.last->link;
		}
		L.last->link = L.first;
		in.clear();//当以ctrl_Z结束，流关闭，必须重新打开
		return in;
	}
protected:
	CircLinkNode<T> *first, *last;
	void inputFront(T endTag);
	void inputRear(T endTag);
};


int main(){
	CircList<int> list;
	ifstream fin("D:\\cb代码\\Data&Structure\\list.txt");
	//assert(fin);
	fin >> list;
	cout << "The initial list in the file is:\n" << list << endl;
	list.Inverse();
	cout << "Inverse the list, then the list is:\n" << list << endl;

	cout << "========================================\n";
	int i, elem;
	cout << "Test the Insert, Remove and Search function:\n";
	cout << "Each test will terminate by an invaid input.";
	cout << "\n----------------------------------------\n";

	cout << "1. Test the Insert(int i, T &elem):\n";
	while (1){
		cout << "Input the index i and data elem to insert: ";
		cin >> i >> elem;
		if (!cin){//流不正常

			cin.clear();//恢复正常
			cin.ignore(100,'\n');
			break;
		}
		if (i < 0)	break;
		if (list.Insert(i, elem)) cout << "Insert successful!\n";
		else	cout << "Insert failed!\n";
	}
	cout << "\nAfter inserted\n" << list << endl;

	cout << "----------------------------------------\n";
	cout << "2. Test the Remove(int i, T &elem):\n";
	while (1){
		cout << "Input the index i in which you want to remove: ";
		cin >> i;
		if (!cin){
			cin.clear();
			cin.ignore(100,'\n');
			break;
		}
		if (i < 0)	break;
		if (list.Remove(i, elem))	cout << "The element " << elem << " has been removed!\n";
		else	cout << "Remove failed!\n";
	}
	cout << "\nAfter removed\n" << list << endl;

	cout << "----------------------------------------\n";
	cout << "3. Test the Search(T &elem):\n";
	while (1){
		cout << "Input the element you want to search: ";
		cin >> elem;
		if (!cin){
			cin.clear();
			cin.ignore(100,'\n');
			break;
		}
		if (elem < 0)	break;
		CircLinkNode<int> *p = list.Search(elem);
		if (p)	cout << "The element " << elem << " is in the list.\n";
		else cout << "The element is not exist!\n";
	}
	cout << "\n----------------------------------------\n";
	cout << "End test!" << endl;
	return 0;
}

7、双向循环链表

#include <iostream>

using namespace std;

template<typename Type>
struct DoubleLinkNode
{
      Type data;
      DoubleLinkNode<Type>* lLink;
      DoubleLinkNode<Type>* rLink;
      DoubleLinkNode(DoubleLinkNode<Type>* pre=NULL,DoubleLinkNode<Type>*suc=NULL)
      {
            lLink=pre;
            rLink=suc;
      }
      DoubleLinkNode(const Type& elem, DoubleLinkNode<Type>* pre=NULL,DoubleLinkNode<Type>* suc=NULL)
      {
            data=elem;
            lLink=pre;
            rLink=suc;
      }
};
template<typename Type>
class CircleDoubleLinkedList
{
private:
      DoubleLinkNode<Type>* first;
public:
      CircleDoubleLinkedList()
      {
          first = new DoubleLinkNode<Type>();
          first->rLink = first;
          first->lLink = first;
      }
      void MakeEmpty()
      {
          DoubleLinkNode<Type>* p = first->rLink;
          DoubleLinkNode<Type>* q = p;
          while(p->rLink!=first)
          {
              q = p->rLink;
              delete p;
              p = q;
          }

      }

      ~CircleDoubleLinkedList()
      {
          this->MakeEmpty();
          delete first;
      }
      int Length()
      {
          int num=0;
          DoubleLinkNode<Type>* p  = first->rLink;
          while(p!=first)
          {
              ++num;
              p=p->rLink;
          }
          return num;
      }
      void InputRear(const Type& elem)
      {
        Insert(Length()+1,elem,1);
      }
       void CopyList(const CircleDoubleLinkedList<Type>& lst)
       {
           this->MakeEmpty();
           DoubleLinkNode<Type>* p  = lst->first->rLink;

           DoubleLinkNode<Type>* q = first->rLink;

           while(p!=first)
           {
               q = new DoubleLinkNode<Type>(p->data);
               p=p->rLink;

               q=q->rLink;
           }
       }
      CircleDoubleLinkedList(const CircleDoubleLinkedList<Type>& lst)
      {
        DoubleLinkNode<Type>* p  = lst->first->rLink;

        DoubleLinkNode<Type>* q =  first->rLink;

           while(p!=first)
           {
               DoubleLinkNode<Type>* newNode =  new DoubleLinkNode<Type>(p->data,q->lLink,q->rLink);
               p=p->rLink;
               q = newNode;
               q=q->rLink;
           }
      }
      CircleDoubleLinkedList<Type>& operator=(const CircleDoubleLinkedList<Type>& lst)
      {
          CopyList(lst);
          return *this;
      }
      DoubleLinkNode<Type>* Locate(int loc, int sign)
      {
        if(loc<1||loc>Length()+1)
            exit(1);
        DoubleLinkNode<Type>* p = first;
          int num=0;
          if(sign)
          {
              p=p->rLink;
              while(p!=first)
              {
                  ++num;
                  if(loc==num)
                    return p;
                  p=p->rLink;
              }
          }else
          {
                p=p->lLink;
              while(p!=first)
              {
                  ++num;
                  if(loc==num)
                    return p;
                  p=p->lLink;
              }
          }
          return p;
      }
      bool Insert(int loc, const Type& elem,int sign)
      {
          if(loc<1||loc>Length()+1)
            return false;

              DoubleLinkNode<Type>* p = Locate(loc,sign);
              DoubleLinkNode<Type>* newNode = new DoubleLinkNode<Type>(elem);

              newNode->lLink = p->lLink;
              p->lLink->rLink = newNode;
              newNode->rLink = p;
              p->lLink = newNode;

        return true;

      }
      bool Remove(int loc, Type& elem, int sign)
      {
          DoubleLinkNode<Type>* p = Locate(loc,sign);

          p->lLink->rLink=p->rLink;
          p->rLink->lLink = p->lLink;
          delete p;
          return true;
      }
      DoubleLinkNode<Type>* Search(const Type& elem, int sign) const
      {
          DoubleLinkNode<Type>* p = first;
          if(sign)
          {
              p=p->rLink;

              while(p!=first)
              {
                if(p->data ==elem)
                    return p;
                    p=p->rLink;
              }
          }
          else
          {
              p=p->lLink;
              while(p!=first)
              {
                if(p->data ==elem)
                        return p;
                p=p->lLink;
              }
          }
      }
      bool GetData(int loc, Type& elem, int sign) const
      {
          if(loc<1)
            return false;
            DoubleLinkNode<Type>* p = Locate(loc,sign);
            elem=p->data;
            return true;
      }
      bool SetData(int loc, const Type& elem, int sign)
      {
            if(loc<1)
            return false;
            DoubleLinkNode<Type>* p = Locate(loc,sign);
            p->data=elem;
            return true;
      }
      void OutPut(int sign=0)
      {
          DoubleLinkNode<Type>* p = first;
        if(sign)
        {
            p=p->rLink;
            while(p!=first)
            {
                cout<<p->data<<" ";
                p=p->rLink;
            }
            cout<<endl;
        }
        else{
            p=p->lLink;
            while(p!=first)
            {
                cout<<p->data<<" ";
                p=p->lLink;
            }
            cout<<endl;
        }
      }
};
int main()
{
    CircleDoubleLinkedList<int> lst;
    for(int i=1;i<=10;i++)
    {
          lst.Insert(i,i,1);
    }
    lst.OutPut(0);
    lst.OutPut(1);
    if(lst.Search(5,0))
    {
          cout<<"yes"<<endl;
    }
    else
    {
          cout<<"no"<<endl;
    }
    lst.SetData(10,100,0);
   lst.OutPut();
    int val;
    for(int i=10;i>0;i--)
    {
          lst.Remove(i,val,1);
          lst.OutPut(0);
    }
    return 0;
}

东北大马猴
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
数据结构与算法-顺序表（链表篇）
09-09
6. **链表的应用**：链表广泛用于各种数据结构，如栈（通过头插法实现）、队列（通过双端操作实现）、哈希表（作为桶的实现）以及二叉树（如AVL树和红黑树）等。 7. **链表的复杂度分析**：链表的基本操作（如插入...
[数据结构]链表的实现（c++/类模板）
Epoch
10-17 3996
#include #include using namespace std; //用struct定义LinkNode类.使用这种方法使该类失去封装性,但简化了描述. //在Link类中把first封装在了其内部,属于该Link的所有LinkNode实例都成为Link实例的私有成员,保证不被外界直接访问. //结点模板的定义 template struct LinkNode { Ty
数据结构之线性表（顺序表、链表、栈、队列）
weixin_52448922的博客
11-28 1001
目录一、线性表1.1 顺序表1.1.1 顺序表的实现1.1.2 顺序表的遍历1.1.3 顺序表的容量可变1.1.4 顺序表的时间复杂度1.1.5 java中ArrayList实现1.2 链表1.2.1 单向链表1.2.1.1 单向链表API设计1.2.1.2 单向链表代码实现1.2.2 双向链表1.2.3 链表的复杂度分析1.2.4 链表反转1.2.5 快慢指针1.2.5.1 中间值问题1.2.5.2 单向链表是否有环问题1.2.5.3 有环链表入口问题1.2.6 循环链表1.2.7 约瑟夫问题 一、线性表
常见的数据结构（顺序表、链表、栈和队列、二叉树）
xiecheng1995的博客
02-29 2699
目录逻辑结构分类存储结构分类线性表线性表的顺序存储线性表的链式存储栈和队列栈队列 逻辑结构分类 线性结构 对于数据结构而言，线性结构是n个数据元素的有序集合。 集合中必存在唯一的一个“第一个元素”； 集合中必存在唯一的一个“最后的元素”； 除最后元素之外，其他数据元素均有唯一的“后继”； 除第一个元素之外，其他数据元素均有唯一的“前驱”。 树形结构（层次结构） 树形结构指的是数据元素之间...
数据结构：顺序表、单链表、栈和队列的简单总结
热门推荐
Keep Fighting All The Time
06-02 1万+
首先，顺序表、链表、栈和队列都属于线性表，都可以采用两种基本的存储结构：顺序存储结构和链式存储结构来存储。结构中的元素之间存在一对一的线性关系。既然，顺序表、链表、栈和队列都属于线性表，那么有必要简单的谈一谈线性表。 线性结构是最常用、最简单的一种数据结构。而线性表是一种典型的线性结构。其基本特点是线性表中的数据元素是有序且是有限的。在这种结构中：① 存在一个唯一的被称为“第一个...
【顺序表和链表】【栈和队列】
TongWu1的博客
09-23 167
栈 先进后出 顺序表实现栈（在尾部插入和弹出，时间复杂度为O(1）） class stack(object): def __init__(self): self.__List = [] def push(self, item): return self.__List.append(item) def pop(self): return self.__List.pop() def size(self): re
数据结构-链表.pdf
08-15
线性数据结构包括线性表、栈、队列、串、数组和文件等，非线性数据结构包括树和图等。链表是线性数据结构的一种特殊类型，它是一种数据元素呈线性关系的数据结构。 线性表的逻辑结构是 n 个数据元素的有限序列，...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
链表是一种线性数据结构，其中元素以节点的形式存储，每个节点包含数据和指向下一个节点的引用。在单链表中，每个节点只有一个指向后继节点的指针，而链表的末尾节点指向null。在C#中，可以使用类`Link`来表示链表...
人工智能-项目实践-python-顺序表、链表、栈、队列、树、Hashmap等数据结构；排序、二分法查找、树遍历等常见算法实现
12-28
人工智能-项目实践-python-顺序表、链表、栈、队列、树、Hashmap等数据结构；排序、二分法查找、树遍历等常见算法实现 顺序表 Python中的list和tuple两种类型采用了顺序表的实现技术 链表 单向链表 双向链表 单向...
单链表-数据结构
qq_31804097的博客
08-07 208
【代码】单链表、双向带头循环链表-数据结构。
常见8种数据结构
qq_43575301的博客
08-08 1807
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 423
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
基础算法模板
2301_79235379的博客
08-08 401
欢迎订阅专栏，数据结构实验，期末大作业，前端后端，算法都有哦，想我发哪个方面的资源或文章可以私信我，免费的哦。
数据结构（学习）2024.8.9（双向链表）
何物爱惜雨的博客
08-09 527
双向链表的创建，插入，遍历，删除
数据结构图书管理系统
2305_78057683的博客
08-07 256
数据结构图书管理系统
「栈」实现LIFO栈（先进后出栈|堆栈|stack）的功能 / 手撕数据结构（C++）
最新发布
dakingffo的博客
08-09 901
​栈，是一种基本的数据结构，也是一种数据适配器。它在底层上以链表方法或动态数组方法实现。本文选择了使用动态数组来实现这种数据结构。
数据结构：二叉树
LCL200356的博客
08-07 988
/创建堆结构int size;}HP;
数据结构（邓俊辉）学习笔记】词典 03—— 排解冲突(1)
weixin_44399845的博客
08-06 835
学习下词条的排解冲突方法
【数据结构】栈篇
2303_79015671的博客
08-07 1061
手把手教你实现栈~
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一...单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

东北大马猴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值