数据结构与算法—顺序表、链接表、顺序栈、链接栈、顺序队列、链接队列的C++代码实现

已于 2023-05-13 19:36:32 修改
阅读量2.1k 收藏 4
点赞数 3
分类专栏： 数据结构与算法 文章标签： c++ 数据结构 链表
于 2023-04-04 22:11:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43978744/article/details/129962813
版权

1、线性表

线性表是一种常见的数据结构，具有以下几个特点：

  • 元素的有限序列：线性表是由有限个元素组成的有序序列，每个元素的位置都是唯一确定的。
  • 线性结构：线性表中的元素只有一个前驱和一个后继，除第一个和最后一个元素外，每个元素都有一个前驱和一个后继。

线性表可以用数组或链表来实现，数组的优点是支持随机访问，但在插入和删除元素时需要移动其他元素，效率较低；链表的优点是支持高效的插入和删除操作，但不支持随机访问。在实际应用中，根据不同的需求和场景，选择合适的实现方式可以提高算法效率和代码可读性。

1.1 顺序表–LinearList.h

#ifndef DATA_STRUCTURE_LINEARLIST_H
#define DATA_STRUCTURE_LINEARLIST_H

#include <iostream>
using namespace std;
template<class T>
class LinearList {
public:
    LinearList(int LLMaxSize);   //构造函数，创建空表
    ~LinearList();     //析构函数，删除表
    LinearList<T>& Insert(int k,const T& x);   //在第k个位置插入元素，返回插入后的空表

    bool IsEmpty() const;     //判断是否为空，表空返会true,表非空返回false
    int GetLength() const;    //返回表中数据元素的个数
    bool GetData(int k,T& x); //将表中第k个元素保存到x中，不存在则返沪false
    bool ModifyData(int k,const T&X);   //将表中第k个元素修改为x,不存在则返回false

    int Find(const T&x);     //返回x在表中的位置，如果x不在表中则返回0
    LinearList<T>& DeleteByIndex(int k,T&x);    // 删除表中第k个元素，并把保存到x中，返回删除后的线性表
    LinearList<T>& DeleteByKey(const T& x,T& y);    // 删除表中关键字为x的元素，并把保存到y中，返回删除后的线性表

    void OutPut(ostream& out) const;   //将线性表放到输出流out中输出
private:
    int length;      //当前数组元素个数
    int MaxSize;    //线性表中的最大元素个数
    T* element;     //一维动态数组
};


//
// Created by 22102 on 2023/3/26.
//

//实现构造函数
template<class T>
LinearList<T>::LinearList(int LLMaxSize){
    MaxSize = LLMaxSize;
    element = new T[LLMaxSize];
    length = 0;
}

//实现析构函数
template<class T>
LinearList<T>::~LinearList(){
    delete []element;
}

//实现插入新数据元素
template<class T>
LinearList<T>& LinearList<T>::Insert(int k,const T& x){
    if(k<1 || k>length+1){
        cout<<"元素下标越界，添加元素失败";
    }else{
        if(length==MaxSize){
            cout<<"此表已满，无法添加新元素";
        }else{
            for(int i=length;i<k-1;i--){
                element[i] = element[i-1];   //移动元素
            }
            element[k-1] = x;
            length++;
        }
    }
    return *this;
}

//实现是否判断为空表
template<class T>
bool LinearList<T>::IsEmpty() const{
    return length==0;
}

//实现求当前表的长度
template<class T>
int  LinearList<T>::GetLength() const{
    return length;
}

//实现按位置取元素
template<class T>
bool LinearList<T>::GetData(int k,T& x){
    if(k<1 || k>length){
        return false;
    }else{
        x = element[k-1];
        return true;
    }
}

//实现按位置修改元素
template<class T>
bool LinearList<T>::ModifyData(int k,const T& x){
    if(k<1 || k>length){
        return false;
    } else{
        element[k-1] = x;
        return true;
    }
}

// 实现按关键字查找
template<class T>
int LinearList<T>::Find(const T&x){
    for(int i=0;i<length;i++){
        if(element[i]==x){
            return i+1;
        }
    }
    return 0;
}

//实现按位置删除
template<class T>
LinearList<T>& LinearList<T>::DeleteByIndex(int k,T&x){
    if(GetData(k,x)){
        for(int i=k-1;i<length-1;i++){   //后面的元素往前移动
            element[i]=element[i+1];
        }
        length--;       //表长度减1
    }else{
        cout<<"元素下标越界，删除失败";
    }
    return *this;
}

//实现按关键字删除
template<class T>
LinearList<T>& LinearList<T>::DeleteByKey(const T& x,T& y){
    int index = Find(x);
    if(index !=0 ){
        return DeleteByIndex(index,y);
    }else{
        cout<<"没有此元素"<<endl;
        return *this;
    }

}

// 实现顺序表的输入
template<class T>
void LinearList<T>::OutPut(ostream& out)const
{
    for(int i=0;i<length;i++)
        out<<element[i]<<endl;
}
// 重载插入运算符 <<
template<class T>
ostream& operator<<(ostream& out,const LinearList<T>& x)
{
    x.OutPut(out);
    return out;
}

#endif //DATA_STRUCTURE_LINEARLIST_H

1.2 单向链表–LinkList.h

#ifndef DATA_STRUCTURE_LINKLIST_H
#define DATA_STRUCTURE_LINKLIST_H
#include <iostream>
using namespace std;
//存储节点类
template<class T>
class LinkNode{

    template<class U>
    friend class LinkList;   //将链式表类声明为友类
public:
    LinkNode(){     //构造函数
        next=NULL;
    }

private:
    T data;           //节点元素
    LinkNode<T>* next;    //指向下一结点的指针
};

//单向来链表类
template<class T>
class LinkList{
public:
    LinkList();    //构造函数
    ~LinkList();   //析构函数

    LinkList<T>& Insert(int k,const T& x);
    bool IsEmpty() const;
    int GetLength() const;
    bool GetData(int k,T& x);
    bool ModifyData(int k,const T&x);

    int Find(const T& x);
    LinkList<T>& DeleteByIndex(int k,T& x);
    LinkList<T>& DeleteByKey(const T& x,T& y);
    void OutPut(ostream& out);

private:
    LinkNode<T>* head;     //指向链表的第一个头结点的指针
};

//构造函数的实现
template<class T>
LinkList<T>::LinkList(){
    //创建空的单向链表
    head = new LinkNode<T>();  //创建头结点
}

//析构函数的实现
template<class T>
LinkList<T>::~LinkList(){
    // 空单向链表
    T x;
    int len = GetLength();
    for(int i=len;i>=1;i--){
        DeleteByIndex(i,x);   //释放所有结点
    }
    delete head;   //释放头结点
}

//实现插入新的数据元素
template<class T>
LinkList<T>& LinkList<T>::Insert(int k,const T& x)
{
    LinkNode<T> *p=head;//p指向头结点
    LinkNode<T> *newNode=new LinkNode<T>;//创建待插入的新结点
    newNode->data=x;
    int len=GetLength();
    if(k<1||k>len+1)
        cout<<"元素下标越界，添加元素失败";
    else
    {
        for(int i=1;i<k;i++){
            p=p->next;
        }
        newNode->next=p->next;
        p->next=newNode;
    }
    return *this;
}

//实现判断是否为空表
template<class T>
bool LinkList<T>::IsEmpty() const {
    return head->next == NULL;
}

//实现求当前链表的长度
template<class T>
int LinkList<T>::GetLength() const {
    int length=0;
    LinkNode<T> *p = head->next;
    while (p){
        length++;
        p = p->next;
    }
    return length;
}

// 实现按位置取元素
template<class T>
bool LinkList<T>::GetData(int k, T &x) {
    LinkNode<T> *p = head->next;
    int index =1;
    if(k<1 || k>GetLength()){
        return false;
    }
    while(p!=NULL && index<k){
        index++;
        p=p->next;
    }
    if(p==NULL){
        return false;
    } else{
        x = p->data;
        return true;
    }
}

//实现按位置修改元素
template<class T>
bool LinkList<T>::ModifyData(int k, const T &x) {
    LinkNode<T>* p = head->next;
    int index =1;
    if(k<1 || k>GetLength()){
        return false;
    }
    while(p!=NULL && index<k){
        index++;
        p = p->next;
    }
    if(p==NULL){
        return false;
    } else{
        p->data =x;
        return true;
    }
}

//实现按关键字查找
template<class T>
int LinkList<T>::Find(const T &x) {
    LinkNode<T>* p =head->next;
    int index =1;
    while (p!=NULL && p->data!=x){
        p = p->next;
        index++;
    }
    if(p!=NULL){
        return index;
    } else{
        return 0;
    }
}

//实现按位置删除
template<class T>
LinkList<T>& LinkList<T>::DeleteByIndex(int k,T& x){
    if(GetData(k,x)){   //判断是否有此元素，如果存在，则将该元素值放入x中，并返回true
        LinkNode<T> *p = head;     //p指向头结点
        LinkNode<T> *q = NULL;    //q指向空指针
        //删除中间或最后的结点
        for(int i=1;i<k;i++){
            p=p->next;         //将p指针移动到第k-1个结点
        }
        q=p->next;    //q指向待删除的第k个结点
        p->next = q->next;   //将第k个结点从链表中移出
        delete q;   //物理删除该结点
    }else{
        cout<<"元素下标越界，删除失败\n";
    }
    return *this;
}

//实现按关键字删除
template<class T>
LinkList<T>& LinkList<T>::DeleteByKey(const T &x, T &y) {
    int index = Find(x);
    if(index !=0){
        return DeleteByIndex(index,y);
    }else{
        cout<<"没有此元素，删除失败\n";
        return *this;
    }
}

// 实现单向链表的输出
template<class T>
void LinkList<T>::OutPut(ostream& out)
{
    LinkNode<T>* p=head->next;
    while(p!=NULL)
    {
        out<<p->data<<endl;
        p=p->next;
    }
}

//重载插入运算符<<
template<class T>
ostream& operator<<(ostream& out,LinkList<T>& x){
    x.OutPut(out);
    return out;
}

2、栈

栈是一种后进先出（Last In First Out，LIFO）的数据结构，也就是说，最后压入栈的元素最先弹出栈。栈只允许在栈顶进行插入和删除操作。由于只有栈顶元素可见，所以栈具有较好的封装性，也就是说，外部无法直接访问栈中的其他元素。常见的应用场景包括表达式求值、函数调用、程序调试等。

2.1 顺序栈–LinearStack.h

#ifndef DATA_STRUCTURE_LINEARSTACK_H
#define DATA_STRUCTURE_LINEARSTACK_H

#include<iostream>
using namespace std;

template<class T>
class LinearStack{
public:
    LinearStack(int LSMaxSize);  //构造函数，创建空栈
    ~LinearStack();  //析构函数，删除栈
    bool IsEmpty();  //判断栈是否为空，空返回true,非空返回false
    bool IsFull();   //判断栈是否为满，满返回true,不满返回false
    int GetElementNumber();   //求栈中元素个数

    bool Push(const T&x);  //在栈顶插入元素x，插入成功返回true,不成功返回false
    bool Top(T& x);        //求栈顶元素的值并将其放入x中，成功返回true,不成功返回false
    bool Pop(T& x);       //从栈顶删除一个元素怒，并将该元素的值放入x中
    void OutPut(ostream& out);    //将顺序栈放到输出流out中输出

private:
    int top;      //用来表示栈底
    int MaxSize;  //栈中最大元素个数
    T* element;   //一维动态数组
};

//实现构造函数
template<class T>
LinearStack<T>::LinearStack(int LSMaxSize){
    MaxSize = LSMaxSize;
    element = new T[LSMaxSize];
    top = -1;
}

//实现析构函数
template<class T>
LinearStack<T>::~LinearStack(){
    delete []element;
}

//实现判断栈是否为空
template<class T>
bool LinearStack<T>::IsEmpty() {
    return top == -1;
}

//实现判断栈是否为满
template<class T>
bool LinearStack<T>::IsFull() {
    return top+1 == MaxSize;
}

//实现进栈
template<class T>
bool LinearStack<T>::Push(const T &x) {
    if(IsFull()){
        return false;
    }else{
        top++;
        element[top]=x;
        return true;
    }
}

//实现求栈顶元素
template<class T>
bool LinearStack<T>::Top(T &x) {
    if(IsEmpty()){
        return false;
    } else{
        x=element[top];
        return true;
    }
}

//实现出栈
template<class T>
bool LinearStack<T>::Pop(T &x) {
    if(IsEmpty()){
        return false;
    }else{
        x=element[top];
        top--;
        return true;
    }
}

//实现顺序栈的输出
template<class T>
void LinearStack<T>::OutPut(ostream &out) {
    for (int i = 0; i < top; ++i) {
        out<<element[i]<<endl;
    }
}

//重载插入运算符<<
template<class T>
ostream& operator<<(ostream& out,const LinearStack<T>& x){
    x.OutPut(out);
    return out;
}
#endif //DATA_STRUCTURE_LINEARSTACK_H

2.2 链接栈–LinkStack.h

#ifndef DATA_STRUCTURE_LINKSTACK_H
#define DATA_STRUCTURE_LINKSTACK_H
#include<iostream>
using namespace std;
//存储结点类
template<class T>
class LinkNode{
    template<class U>      //将链接栈声明为友类.使单向链栈类中的成员函数可以直接访问LinkNode对象中的私有成员。
            friend class LinkStack;
public:
    LinkNode(){    //构造函数
        next =NULL;
    }
private:
    T data;        //结点元素
    LinkNode<T>* next;   //指向下一个结点的指针
};


//单向链接栈类
template<class T>
class LinkStack{
public:
    LinkStack();      //构造函数，创建空栈
    ~LinkStack();    //析构函数，删除栈
    bool IsEmpty() const;   // //判断栈是否为空，空返回true,非空返回false
    bool Push(const T& x);  //在栈顶插入元素x，插入成功返回true,不成功返回false
    bool Top(T& x);      //求栈顶元素的值并将其放入x中，成功返回true,不成功返回false
    bool Pop(T& x);        //从栈顶删除一个元素怒，并将该元素的值放入x中

    void OutPut(ostream& out);   //将链接栈放到输出流out中输出
private:
    LinkNode<T>* top;    //指向链接栈的栈顶点的指针
    int size;    //栈元素个数
};

//实现构造函数
template<class T>
LinkStack<T>::LinkStack(){
    top = NULL;
    size =0;
}

//实现析构函数
template<class T>
LinkStack<T>::~LinkStack(){
    T x;
    while(top!=NULL){    // 栈非空则元素出栈
        Pop(x);
    }
}

//实现判断栈是否为空
template<class T>
bool LinkStack<T>::IsEmpty() const{
    return top==NULL;
}

//实现进栈
template<class T>
bool LinkStack<T>::Push(const T& x){
    LinkNode<T>* p = new LinkNode<T>;
    if(p==NULL){
        return false;
    }else{
        p->data = x;    //为元素辅助
        p->next = top;    //将新结点插入栈顶  (每次都是在头结点处插入)
        top = p;   // top指向栈顶
        size++;
        return true;
    }
}

//实现求栈顶元素
template<class T>
bool LinkStack<T>::Top(T& x){
    if(IsEmpty()){
        return false;
    }else{
        x = top->data;
        return true;
    }
}

//实现出栈
template<class T>
bool LinkStack<T>::Pop(T& x){
    LinkNode<T>* p;
    if(IsEmpty()){    //栈为空，则返回false，元素出栈失败
        return false;
    }else{
        x = top->data;
        p = top;
        top = top->next;
        delete p;       //释放栈顶元素的内存空间
        size--;
        return true;
    }
}

//实现链接栈的输出
template<class T>
void LinkStack<T>::OutPut(ostream& out){
    LinkNode<T>* p;
    p=top;
    for(int i=0;i<size;i++){
        out<<p->data<<endl;
        p=p->next;
    }
}

//重载插入运算符<<
template<class T>
ostream& operator<<(ostream& out,const LinkStack<T>& x){
    x.OutPut(out);
    return out;
}

#endif //DATA_STRUCTURE_LINKSTACK_H

3、队列

队列是一种先进先出（First In First Out，FIFO）的数据结构，也就是说，最先加入队列的元素最先被弹出队列。队列通常分为队头（front）和队尾（rear），只允许在队尾插入元素，在队头删除元素。队列具有较好的顺序性，也就是说，元素的顺序是有意义的。常见的应用场景包括消息队列、任务队列、缓冲区等。

3.1 顺序队列–LinearQueue.h

#ifndef DATA_STRUCTURE_LINEARQUEUE_H
#define DATA_STRUCTURE_LINEARQUEUE_H
#include<iostream>
using namespace std;
template<class T>
class LinearQueue{
public:
    LinearQueue(int LQMaxSize);    //创建空队列
    ~LinearQueue();    //删除队列
    bool IsEmpty();
    bool IsFull();
    bool Insert(const T& x);   //入队，在队列尾部插入元素x
    bool GetElement(T& x);   // 求队头元素的值并放入x中
    bool Delete(T& x);    //进队，从对头删除一个元素，并将该元素的值放入x中

    void OutPut(ostream& out) const;   //输出队列
private:
    int size;   //队列实际元素个数
    int MaxSize;   // 队列最大元素个数
    int front,rear;  // 队列的队头和队尾指针
    T* element;   //一维动态数组
};

//实现构造函数
template<class T>
LinearQueue<T>::LinearQueue(int LQMaxSize) {
    MaxSize = LQMaxSize;
    element = new T[MaxSize];
    size =0;
    front = 0;
    rear =0;
}

//实现析构函数
template<class T>
LinearQueue<T>::~LinearQueue(){
    delete []element;           //释放堆内存空间
};

//实现判断队列是否为空
template<class T>
bool LinearQueue<T>::IsEmpty(){
    return size == 0;
}

//实现是否判断队满
template<class T>
bool LinearQueue<T>::IsFull() {
    return size == MaxSize;
}

//实现入队
template<class T>
bool LinearQueue<T>::Insert(const T &x) {
    if(IsFull()){
        return false;
    } else{
        element[rear] = x;
        rear = (rear+1)%(MaxSize);
        size++;
        return true;
    }
}

//实现求队头元素
template<class T>
bool LinearQueue<T>::GetElement(T &x) {
    if(IsEmpty()){
        return false;
    }else{
        x = element[front];
        return true;
    }
}

//实现出队
template<class T>
bool LinearQueue<T>::Delete(T &x) {
    if(IsEmpty()){
        return false;
    } else{
        x = element[front];
        front = (front+1)%(MaxSize);
        size--;
        return true;
    }
}

//实现顺序队列的输出
template<class T>
void LinearQueue<T>::OutPut(ostream &out) const {
    int index;
    index = front;
    for(int i=0;i<size;i++){
        cout<<element[index]<<endl;
        index = (index+1) % MaxSize;
    }
}

//重载插入运算符<<
template<class T>
ostream& operator<<(ostream& out,LinearQueue<T>& x){
    x.OutPut(out);
    return out;
}
#endif //DATA_STRUCTURE_LINEARQUEUE_H

3.2 链接队列–LinkStack.h

#ifndef DATA_STRUCTURE_LINKQUEUE_H
#define DATA_STRUCTURE_LINKQUEUE_H

#include<iostream>
using namespace std;

//存储结点类
template<class T>
class LinkNode{
    template<class U>
            friend class LinkQueue;
public:
    LinkNode(){
        next = NULL;
    };
private:
    T data;  //结点元素
    LinkNode<T>* next;    //指向下一结点的指针
};


template<class T>
class LinkQueue{
public:
    LinkQueue();
    ~LinkQueue();
    bool IsEmpty();
    bool Insert(const T& x);
    bool GetElement(T& x);
    bool Delete(T& x);

    void OutPut(ostream& out) const;

private:
    int size;
    LinkNode<T>* front,*rear;
};

//实现构造函数
template<class T>
LinkQueue<T>::LinkQueue(){
    front = NULL;
    rear = NULL;
    size = 0;
}

//实现析构函数
template<class T>
LinkQueue<T>::~LinkQueue(){
    T x;
    while(front != NULL){    //队列非空则元素依次出队
        Delete(x);
    }
}

//实现判断队列是否为空
template<class T>
bool LinkQueue<T>::IsEmpty(){
    return size == 0;
}

//实现入队
template<class T>
bool LinkQueue<T>::Insert(const T& x){
    LinkNode<T>* p = new LinkNode<T>;
    if(p==NULL){
        return false;
    }else{
        p->data = x;    //为元素赋值
        // 将新进结点插入队尾
        if(front == NULL){   //插入前是空队列
            rear = p;
            front = p;
        }else{
            rear->next = p;
            rear = p;
        }
        size++;
        return true;
    }
}

//实现求对头元素
template<class T>
bool LinkQueue<T>::GetElement(T& x){
    LinkNode<T>* p;
    if(IsEmpty()){
        return false;
    } else{
        x=front->data;
        return true;
    }
}

//实现出队
template<class T>
bool LinkQueue<T>::Delete(T& x){
    LinkNode<T>* p;
    if(IsEmpty()){
        return false;
    } else{
        p=front;
        x=front->data;
        front = front->next;
        delete p;   //删除队头结点
        size--;
        return true;
    }
}

//实现链接队列的输出
template<class T>
void LinkQueue<T>::OutPut(ostream& out) const{
    LinkNode<T> *p;
    p=front;
    for (int i = 0; i < size; i++) {
        out<<p->data<<endl;
        p=p->next;
    }
}

//重载插入运算符
template<class T>
ostream& operator<<(ostream& out,const LinkQueue<T>& x){
    x.OutPut(out);
    return out;
}
#endif //DATA_STRUCTURE_LINKQUEUE_H

Time:2023.4.4（明天清明节放假一天！！！）
如果上面代码对您有帮助，欢迎点个赞！！！

@硬train一发
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Data-Structure:《数据结构与算法分析》上的代码实现
05-03
《数据结构与算法分析》上的代码实现, 按照该书的章节顺序，主要实现书上给出的例子。 ##已经实现： ###第三章 - 链表 - 栈 - 队列 ###第四章 - 排序二叉树 - 平衡二叉树 - 伸展树（自底向上） - 伸展树（自顶往下）...
C++ 语言学习入门--链表、队列与栈
hz_Oliver_ZHANG的博客
02-20 965
C++入门
数据结构与算法——线性表、顺序表、链表、栈、队列
usunshineboy的博客
01-13 419
一、线性表 前驱元素：若A元素在B元素的前面，则称A为B的前驱元素。 后继元素：若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种一对一的逻辑关系。 1.第一个数据元素没有前驱，这个数据元素被称为头结点； 2.最后一个数据元素没有后继，这个数据元素被称为尾结点； 3.除了第一个元素和最后一个元素外，其他数据元素有且仅有一个前驱和一个后继。 线性表的分类：线性表中数据元素存储的方式可以是顺序存储，也可以是链式存储，按照不同的存储方式可分为顺序表和链表。 1.1顺序表 1.1.1顺
顺序栈基本算法实现及示例(C语言)
qq_46026740的博客
04-11 5438
编写一个程序，实现顺序栈的各种基本算法，并在此基础上设计一个程序完成如下功能： （1）初始化栈s； （2）判断栈s是否为空； （3）依次进栈的元素a,b,c,d,e; （4）判断栈s是否为空； （5）输出出栈序列； （6）判断栈s是否为空； （7）释放栈； #include<stdio.h> #include<malloc.h> #define Maxsize 100 ty...
简述顺序表、链表、栈和队列以及队列实现栈、栈实现队列
八爪大头鱼
08-12 1365
简述顺序表、链表、栈和队列以及队列实现栈、栈实现队列顺序表Vector原理使用方法优点和缺点链表List原理使用方法优点和缺点栈Stack定义和特点使用方法队列定义和特点使用方法队列实现栈原理实现过程代码实现栈实现队列原理实现过程代码实现 顺序表Vector 原理 顺序表存储是将数据元素放到一块连续的内存存储空间，相邻数据元素的存放地址也相邻（逻辑与物理统一）。 使用方法 添加：insert / push_back 删除：erase / pop_back / clear 访问：at / back / beg
数据结构与算法（C语言）代码实现-栈的相关操作代码实现（链栈）
没有简介就是简介
10-07 444
c语言数据结构与算法的代码实现，实现了栈（链栈）的相关操作，例如初始化栈、求栈长度、判断栈是否为空、出栈、入栈、清空栈、销毁栈等操作
数据结构与算法：C++描述
11-10
本书在简要回顾了基本的C++ 程序设计概念的基础上，全面系统地介绍了队列、堆栈、树、图等基本数据结构，以及贪婪算法、分而治之算法、分枝定界算法等多种算法设计方法，为数据结构与算法的继续学习和研究奠定了一...
数据结构算法与应用(C++语言描述).rar
02-28
第二部分 数据结构 第3章 数据描述 75 3.1 引言 75 3.2 线性表 76 3.3 公式化描述 77 3.3.1 基本概念 77 3.3.2 异常类NoMem 79 3.3.3 操作 79 3.3.4 评价 83 3.4 链表描述 86 3.4.1 类ChainNode 和Chain 86 3.4.2 ...
数据结构算法与应用-C++语言描述
10-20
讲述了c++的各种使用的数据结构和算法，对于初学者和已经入门的都很有帮助，里面的内容有 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 ...
数据结构算法与应用-C C++语言描述
11-19
第二部分 数据结构 第3章 数据描述 75 3.1 引言 75 3.2 线性表 76 3.3 公式化描述 77 3.3.1 基本概念 77 3.3.2 异常类NoMem 79 3.3.3 操作 79 3.3.4 评价 83 3.4 链表描述 86 3.4.1 类ChainNode 和Chain 86 3.4.2 ...
(4) 数据结构与算法 ---- 线性表 及Java实现 顺序表、链表、栈、队列
pandaj的专栏
01-02 1552
数据结构与算法是程序设计的两大基础，大型的IT企业面试时也会出数据结构和算法的题目， 它可以说明你是否有良好的逻辑思维，如果你具备良好的逻辑思维，即使技术存在某些缺陷，面试公司也会认为你很有培养价值，至少在一段时间之后，技术可以很快得到提高。同时，它也是软考的重点，我们需要对这部分的内容进行一下总结。        我们先看一下数据结构和算法的整体内容。
C语言实现栈和队列
AllenSquirrel
12-23 1971
栈 栈的理解： 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO (Last In First Out)的原则。压栈:栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈:栈的删除操作叫做出栈。出数据也在栈顶。 ...
顺序表实现栈 链表实现队列
老赵的博客
05-22 183
1.顺序表实现栈结构 ： #pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> //#define N 10 //typedef int STDataType; //typedef struct Stack //{ // STDataType a[N]; // int top; //}ST; typedef int STDataType; typedef struct S
数据结构之线性表、栈与队列(附Java代码)
popofzk的博客
08-27 231
1. 绪论 2. 线性表 ​ 线性表是一种最常用、最简单，也是一种最基本的数据结构，它是学习其他数据结构的基础。 线性表在计算机中可以用{顺序存储链式存储\begin{cases}顺序存储\\链式存储\end{cases}{顺序存储链式存储​两种存储结构来表示，其中，顺序存储的线性表成为顺序表，链式存储的线性表成为链表，链表又分为：{单链表双向链表循环链表\begin{cases} 单链表\\ 双向链表\\ 循环链表\end{cases}⎩⎪⎨⎪⎧​单链表双向链表循环链表​。 特点： 对于同一个线性表，
链表，顺序表的基本操作及其实现的栈与队列
Flanz_Hawk的博客
12-23 543
1，顺序表 在c里面，这一部分也就是静态表和动态表的实现，插入，删除有丁点意思。 静态表靠数组和长度实现（注意长度这一点，因为它反映了当前表内容长度，十分重要） 动态表依靠申请连续空间实现（结构体内部包括首地址，当前规模以及长度） 插入： int *p; p=&(w.a[k-1]); int *q; for(q=&(w.a[w.length-1]);q>=p;--q) {
【C】 初识C语言
努力学习C/C++
04-21 700
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
最新发布
我的博客
04-22 499
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
[C++]异常
m0_62327743的博客
04-19 375
[C++]异常
【动态规划】C++ dp子数组问题（最大/最长：环形/子数组和、乘积最大/为正数、单词拆分、子串）
卜及中的博客
04-22 731
文章介绍了子数组类的dp问题，并通过一系列算法题加深对该类问题的解法理解。
数据结构与算法顺序表
09-06
在数据结构与算法中，我们可以使用顺序表来实现各种常见的算法，比如线性查找、二分查找、插入排序、选择排序等等。 线性查找是一种简单的查找算法，它从顺序表的第一个元素开始逐个比较，直到找到目标元素或者遍历...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值