数据结构---栈、队列、递归

数据结构之栈、队列、递归

文章目录

  • 数据结构之栈、队列、递归
    • 一、栈
    • 二、队列
    • 三、递归
    • 四、LeetCode练习题(未完待续···)

一、栈

  • 1.用数组实现一个顺序栈
  • 2.用链表实现一个链式栈
  • 3.编程模拟实现一个浏览器的前进、后退功能

1.1用数组实现一个顺序栈

  • 栈是一种特殊的线性表,插入和删除操作只能在栈顶进行,具有后进先出(LIFO)的特点。栈的实现,有两种存储结构,分别是顺序存储结构和链式存储结构。
  • 下面,就用数组实现栈的顺序存储结构。
template
class ArrayStack
{
    public:
            ArrayStack();         //创建栈
            ~ArrayStack();        //销毁栈
            void push(T t);       //向栈顶添加一个t元素  
            T peek();             //向栈中取出栈顶元素
            T pop();             //在栈中删除栈顶元素
            int size();          //大小
            int isEmpty();       //判断是否为空
    private:
            T *arr;
            int count;
};

//创建栈,默认大小是20
template
ArrayStack::ArrayStack()
{
    arr=new T[20];
    if(!arr){
        cout<<"arr malloc error"<
ArrayStack::~ArrayStack()
{
    if(arr){
        delete []arr;
        arr=NULL;
    }
}

//向栈顶添加一个元素
template
void ArrayStack::push(T t)
{
    arr[count++]=t;
}

//返回栈顶元素
template
T ArrayStack::peek()
{
    return arr[count-1];
}

//删除栈顶元素,并返回其值
template
T ArrayStack::pop()
{
    int num=arr[count-1];
    count--;
    retutn num;
}

//返回栈的大小
template
int ArrayStack::size()
{
    return count;
}

//判断栈是否为空
template
int ArrayStack::isEmpty()
{
    return size()==0;
}

1.2 用链表实现一个链式栈

  • note:链栈是借用单链表实现的栈。其不同于顺序栈之处在于:

1、链栈的空间是程序运行期间根据需要动态分配的,机器内存是它的上限。而顺序栈则是

静态分配内存的。

2、链栈动态分配内存的特性使得它一般无需考虑栈溢出的问题。

  • 下面用链表实现栈的链式存储结构
//
typedef struct Node
{
    int data;
    struct Node *link;
}node,*pnode;

//基本操作
pnode createStack();             //创建一个空栈
void push(pnode top,int data);   //入栈
void pop(pnode top);             //出栈
int isEmpty(pnode top);          //判断是否为空栈

//创建一个空栈
pnode createStack()
{
    pnode top=(pnode)malloc(sizeof(node));
    if(top==NULL){
        cout<<"Error"<link=NULL;
    }
    
    return top;
}

//判断是否为空栈
int isEmpty(pnode top)      
{
	if(top->link == NULL)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

//入栈
void push(pnode top)
{
    pnode pnew=(pnode)malloc(sizeof(node));
    if(pnew==NULL){
        cout<<"error"<data=data;
    pnew->link=top->link;
    top->link=pnew;
}

//出栈
void pop(pnode top)
{
    if(!isEmpty(top)){
        cout<<"Stack is Empty"<link;
        top->link=tmp->link;
        free(tmp);
        cout<<"Success"<

1.3编程模拟实现一个浏览器的前进、后退功能

  • 思路:使用两个栈a和b实现。将先浏览的网页依次压栈存入a栈中,当后退时,网页再依次从a栈中弹出,依次压栈进入b栈中;当网页前进时,在从b栈中出栈取出数据,放入a栈中。若a栈中为空时,说明没有页面可以继续后退浏览了;当b栈为空时,说明没有页面可以进行前进浏览了。

  • 代码

由于能力有限,代码没有实现,待向各位大佬学习后再给出~

二、队列

  • 1.用数组实现一个顺序队列
  • 2.用链表实现一个链式队列
  • 3.实现一个循环队列

2.1用数组实现一个顺序队列

//队列的顺序存储

#define MaxSize 20

typedef struct
{
    int data[MaxSize];          //数组
    int front,rear;             //队头,队尾
}SqQueue;

//初始化队列
void initQueue(SqQueue* &q)
{
    q=(SqQueue*)malloc(sizeof(SqQueue));
    q->front=q->rear =-1;
}

//销毁队列
void destroy(SqQueue* &q)
{
    free(q);
}

//判断队空
bool queueEmpty(SqQueue* q)
{
    if(q->front == q->rear)
        printf("Empty\n");
    else
        printf("Not Empty\n");
    return (q->front == q->rear);
}

//队列的特点:队头出队;队尾进队
//进队
bool enQueue(SqQueue* &q,int e)
{
    if(q->rear == MaxSize -1)
        return false;
    q->rear++;
    q->data[q->rear] = e;
    return true;
}

//出队
bool deQueue(SqQueue* &q,int &e)
{
    if(q->front == q->rear)
        return false;
    q->front++;
    e=q->data[q->front];
    return true;
}

2.2用链表实现一个链式队列

//用单链表实现链队

//数据结点
typedef struct qnode
{
    int data;
    struct qnode* next;
    
}DataNode;
//链队头结点
typedef struct
{
    DataNode* front;
    DataNode* rear;
}LinkQnode;

//初始化
void initQueue(LinkQnode* &q)
{
    q=(LinkQnode*)malloc(sizeof(LinkQnode));
    q->front=q->rear=NULL;
}

//销毁队列
void destoryQueue(LinkQnode* &q)
{
    DataNote* pre=q->front;        //pre指向队首结点
    DataQnode *p;
    if(pre!=NULL)
    {
        p=pre->next;
        while(p!=NULL)
        {
            free(pre);
            pre=p;
            p=p->next;
        }
        free(pre);                  //释放最后一个链队结点
    }
    free(q);                        //释放链队结点
    
}

//判断队空
bool QueueEmpty(LinkQnode* q)
{
    if(q->rear==NULL || q->front==NULL)
        printf("Empty\n");
    else
        printf("not Empty\n");
    return (q->rear ==NULL);
}

//队的长度
int getSize(LinkQnode* q)
{
    int size=0;
    DataNode *p=q->front;
    while(p)
    {
        size++;
        p=p->next;
    }
    return size;
}

//进队
void push(LinkQnode* &q,int e)
{
    DataQnode* p;
    p=(DataQnode*)malloc(sizeof(DataNode));
    p->data=e;
    p->next=NULL:
    if(q->rear==NULL)          //若队为空,则新结点既是首结点又是尾结点
    {
        q->front=q->rear=p;
    }
    else
    {
        q->rear->next=p;        //将p链到队尾
        q->rear=p;              //尾结点变成p
    }
}

//出队
bool pop(LinkQnode* &q,int &e)
{
    DataNode *t;
    if(q->rear==NULL)           //队空报错
        return false;
    t=q->front;                 //t指向队首
    if(q->front==q->rear)       //若队中只有一个结点
    {
        q->front=q->rear=NULL;
    }
    else
    {
        q->front=q->front->next;
    }
    e=t->data;
    free(t);
    return true;
}

//遍历队列
void printQueue(LinkQnode* q)
{
    DataNode *p=q->front;
    while(p)
    {
        printf("%d ",p->data)
        p=p->next;
    }
    
}

2.3实现一个循环队列

循环队列:使顺序队列的首尾相连,解决了顺序队列假溢出的问题

  • 循环队列特点:
  • 队头指针的计算: front=(front+1)%MaxSize
  • 队尾指针的计算: rear=(rear+1)%MaxSize
  • 队空:q->rear=q->front
  • 队满:(q->rear+1)==q->front
//
//队列的顺序存储

#define MaxSize 20

typedef struct
{
    int data[MaxSize];          //数组
    int front,rear;             //队头,队尾
}SqQueue;

//初始化队列
void initQueue(SqQueue* &q)
{
    q=(SqQueue*)malloc(sizeof(SqQueue));
    q->front=q->rear =0;
}

//销毁队列
void destroy(SqQueue* &q)
{
    free(q);
}

//判断队空
bool queueEmpty(SqQueue* q)
{
    if(q->front == q->rear)
        printf("Empty\n");
    else
        printf("Not Empty\n");
    return (q->front == q->rear);
}


//进队
bool enQueue(SqQueue* &q,int e)
{
    if((q->rear+1)%MaxSize == q->front)   //队满
        return false;
    q->rear=(q->rear+1)%MaxSize;
    q->data[q->rear] = e;
    return true;
}

//出队
bool deQueue(SqQueue* &q,int &e)
{
    if(q->front == q->rear)            //队空
        return false;
    q->front=(q->front+1)%MaxSize;
    e=q->data[q->front];
    return true;
}

三、递归

  • 1.编程实现斐波那契数列求值 f(n)=f(n-1)+f(n-2)
  • 2.编程实现求阶乘 n!
  • 3.编程实现一组数据集合的全排列

Note:递归思想
递归就是一个大问题可以转化为规模较小的与之相似的子问题,解决大问题的方法和解决小问题的方法相同,所以就有了递归函数就是函数调用自身的说法。另外递归还要有明显的结束条件,避免无限递归下去。

3.1编程实现斐波那契数列求值 f(n)=f(n-1)+f(n-2)

//斐波那契数列求值 f(n)=f(n-1)+f(n-2)

//递归实现
int f(int n)
{
    int sum;
    //出口
    if(n==1 || n==2)
        return n;
    else
        sum=f(n-1)+f(n-2);
    return sum;
}

3.2编程实现求阶乘 n!

//递归实现求阶乘 n!

int f(int n)
{
    //递归出口:0!=1;1!=1
    if(n==0 || n==1)
        return 1;
    return n*f(n-1);
}

3.3编程实现一组数据集合的全排列

#include
using namespace std;

//递归实现全排列

//list数组存放排列的数,k表示排列到第几个,m表示数组最大长度
void perm(int list[],int k,int m)
{
    if(k==m)                             //出口  k=m时表示到最后,输出排列
    {
        for(int i=0;i<=m;i++)
            cout<

四、LeetCode练习题(未完待续···)

4.1栈

  • 4.1.1 Valid Parentheses(有效的括号)
    题目链接
//此题就是括号的模式匹配问题
//用栈实现

class Solution {  
public:  
    bool isValid(string s) {  
        stack st;  
        for (char& c : s) {  
            switch (c) {  
                case '(':   
                case '{':   
                case '[': st.push(c); break;  
                case ')': if (st.empty() || st.top()!='(') return false; else st.pop(); break;  
                case '}': if (st.empty() || st.top()!='{') return false; else st.pop(); break;  
                case ']': if (st.empty() || st.top()!='[') return false; else st.pop(); break;  
                default: ; 
            }  
        }  
        return st.empty() ;  
    }  
};
  • 4.1.2 Longest Valid Parentheses(最长有效的括号)
  • 4.1.3 Evaluate Reverse Polish Notatio(逆波兰表达式求值)

4.2队列

  • 4.2.1 Design Circular Deque(设计一个双端队列)
  • 4.2.2 Sliding Window Maximum(滑动窗口最大值)

4.3递归

  • 4.3.1Climbing Stairs(爬楼梯)

你可能感兴趣的:(C++,数据结构)