精华内容
下载资源
问答
  • 主要介绍了java 使用链表来模拟栈的入栈出栈操作,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 使用链表来模拟栈的入栈出栈操作。 1.节点类代码 public class Entry<T> { private T value; private Entry<T> next; public Entry() { this(null); } public Entry(T valu...

    栈:后进先出;最后一个放入堆栈中的物体总是被最先拿出来。

    使用链表来模拟栈的入栈出栈操作。

    1.节点类代码

    public class Entry<T> {
    private T value;
    private Entry<T> next;
    public Entry() {
        this(null);
    }
    public Entry(T value) {
        this.value=value;
        this.next=null;
    }
        
    public void setValue(T value) {
        this.value=value;
    }
    public void setNext(Entry<T> next) { this.next=next; } public T getValue() { return value; } public Entry<T> getNext(){ return next; } }

    2.节点的入栈出栈方法代码

    public class Link<T> {//链表实现栈,先进后出
    private Entry<T> headEntry;
    private int size=0;
    public Link() {
        headEntry =new Entry<>();
    }
    public void pop() {//出栈
        if(headEntry.getNext()!=null) {
        headEntry.getNext().setValue(null);
        headEntry.setNext(headEntry.getNext().getNext());
        size--;
        }else {
            return;
        }
        
    }
    public void push(T value) {//入栈
        Entry<T> newEntry=new Entry<>(value);
        if(headEntry.getNext()!=null) {
            newEntry.setNext(headEntry.getNext());
            
        }
            headEntry.setNext(newEntry);
            size++;
        
    }
    
    
    public void show(){//打印节点
        if(headEntry.getNext()==null) {
            return;
        }
        for(Entry<T> p = headEntry.getNext();p!=null;p=p.getNext()){
            System.out.print(p.getValue()+" ");
        }
        System.out.println();
    }
    }

    3.测试类代码

    public class Main {
    public static void main(String args[]) {
        Link<String> ll=new Link<>();
        ll.push("1");//入栈
        ll.push("2");
        ll.push("3");
        ll.push("4");
        ll.push("5");
        ll.push("6");
        ll.push("7");
        ll.push("8");
        ll.show();//打印栈内元素
        ll.pop();//弹出栈顶元素
        ll.show();
        ll.pop();
        ll.show();
    }
    }

    4.测试结果

     

    转载于:https://www.cnblogs.com/zunzunzunshen/p/10301415.html

    展开全文
  • 栈的入栈出栈返回栈顶元素元素个数判空 #include <stdio.h> #include <stdlib.h> #include <string.h> //定义节点 typedef struct tag { int val; struct tag *pNext; }Node,*pNode;//别名 //...

    栈的入栈出栈返回栈顶元素元素个数判空

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    //定义节点
    typedef struct tag
    {
      int val;
      struct tag *pNext;
    }Node,*pNode;//别名
    
    //定义栈
    typedef struct{
      //头指针
    	pNode phead;
    	//栈中的元素个数
    	int size;
    }Stack,*pStack;
    
    //栈是先进后出,入栈实现,头插法头删法
    void push(pStack p,int val)
    {
    	//calloc申请空间并同时赋值为0
    	pNode pnew=(pNode)calloc(1,sizeof(Node));
    	pnew->val=val;
    	//头插法  也是实现判断栈是否为空empty()
    	if(NULL==p->phead)
    	{
    	 //链表为空
    		p->phead=pnew;
    	}else{
    		pnew->pNext=p->phead;
    	    p->phead=pnew;
    	}
    	p->size++;
    }
    //出栈实现
    void pop(pStack p)
    {
    	//定义一个节点pcur接收要被free的phead
    	pNode pcur;
      //判断链表是否为空
    	if(NULL==p->phead)
    	{
    	   printf("stack is empty\n");
    	   return;
    	}
    	//头部删除
    	//返回栈顶元素:int top()
    	pcur=p->phead;
    	p->phead=p->phead->pNext;
    	p->size--;
    	free(pcur);
    	pcur=NULL;
    }
    int size(pStack p)
    {
      return p->size;
    }
    
    int main()
    {
    	//定义栈
    	Stack s;
    	int i,s_size;
    	//先将s内存清空为0
    	memset(&s,0,sizeof(s));
    	//循环每次把i放入栈
    	while(scanf("%d",&i)!=EOF){
    	   //入栈:push()
    		push(&s,i);
    	}
    	//出栈:pop()
    	pop(&s);
    	//返回栈中元素个数:size()
    	s_size=size(&s);
    	printf("s_size=%d\n",s_size);
    	system("pause");
    }
    
    展开全文
  • 这是使用C语言链表进行的进制装换,十进制转换为八进制,通过栈的先进后出的原则,使用链表进行编写,在通过while循环输出。
  • 学完链表和,数组模拟学完后,自己根据链表写了个链栈,虽然只是简单实现了入栈出栈遍历。收获还是很大。 在push这里思考了一会,思路是:传入一个数字,push里创建一个节点node,把数据加入node里,让head....

    学完链表和栈,数组模拟栈学完后,自己根据链表写了个链栈,虽然只是简单的实现了入栈出栈遍历。收获还是很大的。

    在push这里思考了一会,思路是:传入一个数字,push里创建一个节点node,把数据加入node里,让head.next指向node(新节点),然后让node.next指向top,把node再换成top。

    **package stack;
    
    public class LinkedListStackDemo {
        public static void main(String[] args) {
            SingleLinkedList singleLinkedList = new SingleLinkedList();
            singleLinkedList.push(1);
            singleLinkedList.push(2);
            singleLinkedList.push(3);
            singleLinkedList.push(4);
            singleLinkedList.push(5);
    
            singleLinkedList.show();
            singleLinkedList.pop();
            singleLinkedList.pop();
            singleLinkedList.pop();
            
        }
    }
    
    //链栈
    class SingleLinkedList {
        private Node top;
        private static int size;
    
        //初始化栈
        public SingleLinkedList() {
            size = 0;
        }
    
        private Node head = new Node();
    
        //空
        public boolean isEmpty() {
            return head.next == null;
        }
    
        //入栈
        public void push(int data) {
        
            Node temp = new Node();
            temp.setData(data);
            head.next = temp;
            temp.next = top;
            top = temp;
            size++;
        }
    
        //出栈
        public void pop() {
            if (isEmpty()) {
                System.out.println("栈空");
                return;
            }
            System.out.println("出栈的是:" + top.getData());
            head.next = top.next;
            top = top.next;
            size--;
        }
    
        //遍历输出
        public void show(){
            if (isEmpty()){
                System.out.println("栈空");
                return;
            }
    
            Node temp = head.next;
            for (int i = 1; i <= size; i++){
                System.out.printf("栈的第 %d 个元素是:%d\n",i,temp.getData());
                temp = temp.next;
            }
        }
    }
    
    //数据类
    class Node{
        private int data;
        public Node next;
    
        public int getData() {
            return data;
        }
    
        public void setData(int data) {
            this.data = data;
        }
        @Override
        public String toString() {
            return "Node{" +
                    "data=" + data +
                    '}';
        }
    }
    **
    
    结果:
    
    栈的第 1 个元素是:5
    栈的第 2 个元素是:4
    栈的第 3 个元素是:3
    栈的第 4 个元素是:2
    栈的第 5 个元素是:1
    出栈的是:5
    出栈的是:4
    出栈的是:3
    
    展开全文
  • 栈是一种 “特殊” 的线性存储结构,因此栈的具体实现有以下两种方式: 1.顺序栈:采用顺序存储结构可以模拟栈存储数据的特点,从而实现栈存储结构; 2.链栈:采用链式存储结构实现栈结构; 本文主要模拟顺序栈 二、...

    一、什么是栈

    栈是一种只能从表的一端存取数据且遵守“先进后出” 原则的线性存储结构。

    在这里插入图片描述
    进栈和出栈
    基于栈结构的特点,在实际应用中,通常只会对栈执行以下两种操作:
    向栈中添加元素,此过程被称为"进栈"(入栈或压栈);
    从栈中提取出指定元素,此过程被称为"出栈"(或弹栈);

    栈的具体实现
    栈是一种 “特殊” 的线性存储结构,因此栈的具体实现有以下两种方式:
    1.顺序栈:采用顺序存储结构可以模拟栈存储数据的特点,从而实现栈存储结构;
    2.链栈:采用链式存储结构实现栈结构;
    本文主要模拟顺序栈

    二、顺序栈入栈

    比如,还是模拟栈存储 {1,2,3,4} 的过程。最初,栈是"空栈",即数组是空的,top 值为初始值 -1,如图 一所示:
    图一图一(空栈)
    首先向栈中添加元素 1,我们默认数组下标为 0 一端表示栈底,因此,元素 1 被存储在数组 a[1] 处,同时 top 值 +1,如图 二所示:
    在这里插入图片描述图二
    采用以上的方式,依次存储元素 2、3 和 4,最终,top 值变为 3,如图 三 所示:
    在这里插入图片描述 图三

    三、顺序栈出栈

    其实,top 变量的设置对模拟数据的 “入栈” 操作没有实际的帮助,它是为实现数据的 “出栈” 操作做准备的。

    比如,将图 5三中的元素 2 出栈,则需要先将元素 4 和元素 3 依次出栈。需要注意的是,当有数据出栈时,要将 top 做 -1 操作。因此,元素 4 和元素 3 出栈的过程分别如图 4a) 和 4b) 所示:
    在这里插入图片描述 图四
    注意,图 四 数组中元素的消失仅是为了方便初学者学习,其实,这里只需要对 top 值做 -1 操作即可,因为 top 值本身就表示栈的栈顶位置,因此 top-1 就等同于栈顶元素出栈。并且后期向栈中添加元素时,新元素会存储在类似元素 4 这样的旧元素位置上,将旧元素覆盖。

    四、JAVA代码实现

    package ddd;
    
    import java.util.Stack;
    
    public class TEest {
    	//声明数组栈
    	int arr[];
    	//栈的最大容量
    	int maxSize;
    	//栈标记top
    	int top=-1;
    	
    	//判断栈是否为空
    	public boolean isEmpty(){
    		return top==-1;
    	}
    	
    	//判断栈是否满了
    	public boolean isFull(){
    		return top==maxSize-1;
    	}
    	
    	//给数组栈赋容量
    	public void numArr(int num){
    		this.maxSize=num;
    		arr=new int[num];
    	}
    	
    	//进栈
    	public int push(int value){
    		if(isFull()){
    			throw new RuntimeException("栈满");
    		}
    		//栈顶标记+1
    		top++;
    		arr[top]=value;
    		return value;
    	}
    	
    	//出栈
    	public int pop(){
    		if(isEmpty()){
    			throw new RuntimeException("栈为空");
    		}
    		int value=arr[top];
    		//栈顶标记-1
    		top--;
    		return value;
    	}
    	
    	//遍历栈元素
    	public void see(){
    		if(isEmpty()){
    			return ;
    		}
    		for (int i = 0; i <=top; i++) {
    			System.out.println(arr[i]);
    		}
    	}
    	
    	public static void main(String[] args) {
    	 TEest test=new TEest();
    	 //赋值为20个长度
    		test.numArr(20);
    		//存入1,2,3
    		test.push(1);
    		test.push(2);
    		test.push(3);
    		//出栈操作一次
    		test.pop();
    		//打印数组元素
    		test.see();
    	}
    }
    
    

    六、直接对栈Stack类进行操作

    Stack类继承自Vector类

    	//1、实例化
    	Stack stack = new Stack();
    	//2、进栈
    	stack.push(Object);//返回的是入栈的内容
    	stack.add(Object);//返回的是true或false
    	//3、出栈
    	stack.pop();//输出并删除栈顶元素
    	stack.peek();//输出不删除栈顶元素
    	//4、判断是否为空
    	stack.isEmpty();
    	//5、输出栈([ , , , …])
    	System.out.println(stack);
    	//6、查看某元素在栈中的位置下标,计数从1开始
    	int index = stack.search(Object);
    
    展开全文
  • 设有四个元素A、B、C、D顺序进栈,在进栈过程中可以出栈出栈次序错误排列是: ABCD DCBA ACBD BCDA ACDB DCAB 分析: A进A出,B进B出,C进C出,D进D出。 ABCD依次进入,DCBA依次输出。 A进A出,BC进CB出,D进...
  • 栈的入栈出栈取栈顶(链表实现)

    千次阅读 2018-04-19 11:06:09
    基于链表实现入栈出栈,取栈顶元素操作 链式 入栈 (链表头插) 比较方便 出栈 (链表头删) 头文件 #pragma once //防止头文件重复定义 #include&amp;lt;stdio.h&amp;gt; #include&...
  • 定义一个 typedef struct student{ int data; struct student *next; }node; typedef struct stackqueue{ node *zhandi,*top; };   定义入栈: queue *push(queue *HQ,int x){ node *s,...
  • 栈的入栈出栈操作

    2016-10-19 19:33:24
    #include #define max 26 char stack[max]; int top=0; int push(char x) ...//注意要令i=top-1,因为每次入栈后,top都会指向栈顶之上那个元素 while(i>=0) { printf("%c ",stack[i--]); } }
  • 顺序栈的入栈出栈操作

    千次阅读 2017-12-12 20:13:51
    printf("当前已满,无法入栈!\n"); return ERROR; } s->top++; s->data[s->top] = e; return OK; } Status Pop(Stack *s,ElemType *e) { if (s->top == -1) { printf("当前...
  • **注:java用String存储数据实现队列入队出队:...定义:是先入后出,所以入栈方式和队列一样,但是出栈是返回最后一个数据(即栈顶数据) 定义类: package stack; public class Stack{ private ...
  • 使用链表来模拟栈的入栈出栈操作。 1.节点类代码 public class Entry<T> { private T value; private Entry<T> next; public Entry() { this(null); } public Entry(T value) { this....
  • public interface IsubJect { void test(); }
  • 1.栈的建立和输出,入栈出栈。2.链栈的出栈和入栈。3.数组储存栈和结构体储存栈。4.动态栈和静态栈
  • 元素入栈出栈操作(C)

    千次阅读 2020-03-02 19:13:32
    元素入栈时,会先将压入,top指针再向上加一。C语言如何实现呢,下面是入栈的代码片段: typedef struct node { int * base; int * top; int stacksize; }Sqstack; void Push(Sqstack *S, int elem)//入栈 ...
  • 栈的特性就是 后进先出,如果用链表来实现的话,将新入栈的元素作为链表的最后一个元素,在出栈的时候就不是很好操作。那这样吧,栈顶对链头,栈底对链尾。这样就好操作了。所以在入栈的时候,将新入栈元素的next...
  • 栈的创建入栈出栈

    2013-11-09 14:53:53
    栈的创建入栈出栈 #include #include typedef struct node //结点结构 { int data; struct node *next; }Node, *Pnode; typedef struct stack //栈结构 { Pnode top; Pnode bottom; }Stack,
  • printf("满,入栈失败"); return -1; } //数据压栈 ps->arr[ps->top] = data; ps->top++; } //出栈操作 int pop(Stack* ps) { //空 if (empty) { ...
  • 主要介绍了PHP栈的定义、入栈出栈方法及基于堆栈实现的计算器,结合实例形式较为详细的分析了php定义与使用栈的基本方法,并结合完整实例形式给出了php基于堆栈实现高级计算器功能的相关操作技巧,需要的朋友可以参考下
  • 数组入栈出栈 class Stack{ private Object[] data = new Object[0]; //栈的内容 private int size = 0; //栈的元素个数 public boolean isFull(){ //判断栈是否满 return data.length == size; } ...
  • //使用数组来模拟一个栈的使用 type Stack struct { MaxTop int // 表示我们栈最大可以存放数个数 Top int // 表示栈顶, 因为栈顶固定,因此我们直接使用Top arr [5]int // 数组模拟栈 } //入栈 func (this *S...
  • 栈的入栈出栈

    2020-02-28 22:29:44
    一个栈的入栈序列为ABCDEF,则不可能的出栈序列是(D)  A、DEFCBA B、DCEFBA C、FEDCBA  D、FECDBA E、ABCDEF F、ADCBFE  分析:  该题主要是考虑栈的核心思想是先进后出,并且需要注意入栈和出栈的顺序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,283
精华内容 4,913
关键字:

栈的入栈出栈