精华内容
下载资源
问答
  • * 文件描述:使用堆栈存储模型(后进先出)来挂载链表数据 * 头部插入链表方式相当于堆栈模型的存储模式 * 编辑人:王廷云 * 编辑日期:2017-11-12 * 修改日期:2018-2-1 *********************...
    /***************************************************
     * 文件名:ListStack
     * 文件描述:使用堆栈存储模型(后进先出)来挂载链表数据
     *         头部插入链表方式相当于堆栈模型的存储模式
     * 编辑人:王廷云
     * 编辑日期:2017-11-12
     * 修改日期:2018-2-1
    ***************************************************/
    
    #include <stdio.h>
    #include <stdlib.h> 
    
    /* 数据节点封装 */
    struct node
    {
    	char data;
    	struct node *next;
    } stackHead = {.next = NULL};
    
    /* 栈模型函数 */
    void push(char data);               // 压栈
    int pop(void);                      // 出栈
    int top(void);                      // 栈顶
    int isEmptyStack(void);             // 栈空
    int isFullStack(void);              // 栈满
    
    /* 括号匹配检查函数 */
    void check(char left, char right);  
    
    int main(void)
    {
    	char buff[1024];
    	int i = 0;
    
    	printf("\n=====输入带有括号的字符串=====\n");
    	scanf("%s", buff);
    	
    	/* 循环检查直到检查完毕 */
    	while (buff[i])
    	{
    		switch (buff[i])
    		{
    			/* 左括号入栈 */
    			case '(':  /* no break */
    			case '[':	
    			case '{':
    			case '<': push(buff[i]);	   break;
    			
    			/* 右括号出栈检查 */
    			case ')': check('(', buff[i]); break;
    			case ']': check('[', buff[i]); break;
    			case '}': check('{', buff[i]); break;
    			case '>': check('<', buff[i]); break;
    		}
    		i++;
    	}
    	
    	/* 检查完所有右括号字符后还有左括号说明不匹配 */
    	while (!isEmptyStack())
    	{
    		printf("\'%c\'是多余的括号!\n", pop());
    	}
    
    	return 0;
    }
    
    /**
     * 函数名:push
     * 函数功能:数据节点入栈
     * 参数:data:入栈的数据
     * 返回值:void
    */
    void push(char data)
    {
    	struct node *newOne;
    
    	/* 分配新节点数据空间 */
    	newOne = malloc(sizeof(newOne));
    	if (NULL == newOne)
    	{
    		printf("Push data error! Maybe stack of memry is full!\n");
    		exit(1);
    	}
    	
    	/* 给新节点赋值数据 */
    	newOne->data = data;
    	
    	/* 链表头插入节点方式模拟入栈 */	
    	newOne->next = stackHead.next;
    	stackHead.next = newOne;
    }
    
    /**
     * 函数名:pop
     * 函数功能:数据节点出栈
     * 参数:void
     * 返回值:栈顶数据
    */
    int pop(void)
    {
    	struct node *topNode;
    	char topData; 
    
    	topNode = stackHead.next;			// 先保存栈顶数据地址
    	topData = stackHead.next->data;		// 取栈顶数据
    	
    	stackHead.next = topNode->next;	// 摘掉栈顶节点
    	free(topNode);
    
    	return topData;						// 返回栈顶数据
    }
    
    /**
     * 函数名:top
     * 函数功能:获取栈顶数据
     * 参数:void
     * 返回值:栈顶数据
    */
    int top(void)
    {
    	return stackHead.next->data;
    }
    
    /**
     * 函数名:isEmptyStack
     * 函数功能:判断栈是否为空
     * 参数:void
     * 返回值:栈为空返回1,不为空返回0
    */
    int isEmptyStack(void)
    {
    	return stackHead.next == NULL;
    }
    
    /**
     * 函数名:isFullStack
     * 函数功能:判断栈是否已满
     * 参数:void
     * 返回值:0-链表不存在满的情况
    */
    int isFullStack(void)
    {
    	return 0;
    }
    
    /**
     * 函数名:check
     * 函数功能:通过检查括号是否匹配
     * 参数:left: 左括号  right: 右括号 
     * 返回值:void
    */
    void check(char left, char right)
    {
    	char temp;
    
    	if (isEmptyStack())
    	{
    		printf("%c 是多余的括号\n", right);
    		exit(1);
    	}
    	
    	temp = pop();
    	if (temp != left)
    	{
    		printf("\'%c\' 和 \'%c\' 不匹配\n",left,right);
    		exit(1);
    	}
    }
    
    展开全文
  • 使用链表进行模拟栈比用数组好用,考虑的要素也少还方便。 链表结构 private class Node{//链表结构 Item item; Node next; } 迭代器 private class Iterator implements java.util.Iterator<Item>{//迭代...

    使用链表进行模拟栈比用数组好用,考虑的要素也少还方便。

    链表结构

    private class Node{//链表结构
                Item item;
                Node next;
            }
    

    迭代器

    private class Iterator implements java.util.Iterator<Item>{//迭代器
    
                private Node p=first;
                @Override
                public boolean hasNext() {
                    return p!=null;
                }
    
                @Override
                public Item next() {
                    Item item=p.item;
                    p=p.next;
                    return item;
                }
    
                @Override
                public void remove() {
    
                }
            }
    

    完整源代码

     static class stack<Item>{
            private Node first;
            private int N;
            private class Node{//链表结构
                Item item;
                Node next;
            }
            private int size(){
                return N;
            }
            private boolean isEmpty(){
                return first==null;
            }
            private void push(Item item){//入栈
                Node oldfirest=first;
                first=new Node();
                first.item=item;
                first.next=oldfirest;
                N++;
            }
            private Item pop(){//出栈
                Item item=first.item;
                first=first.next;
                N--;
                return item;
            }
            private Iterator iterator(){
                return new Iterator();
            }
            private class Iterator implements java.util.Iterator<Item>{//迭代器
    
                private Node p=first;
                @Override
                public boolean hasNext() {
                    return p!=null;
                }
    
                @Override
                public Item next() {
                    Item item=p.item;
                    p=p.next;
                    return item;
                }
    
                @Override
                public void remove() {
    
                }
            }
    
        }
    

    简单的使用

    static public void main(String[] args) {
            stack<String> stack = new stack<String>();
            System.out.println("入栈中... ...");
            stack.push("hello world!");
            stack.push("hello Java!");
            stack.push("hello stack");
            System.out.println("--------出栈---------");
            String pop = stack.pop();
            System.out.println(pop);
            System.out.println("--------迭代--------");
            ListStack.stack<String>.Iterator iterator = stack.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
    

    在这里插入图片描述

    展开全文
  • 后进先出表:在建立单链表时,将每次生成的新结点,总是插入到当前链表的表头结点之后作为当前链表的首结点。若用换行符‘n’作为输入结束标志,则建立带表头结点的后进先出单链表的算法如下:LinkList CreateList_...

    【导语】在事业单位考试中,计算机专业知识的复习向来是考生复习备考阶段的一大重点,其中中公为计算机基础知识的复习为考生提供知识点梳理,帮助考生备考!

    后进先出表:在建立单链表时,将每次生成的新结点,总是插入到当前链表的表头结点之后作为当前链表的首结点。若用换行符‘n’作为输入结束标志,则建立带表头结点的后进先出单链表的算法如下:

    LinkList CreateList_fr( )

    {

    LinkList H,p;

    char ch;

    H =(LinkList)malloc(sizeof(

    ListNode)); /*生成表头结点*/

    if(!H)

    {

    printf("n 存储分配失败");

    exit(1);

    }

    H->next=NULL; /*表初值为空*/

    while((ch=getchar())!='n')

    {

    p=(LinkList)malloc(sizeof(

    ListNode)); /*生成新结点*/

    if(!p)

    {

    printf("n 存储分配失败");

    exit(1);

    }

    p->data=ch;

    p->next=H->next;

    H->next=p;/*插入表头结点之后*/

    }

    return(H); /*返回头指针*/

    }

    更多相关信息请访问事业单位考试资料网

    展开全文
  • 建立先进先出和先进后出链表

    千次阅读 2018-09-29 14:41:38
    先入先出 生成单链表 1.生成新节点 p=malloc(链表大小) 给新节点赋值 p-&amp;gt;data ,p-&amp;gt;next =NULL; 2.添加到表尾 tail-&amp;gt;next = p; 3.设置新表尾 tail = p; 类C语言描述 ...

    链表学习笔记(二)

    一.先进先出

    生成单链表
    1.生成新节点 p=malloc(链表大小)
    给新节点赋值 p->data ,p->next =NULL;
    2.添加到表尾 tail->next = p;
    3.设置新表尾 tail = p;

    类C语言描述

    struct node *creat1()
    {
        struct node *head,*tail,*p;
    	int e;
    	head = (struct node*)malloc(sizeof(LENG));
    	tail = head;
    	scanf("%d",&e);
    	while(e!=0)
    	{
    		p = (struct node*)malloc(sizeof(LENG));
    		p->data = e;
    		tail->next = p;
    		tail = p;
    		scanf("%d",&e);
    	}
    	tail->next = NULL;
    	return head;
    }
    

    二.先进后出

    元素插入表头
    生成链表
    1.生成新节点 p=malloc(链表大小)
    给新节点赋值 p->data ,p->next =NULL;
    2.新节点指向原首节点
    p->next=head->next;
    3.新节点作为首元素
    head->next = p ;

    struct node *creat2()
    {
        struct node *head,*p;
    	int e;
    	head = (struct node*)malloc(sizeof(LENG));
    	head->next = NULL;
    	scanf("%d",&e);
    	while(e!=0)
    	{
    		p = (struct node*)malloc(sizeof(LENG));
    		p->data = e;
    		p->next = head->next;
    		head->next = p;
    		scanf("%d",&e);
    	}
    	return head;
    }
    
    展开全文
  • 具体而言,栈的数据结点必须后进先出。 宏观上来看,与数组或链表相比,栈的操作更为受限,那为什么我们要用这种受限的栈呢?其实,单纯从功能上讲,数组或者链表可以替代栈。然而问题是,数组或者链表的操作过于...
  • 后进先出”的栈

    2014-08-22 22:37:46
    栈的修改遵循后进先出的原则,因此栈又称为后进先出的线性表,简称LIFO结构。 栈一般采用数组作为其存储结构,这样做可以避免使用指针,简化程序,当然数组需要预先声明静态数据区的大小,但这不是问题,因为即便是...
  • Queue是先进先出的集合而Stack是后进先出的集合。这两个集合在日常的工作中也经常会用到。Queue相当我们去银行柜台排队,大家依次鱼贯而行。Stack象我们家中洗碗,最后洗好的碗叠在最上面,而下次拿的时候是最先拿到...
  • 原创不易 还请一键三连支持 什么是栈 栈在我们日常编码中遇到的非常多,很多人对栈的接触可能仅仅局限在 递归使用的是栈 和 StackOverflowException,栈是一种后进先出的数据结构(可以想象生化金字塔的牢房和生化...
  • 线性表是使用非常广泛的一类数据结构,它对数据的顺序非常敏感,而且它对数据的增删...栈是特殊的线性表,栈的数据结点必须后进先出后进的意思是,栈的数据新增操作只能在末端进行,不允许在栈的中间某个结点后新增
  • 1、栈是一种先进后出的顺序表,和顺序表的区别是:顺序表可以操作任意元素,但是栈只能对栈顶元素进行操作,即后进先出原则。 2、栈的操作就只有入栈和出栈两个。 3、实现入栈和出栈 栈的栈顶用top标识,入栈时...
  • 实现数据结构中的栈---后进先出LIFO

    千次阅读 2020-06-18 12:17:21
    书本整齐跨一叠在一起,最后放在最上面的那本最先拿走,生活中有很多后进先出的列子,就不一一说明了,用图来说明应该很好理解。 放在最上面的那本书的位置叫栈顶,栈顶是可变的,比如说你拿走了西游记,那么栈顶...
  • 栈(LIFO:后进先出

    千次阅读 2017-07-20 21:55:56
     栈的链表实现:通过在单链表的顶端插入元素来实现push,通过删除表顶端的元素来实现pop操作。top只是考查表顶端元素并返回它的值。  栈的数组实现:模仿的是ArrayList的add操作。与每个栈相关的操作是theArray...
  • 栈的操作就是针对栈顶元素,其特点就是后进先出。这里分别采用数组和单链表分别实现了一个顺序栈和链栈,并且共享了一个栈的应用: 单词逆序。
  • 出栈:指数据的删除操作(数据也在栈顶)。 栈的实现:一般可以用数组或者链表,但是用数组实现更优一点,因为数组在尾插尾删上的代价较小。 下面,我们来实现支持动态增长的栈: typedef int STData...
  • 栈:后进先出的线性表如何实现增删查1)栈是什么?2)栈的基本操作 线性表是使用非常广泛的一类数据结构,它对数据的顺序非常敏感,而且它对数据的增删操作非常灵活。在有序排列的数据中,可以灵活的执行增删操作,...
  • 数据结构-栈结构栈结构链表...总结:后进先出 链表实现 // ConsoleApplication3.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" struct Student { int grade; struct Stude...
  • * Title: 带虚拟头结点的链表 * Description: * 链表结构包含两个要素: 头结点head + 链表大小size, * 操作包括: * 链表的增删 * 链表是否为空 * 链表的大小 * 链表的打印输出 * 删除链表重复节点 * ...
  • 栈的数据结点被限制为后进先出,这意味着栈的数据新增操作只能在末端进行,不允许在栈的中间某个结点后新增数据。同时,栈的数据删除操作也只能在末端进行,不允许在栈的中间某个结点后删除数据。 因此,可以说栈是...
  • 链表实现堆栈

    千次阅读 2017-06-24 15:09:31
    堆栈数据一种后进先出的数据结构,只能在一端(称为栈顶(top))对数据项进行插入和删除。基本的堆栈操作是push和pop,push是把一个新值压入堆栈的顶部,pop是把堆栈的顶部的值移除并返回这个值。堆栈只提供对它的栈顶...
  • 堆栈(Strack)是指这样一段内存,它可以理解为一个筒结构,先放进筒中的数据被后放进筒中的数据“压住”,只有后放进筒中的数据都取出后,先放进去的数据才能被取出,称为“后进先出”。堆栈的长度可随意增加。堆栈...
  • 1.本题知识点    链表,递归,栈 ...   不改变链表结构,典型的后进先出场景,我们想到了栈,可以利用有序线性表结构ArrayList 递归实现。    Java版本: /** * public class ListNode { * int val; * ListNo...
  • 翻转链表

    2018-11-17 00:44:21
    因为链表翻转是将最后一个元素放到第一个,第一个放到最后,遍历时由只能从前向后,这符合栈后进先出的特点,考虑的使用栈会增加空间的开销,因为可以使用具有后进先出特性的递归。 class Solution{ public ...
  • //后进先出 stack public HeroNode reversedNode3(Node head){ if(head.next==null){ return null; } Stack<Node> stack=new Stack<>(); HeroNode temp=head.next; while(temp != null){ stack...
  • 反转链表

    2019-07-15 20:51:36
    返回一个反序的链表,这就是经典的“后进先出”,我们可以使用栈实现这种顺序。每经过一个结点的时候,把该结点放到一个栈中。当遍历完整个链表后,再从栈顶开始逐个输出结点的值,给一个新的链表结构,这样链表就...
  • 前注:本文参考传智博客毕向东老师的java教学视屏加上本菜鸟的一些总结理解,错漏之处烦请各位批评改正,望共同进步。 一 所用主要方法介绍 1.removedFirst(移除对象)  removedLast 2.addFirst(添加对象) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,951
精华内容 11,180
关键字:

后进先出链表