精华内容
下载资源
问答
  • 上传内容为栈和线性表的基本实现,如有需要,可以在接口不变的情况下改为队列、链表、数组实现。
  • 通过数据结构实现线性表的建立,增加元素,删除元素!
  • 用前面已经实现的线性表来实现一个整数里的数据是整数)。共需要补全三个函数(也是的基本功能):判断空的 empty 函数、压栈的 push 函数的 pop 函数。 相关知识 (stack)又名堆栈,是一种功能...

    用前面已经实现的线性表来实现一个整数栈(栈里的数据是整数)。共需要补全三个函数(也是栈的基本功能):判断栈空的 empty 函数、压栈的 push 函数和弹栈的 pop 函数。

    相关知识

    栈(stack)又名堆栈,是一种功能受限的线性表,具有先进后出的特性。其限制为仅允许在线性表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为栈底。
    向一个栈插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素;
    从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。
    接下来首先声明结构类型:

    // 定义结点结构
    struct node
    {
        int data;  // 数据域
        node * next;  // 指针域,指向下一个结点
    };
    typedef node * intStack;  // 定义类型别名,intStack即相当于node*
    

    其中:定义intStack是为了使程序的可读性更好一些。因为本关是用线性表实现栈,而访问一个线性表其实只需要一个链表头指针就可以了,intStack实际上就是node类型,所以后面可以这样声明栈sk:
    intStack sk = NULL; // 声明栈sk,并初始化为空栈(空线性表)
    实际上sk就是一个node
    类型的指针,用它可以访问一个线性表,也就可以看成一个栈了。
    三个需要用户补全的函数的函数原型分别为:

    1. 判断栈是否为空:函数empty判断栈sk是否为空,为空则返回true,否则返回false;
      bool empty(intStack sk);
    2. 弹栈:函数pop实现从栈sk中弹出栈顶元素,参数sk,传引用,因为弹栈可能会改变sk的值,返回值为弹栈弹出的数据,如果栈空,则返回-1;
      int pop(intStack &sk);
    3. 压栈:函数push实现压栈功能,将n压入栈sk中,参数sk为传引用,因为压栈可能会改变sk的值,由于栈使用链表实现,只要还有内存,压栈都会成功。
      void push(intStack &sk, int n);
      由于前面几关已经实现了线性表的各种功能,而栈只是一种功能受限的线性表而已,所以本关的三个函数都可以利用线性表已有的功能来实现。
      温馨提示:栈只能在栈顶弹出和压入数据,可以选择线性表头或者尾作为栈顶,另一头则为栈底。栈的弹出和压入就转变为线性表一头的删除和插入了。
    #include <iostream>
    #include "mstack.h"
    //#include "linearList.h"
    using namespace std;
    //定义结点结构
    struct node
    {
     int data;  //数据域
     node * next;  //指针域,指向下一个结点
    };
    //函数listLength:计算并返回链表的长度
    //参数:h-链表头指针
    //返回值:链表长度
    int listLength(node * h);
    //函数delHas:删除链表中data为n的结点,如果有多个这样的结点,只删除第一个
    //参数:h-链表头指针,n-结点包含的数据
    //返回值:删除结束后链表首结点地址
    node * delHas(node * h, int n);
    //函数delAt:删除链表中序号为i的结点,如果i是非法序号则不做操作
    //参数:h-链表头指针,i-要删除结点的序号
    //返回值:删除结束后链表首结点地址
    node * delAt(node * h, int i);
    //函数search:在链表中查找包含数据num的结点
    //参数:h-链表头指针,num-要查找的数据
    //返回值:找到了返回该结点的地址,否则返回NULL
    node * search(node * h, int num);
    //函数insertSort:链表排序插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node * insertSort(node *h, node *t);
    //函数insertHead:链表头部插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node * insertHead(node *h, node *t);
    //函数printList:输出链表,每个数据之间用一个空格隔开
    //参数:h-链表头指针
    void printList(node *h);
    //函数insertTail:链表尾部插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node *insertTail(node *h, node *t);
    //函数delList:删除链表,释放空间
    //参数:h-链表头指针
    void delList(node *h);
    /函数delList:删除链表,释放空间
    //参数:h-链表头指针
    void delList(node *h)
    {
     node *p=h; //指针p指向头结点,第一个要删除的结点
     while(p) //这个结点是存在的
     {
      h = h->next; //头指针h指向下一个结点(下一个结点的地址存在当前结点的指针域中,即h->next中
      delete p; //删除p指向的结点
      p = h; //p指向当前的头结点,即下一个要删除的结点
     }
    }
    //函数printList:输出链表,每个数据之间用一个空格隔开
    //参数:h-链表头指针
    void printList(node *h)
    {
     cout<<"List:"; 
     while(h)
     {//h为真,即h指向的结点存在,则输出该结点的数据
      cout<<" "<<h->data;  //输出结点数据
      h=h->next;  //将该结点的指针域赋值给h,h就指向了下一个结点
     }
     cout<<endl; //输出换行符
    }
    //函数insertTail:链表尾部插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node *insertTail(node *h, node *t)
    {
     if(h==NULL) //空链表单独处理
     {
      t->next=NULL; //链表尾指针置为NULL
      return t; //返回第一个结点的地址(即链表头指针)
     }
     //非空链表的情况
     node *p=h;
     //让p指向最后一个结点
     while(p->next)
      p=p->next;
     p->next = t; //让最后一个结点的指针域指向结点t
     t->next=NULL; //链表尾指针置为NULL
     return h;  //返回第一个结点的地址(即链表头指针)
    }
    //函数insertHead:链表头部插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node * insertHead(node *h, node *t)
    {
     t->next=h;
     return t;
    }
    //函数insertSort:链表排序插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node * insertSort(node *h, node *t)
    {
     node *p=NULL,*q=h; //定位第一个插入点:链首
     while(q && q->data<t->data) //查找插入点
     {//两个指针并行后移
      p=q;
      q=q->next;
     }
     if(p==NULL) //插入链首
     {
      t->next = h;
      return t;
     }
     if(q==NULL) //插入链尾
     {
      p->next = t;
      t->next = NULL;
      return h;
     }
     //插入p、q之间
     t->next=q;
     p->next=t;
     return h;
    }
    //函数search:在链表中查找包含数据num的结点
    //参数:h-链表头指针,num-要查找的数据
    //返回值:找到了返回该结点的地址,否则返回NULL
    node * search(node * h, int num)
    {
     while(h)
     {//h为真,即h指向的结点存在
      if(h->data==num)
       return h;
      h=h->next;  //将该结点的指针域赋值给h,h就指向了下一个结点
     }
     return NULL; //没找到包含num的结点
    }
    //函数delAt:删除链表中序号为i的结点,如果i是非法序号则不做操作
    //参数:h-链表头指针,i-要删除结点的序号
    //返回值:删除结束后链表首结点地址
    node * delAt(node * h, int i)
    {
     if(i<0) //序号非法,不删除
      return h;
     node *p=NULL, *q = h; // 定位删除结点,试图让q指向要删除结点,p指向其前面的结点
     for(int k=0;k<i;k++)
     {
      if(q->next==NULL) //后面没有结点了,序号非法
       return h;
      p=q;
      q=q->next;
     }
     if(p) //p指向的结点存在,不是删除首结点
     {
      //删除q指向的结点,让p指向结点的指针域指向q的后续结点
      p->next = q->next;
      //释放空间
      delete q;
      return h;
     }
     else //删除首结点
     {
      h = q->next; //下一个结点成了首结点
      //释放空间
      delete q;
      return h;
     }
    }
    //函数delHas:删除链表中data为n的结点,如果有多个这样的结点,只删除第一个
    //参数:h-链表头指针,n-结点包含的数据
    //返回值:删除结束后链表首结点地址
    node * delHas(node * h, int n)
    {
     node *p=NULL, *q=h; //p为要删除结点的前结点,q指向要删除结点
     while(q)
     {//h为真,即h指向的结点存在
      if(q->data==n)
       break; //找到了
      if(q->next==NULL)//后面没有结点了,没有结点满足条件
       return h; //不删除,直接返回
      //继续往后找,两个指针一起后移
      p=q;
      q=q->next;
     }
     //删除q指向的结点
     if(p==NULL)//删除头结点
     {
      h=q->next;//下一个结点变成头结点
      delete q;//删除结点
      return h;
     }
     //不是头结点
     p->next=q->next;//把q指向结点的指针域(q后面结点的地址)赋值给p指向结点的指针域
     return h;
    }
    //函数listLength:计算并返回链表的长度
    //参数:h-链表头指针
    //返回值:链表长度
    int listLength(node * h)
    {
     int n=0;
     while(h)
     {
      n++;
      h=h->next;
     }
     return n;
    }
    typedef node * intStack;  // 定义类型别名,intStack即相当于node*
    // 函数empty:判断栈sk是否为空
    // 参数:sk-栈
    // 返回值:true-sk为空,false-sk不为空
    bool empty(intStack sk);
    // 函数pop:从sk中弹栈
    // 参数:sk-栈,传引用,弹栈可能会改变sk的值,n-要压栈的整数
    // 返回值:弹栈的弹出的整数,如果栈空,返回-1
    int pop(intStack &sk);
    // 函数push:压栈,将整数n压入栈sk中
    // 参数:sk-栈,传引用,压栈会改变sk的值,n-要压栈的整数
    // 返回值:无,采用链表实现栈,只要还有内存,压栈都会成功
    void push(intStack &sk, int n);
    int main()
    {
     intStack sk=NULL; //声明栈sk,并初始化为空栈(空线性表)
     int command; //输入指令:1-压栈,0-弹栈,-1-退出,其它-非法操作
     int n;
     //输入指令
     cin>>command;
     while(command!=-1)
     {
      switch(command) 
      {
      case 0:
       if(!empty(sk))
       {//栈非空
        n = pop(sk); //弹栈,弹出的值给n
        cout<<n<<endl; //输出弹栈的值
       }
       else
        cout<<"Stack empty"<<endl;
       break;
      case 1:
       cin>>n; //输入要压栈的数据
       push(sk,n);
       cout<<"push "<<n<<endl;
       break;
      default:;
      }
      cin>>command;//输入下一条指令
     }
     //删除栈
     delList(sk);
     return 0;
    }
    // 函数empty:判断栈sk是否为空
    // 参数:sk-栈
    // 返回值:true-sk为空,false-sk不为空
    bool empty(intStack sk)
    {
        return (listLength(sk) == 0);  // 链表长度为0,则栈为空
    }
    // 函数pop:弹栈
    // 参数:sk-栈,传引用,弹栈可能会改变sk的值
    // 返回值:弹栈的弹出的整数,如果栈空,返回-1
    int pop(intStack &sk)
    {
        if(empty(sk))  // 栈空,返回-1
            return -1;
        int n = sk->data;  // 获取栈顶结点(链首结点)的数据
        sk = delAt(sk,0);  // 删除首结点(弹栈,第一个结点出栈)
        return n;  // 返回弹栈数据
    }
    // 函数push:压栈,将整数n压入栈sk中
    // 参数:sk-栈,传引用,压栈会改变sk的值,n-要压栈的整数
    // 返回值:无,采用链表实现栈,只要还有内存,压栈都会成功
    void push(intStack &sk, int n)
    {
        // 创建要压栈的结点
        node *p = new node;
        p->data = n;
        // 压栈(插入链首)
        sk = insertHead(sk,p);
    }
    展开全文
  • 的定义:是一种特殊的表这种表只在表头进行插入删除操作。因此,表头对于来说具有特殊的意义,称为栈顶。相应地,表尾称为底。不含任何元素的称为空栈。   而本次给大家介绍用线性表实现的。 ...

    栈的定义:栈是一种特殊的表这种表只在表头进行插入和删除操作。因此,表头对于栈来说具有特殊的意义,称为栈顶。相应地,表尾称为栈底。不含任何元素的栈称为空栈。 

            而本次给大家介绍用线性表实现的栈。

    如图

    这里介绍双向链表的常用操作:

    l 创建栈

    l 销毁栈

    l 清空栈

    l 压栈

    l 出栈

    l 返回栈顶元素

    l 返回栈的大小

    l 返回栈的最大长度

    代码总分为三个文件:

    SeqStack.h : 放置功能函数的声明,以及表的声明 

    SeqStack.c : 放置功能函数的定义

    Main.c     : 主函数,使用功能函数完成各种需求,一般用作测试

    整体结构图为:

     

    这里详细说下压栈操作,出栈操作和返回栈顶元素操作:

     

    压栈操作:

    如图:

      

    出栈操作:

    如图:

    返回栈顶元素:

    如图:

        如果(表头用作栈底,表尾用作栈顶)时,每次操作都在表尾部操作,不会移动元素,如果(表头用作栈顶,表尾用作栈底)时,每次操作都会移动表元素,所以第一种方案较合适。

     

         OK! 上代码:

    SeqStack.h : 

    [cpp] view plain copy
    1. #ifndef _SEQSTACK_H_  
    2. #define _SEQSTACK_H_  
    3.   
    4. typedef void SeqStack;  
    5.   
    6. SeqStack* SeqStack_Create(int capacity);  
    7.   
    8. void SeqStack_Destroy(SeqStack* stack);  
    9.   
    10. void SeqStack_Clear(SeqStack* stack);  
    11.   
    12. int SeqStack_Push(SeqStack* stack, void* item);  
    13.   
    14. void* SeqStack_Pop(SeqStack* stack);  
    15.   
    16. void* SeqStack_Top(SeqStack* stack);  
    17.   
    18. int SeqStack_Size(SeqStack* stack);  
    19.   
    20. int SeqStack_Capacity(SeqStack* stack);  
    21.   
    22. #endif  


     

    SeqStack.c :

    [cpp] view plain copy
    1. #include "Seqlist.h"  
    2. #include "SeqStack.h"  
    3.   
    4. SeqStack* SeqStack_Create(int capacity)  
    5. {  
    6.     return SeqList_Create(capacity);  
    7. }  
    8.   
    9. void SeqStack_Destroy(SeqStack* stack)  
    10. {  
    11.     SeqList_Destroy(stack);  
    12. }  
    13.   
    14. void SeqStack_Clear(SeqStack* stack)  
    15. {  
    16.     return SeqList_Clear(stack);  
    17. }  
    18.   
    19. int SeqStack_Push(SeqStack* stack, void* item)  
    20. {  
    21.     return SeqList_Insert(stack, (SeqListNode*)item, SeqList_Length(stack));  
    22. }  
    23.   
    24. void* SeqStack_Pop(SeqStack* stack)  
    25. {  
    26.     return SeqList_Delete(stack, SeqList_Length(stack)-1);  
    27. }  
    28.   
    29. void* SeqStack_Top(SeqStack* stack)  
    30. {  
    31.     return SeqList_Get(stack, SeqList_Length(stack)-1);  
    32. }  
    33.   
    34. int SeqStack_Size(SeqStack* stack)  
    35. {  
    36.     return SeqList_Length(stack);  
    37. }  
    38.   
    39. int SeqStack_Capacity(SeqStack* stack)  
    40. {  
    41.     return SeqList_Capacity(stack);  
    42. }  


     

    Main.c :

    [cpp] view plain copy
    1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. #include "SeqStack.h"  
    4.   
    5. int main(void)  
    6. {  
    7.     SeqStack* stack = SeqStack_Create(20);  
    8.       
    9.     int a[10];  
    10.     int i = 0;  
    11.       
    12.     for(i=0; i<10; i++)  
    13.     {  
    14.         a[i] = i;  
    15.           
    16.         SeqStack_Push(stack, a+i);  
    17.     }  
    18.       
    19.     printf("Top:      %d\n", *(int*)SeqStack_Top(stack));  
    20.     printf("Capacity: %d\n", SeqStack_Capacity(stack));  
    21.     printf("Length:   %d\n", SeqStack_Size(stack));  
    22.       
    23.     while(SeqStack_Size(stack) > 0)  
    24.     {  
    25.         printf("%d ", *(int*)SeqStack_Pop(stack));  
    26.     }  
    27.     printf("\n");  
    28.       
    29.     SeqStack_Destroy(stack);  
    30.       
    31.     return 0;  
    32. }  

    展开全文
  • public class ArrayStack { private static final int DEFAULT_CAPACITY = 10; private int top; private E[] items; @SuppressWarnings("unchecked") public ArrayStack() { ... items = (E[]
    public class ArrayStack<E> {
    
    	private static final int DEFAULT_CAPACITY = 10;
    	
    	private int top;
    	private E[] items;
    	
    	@SuppressWarnings("unchecked")
    	public ArrayStack() {
    		top = -1; 
    		items = (E[]) new Object[ DEFAULT_CAPACITY ];  
    	}
    	
    	@SuppressWarnings("unchecked")
    	public void push(E data) {
    		
    		if (top == items.length) {
    			E [ ] newItems = (E[]) new Object[ items.length * 2 ];
    			System.arraycopy(items, 0, newItems, 0, items.length);
    			items = newItems;
    		}
    		
    		items[++top] = data;
    	}
    	
    	public E pop() {
    		
    		if (top < 0) {
    			return null;
    		}
    		
    		return items[ top-- ];
    	}
    
    }

    展开全文
  • 栈和队列以及线性表区别

    千次阅读 2017-06-29 10:09:01
    是限定只能在表的一端进行插入删除操作的线性表。队列是限定只能在表的一端进行插入在另一端进行删除操作的线性表。 从"数据结构"的角度看,它们都是线性结构,即数据元素之间的关系相同。但它们是完全不同的...

    1.队列先进先出,栈先进后出。


    2.对插入和删除操作的"限定"。 栈是限定只能在表的一端进行插入和删除操作的线性表。队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。  从"数据结构"的角度看,它们都是线性结构,即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外,主要区别是对插入和删除操作的"限定"。 栈和队列是在程序设计中被广泛使用的两种线性数据结构,它们的特点在于基本操作的特殊性,栈必须按"后进先出"的规则进行操作,而队列必须按"先进先出"的规则进行操作。和线性表相比,它们的插入和删除操作受更多的约束和限定,故又称为限定性的线性表结构。

     

    3.遍历数据速度不同。栈只能从头部取数据 也就最先放入的需要遍历整个栈最后才能取出来,而且在遍历数据的时候还得为数据开辟临时空间,保持数据在遍历前的一致性队列怎不同,他基于地址指针进行遍历,而且可以从头或尾部开始遍历,但不能同时遍历,无需开辟临时空间,因为在遍历的过程中不影像数据结构,速度要快的多

     

     

    栈(Stack)是限定只能在表的一端进行插入和删除操作的线性表。
    队列(Queue)是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。
    从"数据结构"的角度看,它们都是线性结构,即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外,主要区别是对插入和删除操作的"限定"。

    栈和队列是在程序设计中被广泛使用的两种线性数据结构,它们的特点在于基本操作的特殊性,栈必须按"后进先出"的规则进行操作,而队列必须按"先进先出"的规则进行操作。和线性表相比,它们的插入和删除操作受更多的约束和限定,故又称为限定性的线性表结构。可将线性表和栈及队列的插入和删除操作对比如下:

     
    线性表
     Insert(L,i,x)
    (1≤i≤n+1)
     Delete(L,i)
    (1≤i≤n)
     如线性表允许在表内任一位置进行插入和删除
     

     Insert(L,n+1,x)
     Delete(L,n)
     而栈只允许在表尾一端进行插入和删除

     

    队列
     Insert(L,n+1,x)
     Delete(L,1)
     队列只允许在表尾一端进行插入,在表头一端进行删除

     

    栈(Stack)是限定只能在表的一端进行插入和删除操作的线性表。
    队列(Queue)是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。


    从"数据结构"的角度看,它们都是线性结构,即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外,主要区别是对插入和删除操作的"限定"。

     

    展开全文
  • 在之前的线性表的基础上实现了的功能,包括顺序存储结构链式存储结构,保留了之前的线性表的代码,现在是栈和线性表的功能二合一,类似MFC的CArrayCList
  • 一、,队列,线性表区别 只有入栈出栈操作,队列也只有入队出队操作,相比于线性表,站队列都是操作受限的线性表:先进后出。用于调用函数时,网页搜索等等 队列:先进先出,后进后出。 二、用顺序...
  • 线性表的存储结构(主要有两种): 1、定长的顺序存储结构,也称顺序表或向量型的一维数组结构。数据结点之间的逻辑关系是通过数据结点的存储位置来反映的。 2、边长的线性结构存储结构、大多实现为链接式存储结构...
  • 线性表实现: # 使用线性表来实现 class Stack(object): # 初始化一个空栈 def __init__(self): self.__list = [] # 判断是否为空 def is_empty(self): return self.__list == [] # 压栈 def PushS...
  • 一、,队列,线性表区别 相对只有入栈出栈操作,队列相对也只有入队出队操作,相对于线性表而言,站队列是操作受限的线性表:先进后出。用于调用函数,网页访问等等。 队列:先进先出,后进后出。...
  • 线性表栈和队列与应用——基础要点
  • ——线性表栈是限定仅在表头进行插入或删除的操作的线性表。一、汉字,zhan,从木从戋。牲口棚,马鹏。基本释义储存货物或供旅客住宿的房屋:货栈。客栈。栈房。竹木编成的遮蔽物或其他东西:马(养马的竹木棚)。...
  • 线性表 栈和队列

    2013-06-23 18:07:33
    一个文件commom.h #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 第二个文件seqlist.h #define ElemType int #defineMAXSIZE 100 /*此处的宏定义常量表示线性表可能达到...
  • .h 文件#ifndef _SEQ_STACK_H_ #define _SEQ_STACK_H_ ...//用线性表的顺序存储模拟的顺序存储,在尾部插入删除元素不会涉及大量元素移动 typedef void Stack;#ifndef bool #define bool int #def
  • 线性表栈和队列

    2015-08-30 22:12:09
    简单介绍了线性表栈和队列的实现
  • 线性表栈和队列

    2018-08-22 15:50:48
    2种特殊的线性表栈和队列 1. (LIFO,后进先出): a) 操作示意图:push()操作与pop()操作 b)的顺序存储结构:进栈/出栈操作均在数组尾部,时间复杂度=O(1); i.缺陷:数组长度固定,长度不够时需扩容,...
  • 的定义:(特殊的线性表)  仅在表的一端进行插入删除的线性表。允许插入、删除的这一端称为栈顶,另一端称为底。表中没有元素时称为空栈。  被称为后进先出的线性表(Last In First Out),简称 LIFO表,...
  • 线性表栈和队列

    2018-05-31 16:39:14
    线性表:零个或多个数据元素的有限序列长度:线性表元素的的个数n(n&gt;=0),当n=0时,是空表操作(operation):InitList(*L):初始化操作,建立一个空的线性表LListEmpty(L):若线性表为空,返回true,否则返回...
  • 是限定仅在表的一端进行插入删除的线性表 队列是限定仅在表的一端进行插入、在表的另一端进行删除的线性表 栈和队列是两种常用的抽象数据类型、都属于线性结构 可以改变数据的处理顺序 是函数过程...
  • 线性表

    2018-08-06 20:56:56
    是一个限定仅在表尾进行插入删除操作的线性表;又称后进先出的线性表。LIFO结构。 栈顶(top):允许操作 的一端; 底(bottom):不允许操作的一端。 空栈:不含任何数据元素的;top=-1; 的常见...
  • 顺序存储的线性表和运算 链式存储的线性表和运算 顺序的实现运算 链栈的实现运算 顺序队列的实现运算 链式队列的实现运算 循环队列的实现运算
  • 特殊线性表栈和队列 顺序——的顺序存储结构 属于特殊的线性表,支持进栈出栈判空判满等基础操作. 可以利用数组模拟搭配top值进行以上的基础操作. 两共享空间(双端) : 在一个程序中需要同时使用具有...
  • 栈和队列 栈和队列是两种特殊的线性表,是操作受限的线性表,称限定性DS 讲解了栈和队列的操作与应用
  • 1.的基本概念 概念: 首先是一个线性表元素具有线性关系,即前驱后继...只不过它是一种受限制的线性表,定义中说明这种线性表在线 性表的表位进行插入或者删除操作,这里的表尾是指栈顶,而不是底. ...
  • 数据结构课件 线性表 单链表 栈和队列 串 数组广义表 树二叉树 C语言版 有大量程序代码
  • 包含了数据结构中的线性表,队列和栈的具体代码,如有错误可以联系我,我可以进行修改。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,963
精华内容 14,385
关键字:

栈和线性表的区别