精华内容
下载资源
问答
  • 我们使用LinkedList可以很容易模拟出栈,现在我们使用泛型实现栈,模拟内部链式存储机制 public class LinkedStack<T> { //定义一个内部类 private static class Node<U>{ U item; Node<U>...

    我们使用LinkedList可以很容易模拟出栈,现在我们使用泛型来实现栈,模拟内部链式存储机制

    public class LinkedStack<T> {
    //定义一个内部类
    	private static class Node<U>{
    		U item;
    		Node<U> next;
    		Node(){
    			item = null;
    			next = null;
    		}
    		Node(U item,Node<U> next){
    			this.item = item;
    			this.next = next;
    		}
    		boolean end() {
    			return item == null && next ==null;
    		}
    	}
    	//这是一个末端哨兵,用来判断栈是否为空
    	private Node<T> top = new Node<>();
    	//push方法就是模拟进栈操作,会创建一个新的对象,把它链接到前一个对象上。
    	public void push(T item) {
    		top = new Node<T>(item,top);
    	}
    	//模拟弹栈操作
    	public T pop() {
    		T result = top.item;
    		if(!top.end()) {
    			top = top.next;
    		}
    		return result;
    	}
    	public static void main(String[] args) {
    		String[] s = {"a","b","c","d"};
    		LinkedStack<String> li = new LinkedStack<String>();
    		for(String i : s) {
    			li.push(i);
    		}
    		String s1;
    		while((s1 = li.pop()) != null) {
    			System.out.println(s1);
    		}
    	}
    }
    

    在这里插入图片描述

    展开全文
  • 的基本功能定义在接口中,使实现接口即可。 public interface Stack<E> { int getSize();//存储了多少数据 boolean isEmpty(); void push(E e);//顶部放入元素 E pop();//取出并返回顶部元素 E ...

    栈的功能

    将栈的基本功能定义在接口中,使栈类实现接口即可。

    public interface Stack<E> {
        int getSize();//存储了多少数据
        boolean isEmpty();
        void push(E e);//顶部放入元素
        E pop();//取出并返回顶部元素
        E peek();//返回顶部元素
    }

    栈的实现

    在动态泛型数组Array类基础上实现。

    Array类:

    /*
    动态泛型数组 支持所有类元素的存储
     */
    public class Array<E> {//数组中使用类型E 泛型
        private int size;
        private E[] datas;
    
        //构造函数,capacity初始容量,默认为2
        public Array(int capacity){
            //datas=new E[capacity];//E类型不能直接new
            datas=(E[])new Object[capacity];//java中E[]不能直接new,由Object转化转化为E[]子类
        }
        public Array(){
            datas=(E[])new Object[2];
        }
    
        //查看数据数量
        public int getSize(){
            return size;
        }
        //查看是否为空
        public boolean isEmpty(){
            return (size==0);
        }
        //查看数组内容
        @Override//表示覆盖父类函数
        public String toString(){
            StringBuilder str=new StringBuilder();//StringBuilder的使用
            str.append("capacity:"+datas.length+"\nsize:"+size+"\ndatas:");
            for(int i=0;i<size;i++)
                str.append(datas[i]+"\t");
            return str.toString();
        }
        //根据下标查看数据
        public E get(int index){
            if(index<0||index>=size){
                throw new IllegalArgumentException("Get Failed.Index is illegal");
            }
            return datas[index];
        }
        //查看最后一个数据
        public E getLast(){
            return get(size-1);
        }
        //查看第一个数据
        public E getFirst(){
            return get(0);
        }
        //根据下标修改元素
        public boolean set(int index,E data){
            if(index<0||index>=size)
                return false;
            else{
                datas[index]=data;
                return true;
            }
        }
    
        //删除指定位置数据并返回值
        public E remove(int index){
            if(index<0||index>=size)
                throw new IllegalArgumentException("请求不合法,Array.remove(int index)操作失败");
            E ret=datas[index];
            for(int i=index;i<size-1;i++){
                datas[i]=datas[i+1];
            }
            size--;
            datas[size]=null;//置为空才能进行垃圾回收 lolitering objects闲逛元素
            return ret;
        }
        //删除最后一个元素并返回值
        public E remove(){
            return remove(size-1);
        }
        //根据数值获得索引
        public int find(E data){
            for(int i=0;i<size;i++){
                if(datas[i].equals(data))//类元素相等用equals,值比较
                    return i;
            }
            return -1;//-1下标无效
        }
        //获取容量
        public int getCapacity(){
            return datas.length;
        }
        //增加元素
        public void add(E data){
            if(size==datas.length){//此元素将放入size处
                E[] newDatas=(E[])new Object[datas.length*2];
                System.arraycopy(datas,0,newDatas,0,datas.length);
                newDatas[size++]=data;
                datas=newDatas;
            }
            else {
                datas[size++] = data;
            }
        }
    }
    

    ArrayStack类:

    public class ArrayStack<E> implements Stack<E> {
        Array<E> array;
    
        public ArrayStack(int capacity){//泛型类构造函数类名后不加<>
            array=new Array<E>(capacity);
        }
        public ArrayStack(){
            array=new Array<E>();
        }
    
        @Override
        public int getSize(){
            return array.getSize();
        }
    
        @Override
        public boolean isEmpty(){
            return array.isEmpty();
        }
    
        @Override
        public void push(E e){
            array.add(e);
        }
    
        @Override
        public E pop(){
            return array.remove();
        }
    
        @Override
        public E peek(){
            return array.getLast();
        }//已经在接口中定义的函数
    
        public int getCapacity(){
            return array.getCapacity();
        }//未曾在接口中定义的函数
    }

    简单测试:

    public class TeatArrayStack {
        public static void main(String[] args){
            ArrayStack<String> as=new ArrayStack<>(2);//定义初始容量为2的栈
            for(int i=0;i<6;i++){
                as.push("a"+i);
                System.out.print(as.peek()+"\t");
            }//依次放入a0-a5字符串
            System.out.println();
            for(int i=0;i<6;i++){
                System.out.print(as.pop()+"\t");
            }//从顶部取5次数据
        }
    }
    
    展开全文
  • C实现泛型栈

    2015-01-20 11:23:33
    原地址:... typedef struct{ void *elems; //底指针 int loglen; //已经使用的长度 int alloclen; //已经申请的长度 int elemSize; //单个元素的长度 }
    typedef struct{
    void *elems;    //栈底指针
    int loglen;       //已经使用的长度
    int alloclen;    //已经申请的长度
    int elemSize;   //单个元素的长度
    }stack;


    void StackNew(stack *s, int elemSize)
    {
    assert(elemSize > 0);
    s->elemSize = elemSize;
    s->loglen = 0;
    s->alloclen = 4;
    s->elems = malloc(4 *elemSize);
    assert(s->elems != NULL);
    }

    void StackPush(stack *s, void *elemAdd)
    {
            //栈满则采用加倍策略增长
    if (s->loglen == s->alloclen)
    {
              StackGrow(s);
    }

    void *target = (char *)(s->elems) + loglen * (s->elemSize);
    memcpy(target, elemAdd, s->elemSize);
    s->loglen++;
    }

    static  void StackGrow(stack *s)
    {
         s->alloclen *= 2;
          s->elems = realloc(s->elems, (s->alloclen) * (s->elemSize));
    }

    void StackPop(stack *s,  void *elempop)
    {
              //获取栈顶元素指针
    void *source = (char*)(s->elems) + (s->loglen - 1 ) *(s->elemSize);
    memcpy(elempop, source, s->elemSize);
    s->loglen--;
    }

    简单测试
    #include <iostream>
    #include <string>
    using namespace std;

    class Student
    {
            public:
                int id;
                string name;

                Student(){}

                Student(int i,char* n)
                {
                    id = i;
                    name = n;
                }
    };

    int main()
    {
            stack s;
            StackNew(&s,sizeof(Student));

            Student *stu1 = new Student(1,"张三");

            StackPush(&s,stu1);
        
            Student stu2;
            StackPop(&s,&stu2);
        
            cout<<stu2.name<<endl;

            delete stu1;
            stu1 = 0;

            return 0;
    }
    展开全文
  • public class CalculatorDemo {...} public class StackNode<T> {...} public class Stack <T>{...} public class Calculator {...}
  • C语言实现支持泛型

    千次阅读 2014-12-12 11:07:05
    在这篇博文中我们准备一步一步的使用C来实现一个支持泛型,众所周知...一:首先我们先实现一个特定类型的栈(比如用来存储整型的栈),来看一下实现栈一般 都需要哪些内容:  我们分三个文件来实现(stack.h;stack.c;Mai

         在这篇博文中我们准备一步一步的使用C来实现一个支持泛型,众所周知,C++

    有模板机制来支撑泛型(所谓的泛型栈其实就是指一个可以存放任何类型包括用户自定义类型的栈),那么对于C我们如何来支持泛型呢,下面我们将一步一步来现实这个需求:

    一:首先我们先实现一个特定类型的栈(比如用来存储整型的栈),来看一下实现栈一般

    都需要哪些内容: 

    我们分三个文件来实现(stack.h;stack.c;Main.c):

    stack.h  //声明文件,里面包括对Stack以及相应操作(函数)的定义。

    ///
    // Stack.h : declaration file
    // 
    // Version: 1.1
    // Date: 12 September 2014
    // Author: Yu maosheng
    // Email: yums467@nenu.edu.cn
    // Copyright (c) 20014. All Rights Reserved.
    //
    //   History:
    /*
    12.12.2014 11:12       Yu maosheng
    	Added int类型 Stack declaration;
    */
    // 定义一个整型栈
    typedef struct 
    {
    	// 指向栈空间的元素
    	int *element;
    	// 栈顶指针
    	int logLength;
    	// 初始化时栈的长度
    	int allocLength; 
    }stack;
    //声明 初始化栈的函数
    void stackNew(stack *s);
    // 声明 销毁栈的函数
    void stackDispose(stack *s);
    // 声明 向栈中推入一个元素的函数
    void stackPush(stack *s, int value);
    // 声明 从栈中退出一个元素的函数
    int stackPop(stack *s);
    
    
    通过这个头文件我们可以看出实现一个栈,我们需要一个栈空间,一个指示栈顶

    元素的标示,为了实现方便我们还添加了一个指示栈空间大小的元素。

    同时我们还有针对栈实现的操作:初始化栈,推入一个元素,退出一个元素,

    销毁栈。

    下面Stack.c文件是对Stack.h里面声明的函数的实现。

    ///
    // Stack.c : Implementation file
    // 
    // Version: 1.1
    // Date: 12 September 2014
    // Author: Yu maosheng
    // Email: yums467@nenu.edu.cn
    // Copyright (c) 20014. All Rights Reserved.
    //
    //   History:
    /*
    12.12.2014 11:12       Yu maosheng
    	Added int Stack function Implementation;
    */
    #include <stdlib.h>
    #include <assert.h>
    #include "Stack.h"
    //stackNew的实现
    void stackNew(stack *s)
    {
    	//初始化栈顶的位置
    	s->logLength = 0;
    	//设定栈的初始大小(应该理解为所存放元素个数)
    	s->allocLength = 4;
    	//分配栈空间
    	s->element = malloc(s->allocLength * sizeof(int));
    	//检查地址是否分配成功
    	assert(s->element != NULL);
    	return;
    }
    //stackDispose的实现
    void stackDispose(stack *s)
    {
    	//释放栈空间
    	free(s->element);
    	return;
    }
    //stackPush的实现
    void stackPush(stack *s, int value)
    {
    	//检查栈空间是否已满,如果满则拓展空间
    	if (s->logLength == s->allocLength)
    	{
    		s->allocLength *= 2;
    		s->element = realloc(s->element, s->allocLength * sizeof(int));
    		assert(s->element != NULL);
    	}
    	//将元素放到栈顶位置
    	//printf("%d \n", s->logLength);
    	s->element[s->logLength++] = value;
    
    	return;
    }
    //stackPop函数的实现
    int stackPop(stack *s)
    {
    	//将栈顶元素弹出
    	assert(s->logLength > 0);
    	return s->element[--s->logLength];
    }
    
    经过上面的代码我们就实现了具体栈上的操作。下面我们来对这个栈进行

    测试工作,看看咱们是否已经正确实现了这个栈。

    Main.c

    ///
    // Main.c : Test file
    // 
    // Version: 1.1
    // Date: 12 September 2014
    // Author: Yu maosheng
    // Email: yums467@nenu.edu.cn
    // Copyright (c) 20014. All Rights Reserved.
    //
    //   History:
    /*
    12.12.2014 18:00       Yu maosheng
    Added int Stack Test in Main ;
    */
    #include "Stack.h"
    
    int main(int argc, char const *argv[])
    {
    	stack s;
    	stackNew(&s);
    
    	for (int i = 0; i < 4; ++i)
    	{
    		stackPush(&s, i);
    	}
    	printf("%d\n", stackPop(&s));
    	//销毁栈
    	stackDispose(&s);
    	return 0;
    }
    执行后,程序在控制台输出了3,这说明我们的实现是正确的!


    二、按照上文所述,我们已经实现了一个可以存放整型数据的栈,并实现了

    栈上的操作(栈的初始化、入栈、出栈、销毁栈),然而对于一个栈,我们不能

    仅仅用来存放整型数据呀,如果我想存放double类型的数据怎么办呢?一种

    方式是我们再实现一个double类型的栈,那如果我又想存放一个自定义类型的

    数据呢?看来上面的方式是行不通了,在这里我们将要实现一个支持泛型的

    栈,实现一个泛型栈的技巧则是利用void指针。

    首先我们要修改结构体stack的定义,将指向栈空间的指针元素element由int*修

    为viod*,同时添加一个指示用户数据结构大小的变量int elemSize。

    然后我们还要修改关于stack一些操作的函数的声明:

    //声明 初始化栈的函数

    void stackNew(stack *s, int elemSize);
    函数参数添加一项 int elemSize,这一项将用在为栈开辟 空间时决定每一个元

    素的大小的。

    // 声明 向栈中推入一个元素的函数
    //void stackPush(stack *s, int value);
    void stackPush(stack *s, void *elemAddr);
    添加参数 void *elemAddr,用来指示要入栈元素的地址

    // 声明 从栈中退出一个元素的函数
    //int stackPop(stack *s);
    void stackPop(stack *s,void *elemAddr);
    添加参数 void *elemAddr,用来指示用来存储出栈元素的地址

    这就是stack.h所做的修改

    到现在stack.h文件代码如下:

    ///
    // Stack.h : declaration file
    // 
    // Version: 1.1
    // Date: 12 September 2014
    // Author: Yu maosheng
    // Email: yums467@nenu.edu.cn
    // Copyright (c) 20014. All Rights Reserved.
    //
    //   History:
    /*
    12.12.2014 11:12       Yu maosheng
    	Added int类型 Stack declaration;
    
    12.12.2014 18:37       Yu maosheng
    	修改了stack结构体的定义;
    12.13 2014 13:42       Yu maosheng
    	修改了stackNew,stackPush,stackPop三个函数的定义
    */
    // 定义一个整型栈
    typedef struct 
    {
    	// 指向栈空间的元素
    	//int *element;
    	//支持泛型,重新定义栈空间元素
    	void *element;
    	//添加一项指示用户数据结构大小的变量
    	int elemSize;
    	// 栈顶指针
    	int logLength;
    	// 初始化时栈的长度
    	int allocLength; 
    }stack;
    //声明 初始化栈的函数
    //void stackNew(stack *s);
    void stackNew(stack *s, int elemSize);
    // 声明 销毁栈的函数
    void stackDispose(stack *s);
    // 声明 向栈中推入一个元素的函数
    //void stackPush(stack *s, int value);
    void stackPush(stack *s, void *elemAddr);
    // 声明 从栈中退出一个元素的函数
    //int stackPop(stack *s);
    void stackPop(stack *s,void *elemAddr);
    
    
    继续,我们来修改stack.c文件,修改上述函数的具体实现。

    1.stackNew函数要修改分配空间的代码,空间的大小不再是

    s->allocLength * sizeof(int),而是s->allocLength * elemSize。

    void stackNew(stack *s, int elemSize)
    {
    	//初始化栈顶的位置
    	s->logLength = 0;
    	//设定栈的初始大小
    	s->allocLength = 4;
    	//给栈成员elemSize赋值
    	s->elemSize = elemSize;
    	//分配栈空间
    	s->element = malloc(s->allocLength * elemSize);
    	//检查地址是否分配成功
    	assert(s->element != NULL);
    	return;
    }

    2.stackPush函数要修改空间增长的代码,元素入栈代码。

    为了代码的优雅,我们将空间增长代码也封装成一个函数stackGrow(),

    在获得栈顶指针的时候,我们不能再单纯的使用栈顶元素logLength指示了,

    我们需要从具体的内存地址中找到相应的栈顶位置。

    void *target = (char *)(s->element) + s->logLength * s->elemSize;
    target指针指示的就是栈顶位置的内存地址,我们将其要入栈元素的地址拷贝到我们的栈顶地址 中去:

    memcpy(target, elemAddr, s->elemSize);

    具体实现代码如下:

    void stackPush(stack *s, void *elemAddr)
    {
    	//检查栈空间是否已满,如果满则拓展空间
    	if (s->logLength == s->allocLength)
    	{
    		//s->allocLength *= 2;
    		//s->element = realloc(s->element, s->allocLength * sizeof(int));
    		//调用增长栈空间的函数
    		stackGrow(s);
    		assert(s->element != NULL);
    	}
    	//将元素放到栈顶位置
    	//printf("%d \n", s->logLength);
    	//s->element[s->logLength++] = value;
    	//获得栈顶地址
    	void *target = (char *)(s->element) + s->logLength * s->elemSize;
    	memcpy(target, elemAddr, s->elemSize);
    	s->logLength++;
    	//printf("%d %d %s\n", s->logLength, s->elemSize, (char *)(s->element) + (s->logLength - 1) * s->elemSize);
    	return;
    }
    3.stackPop函数跟stackPush修改的地方类似,主要是寻找栈顶元素地址方式的改变,

    我们用source指针来指示栈顶地址。

    void stackPop(stack *s, void *elemAddr)
    {
    	//将栈顶元素弹出
    	assert(s->logLength > 0);
    	//s->logLength--;
    	void *source = (char *)(s->element) + (s->logLength - 1) * s->elemSize;
    	memcpy(elemAddr, source, s->elemSize);
    	s->logLength--;
    	printf("Pop:%d ", s->logLength);
    	//return s->element[--s->logLength];
    }
    那么stack.c总体的代码如下:

    ///
    // Stack.c : Implementation file
    // 
    // Version: 1.1
    // Date: 12 September 2014
    // Author: Yu maosheng
    // Email: yums467@nenu.edu.cn
    // Copyright (c) 20014. All Rights Reserved.
    //
    //   History:
    /*
    12.12.2014 11:12       Yu maosheng
    	Added int Stack function Implementation;
    12.13.2014 13:44       Yu maosheng
    	重新修改了stackNew,stackPush,stackPop的实现
    	添加了stackGrow函数
    */
    #include <stdlib.h>
    #include <stdio.h>
    #include <assert.h>
    #include <string.h>
    #include "Stack.h"
    //增长栈空间的函数
    static void stackGrow(stack *s)
    {
    	s->allocLength *= 2;
    	s->element = realloc(s->element, s->allocLength * s->elemSize);
    
    	return;
    }
    //stackNew的实现
    void stackNew(stack *s, int elemSize)
    {
    	//初始化栈顶的位置
    	s->logLength = 0;
    	//设定栈的初始大小
    	s->allocLength = 4;
    	//给栈成员elemSize赋值
    	s->elemSize = elemSize;
    	//分配栈空间
    	s->element = malloc(s->allocLength * elemSize);
    	//检查地址是否分配成功
    	assert(s->element != NULL);
    	return;
    }
    //stackDispose的实现
    void stackDispose(stack *s)
    {
    	//释放栈空间
    	free(s->element);
    	return;
    }
    //stackPush的实现
    void stackPush(stack *s, void *elemAddr)
    {
    	//检查栈空间是否已满,如果满则拓展空间
    	if (s->logLength == s->allocLength)
    	{
    		//s->allocLength *= 2;
    		//s->element = realloc(s->element, s->allocLength * sizeof(int));
    		//调用增长栈空间的函数
    		stackGrow(s);
    		assert(s->element != NULL);
    	}
    	//将元素放到栈顶位置
    	//printf("%d \n", s->logLength);
    	//s->element[s->logLength++] = value;
    	//获得栈顶地址
    	void *target = (char *)(s->element) + s->logLength * s->elemSize;
    	memcpy(target, elemAddr, s->elemSize);
    	s->logLength++;
    	//printf("%d %d %s\n", s->logLength, s->elemSize, (char *)(s->element) + (s->logLength - 1) * s->elemSize);
    	return;
    }
    //stackPop函数的实现
    void stackPop(stack *s, void *elemAddr)
    {
    	//将栈顶元素弹出
    	assert(s->logLength > 0);
    	//s->logLength--;
    	void *source = (char *)(s->element) + (s->logLength - 1) * s->elemSize;
    	memcpy(elemAddr, source, s->elemSize);
    	s->logLength--;
    	printf("Pop:%d ", s->logLength);
    	//return s->element[--s->logLength];
    }
    
    接下来我们使用Main.c文件来测试

    ///
    // Main.c : Test file
    // 
    // Version: 1.1
    // Date: 12 September 2014
    // Author: Yu maosheng
    // Email: yums467@nenu.edu.cn
    // Copyright (c) 20014. All Rights Reserved.
    //
    //   History:
    /*
    12.12.2014 18:00       Yu maosheng
    	Added int Stack Test in Main ;
    12.13.2014 14:22	   Yu maosheng
    	对支持泛型的栈添加测试用例(字符串数组)
    2014 12.19 13:00       Yu maosheng
    	测试程序,寻找在哪出现了段错误
    	stackPush(&strStack, copy);错误在这:应该取copy变量的地址作为push函数的参数
    	stackPush(&strStack, &copy);像这个样子
    	因为向栈中写入的应该是字符串的地址而不是字符串本身
    */
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include "Stack.h"
    #pragma warning(disable:4996)//之所以加这一句是因为strdup报错
    
    int main(int argc, char const *argv[])
    {
    	const char *friends[] = {"Alex","Bob","Caser"};
    	stack strStack;
    	stackNew(&strStack, sizeof(char *));
    	
    	for (int i = 0; i < 3; ++i)
    	{
    		//stackPush(&s, i);
    		//strdup功 能: 将串拷贝到新建的位置处
    		//strdup在内部调用了malloc()为变量分配内存,
    		//不需要使用返回的字符串时,需要用free()释放
    		//相应的内存空间,否则会造成内存泄漏。
    		char *copy = strdup(friends[i]);
    		stackPush(&strStack, &copy);
    		//free(copy);
    	}
    	for (int j = 0; j < 3; j++)
    	{
    		char *name;
    		name = malloc(sizeof(char *));
    		stackPop(&strStack, &name);
    		printf("%s\n", name);
    		free(name);
    	}
    	//printf("%d\n", stackPop(&s));
    	//销毁栈
    	stackDispose(&strStack);
    	printf("Over\n");
    
    	return 0;
    }
    我们向栈中推送三个字符串,然后将这三个字符串再推出栈并输出到控制台中:



    在这我想强调一点,以前我们在实现整型栈的时候栈空间元素存放的是入栈元素

    本身的值,而对于泛型栈,我们在泛型栈空间里存放的是指向元素的指针。

    拿上面那三个字符串为例,我们在栈中存放的是指向"Carse"的指针,而不是"Carse"

    本身。

    写到这,貌似问题都解决了吧? 是吗? 如果我们的栈内元素本身就是指针或者句柄

    怎么办(他们本身也开辟了存储空间,我们需要释放这些空间)?在这里我们要修改

    stack结构体的定义,在里面添加一项用来指向函数的指针成员,这个函数具体让用

    户自己定义来实现释放自定义数据类型空间。

    void (*freefn)(void *element);

    我们在stackNew函数中给这个结构体中函数指针赋值

    修改stackNew如下:

    void stackNew(stack *s, int elemSize, void (*freefn)(void *element))
    {
    	//初始化栈顶的位置
    	s->logLength = 0;
    	//设定栈的初始大小
    	s->allocLength = 4;
    	//给栈成员elemSize赋值
    	s->elemSize = elemSize;
    	//给函数指针赋值
    	s->freefn = freefn;
    	//分配栈空间
    	s->element = malloc(s->allocLength * elemSize);
    	//检查地址是否分配成功
    	assert(s->element != NULL);
    	return;
    }
    给stackNew函数添加一个参数,用来初始化栈的指针函数成员。


    修改stackDispose函数:

    void stackDispose(stack *s)
    {
    	if (s->freefn != NULL)
    	{
    		for (int i = 0; i < s->logLength; i++)
    		{
    			s->freefn((char *)s->element + i * s->elemSize);
    		}
    	}
    	//释放栈空间
    	free(s->element);
    	return;
    }
    在实际应用中我们根据自己定义的数据结构空间的申请方式来定义
    void (*freefn)(void *element);
    
    的具体实现函数,并作为一个参数在栈初始化的时候赋值。

    到此我们就完整的实现了一个支持泛型的栈。



















    展开全文
  • C中泛型实现

    2015-11-28 16:06:11
    在数据结构中有很多种数据结构相关算法的实现都需要用到。如表达式求值,迷宫求解,中序遍历二叉树的非递归算法,拓扑排序,关键路径等等,算法都需要用。所以,有时候需要用一个”泛型“数据结构。而不是用...
  • 所以链表的实现需要有两个对象。  1.链表本身:linkedlist  2.链表中的元素:也叫结点,node  接着我们来分析这两个对象中有哪些属性。首先是linkedlist,它要有一个size属性,用来记录集合中的数据个数,所以...
  • 构造栈与与实现栈的基本操作2.具体实例测试代码1、String类实现2、Integer类实现总结 前言 用Java实现顺序栈的基本操作,采用泛型结构,可以适应更多场合运用,避免了上篇文章只是储存int类型的单链表的缺点。本文...
  • C++模板实现泛型队列

    千次阅读 2015-08-18 15:54:35
    这里利用C++模板实现一个泛型队列,其原理是利用数组来实现循环队列。下面给出代码,以供参考: 头文件中 #pragma once #ifndef __AQUEUE #define __AQUEUE //数组队列,环形队列 template class Aqueue { public:...
  • 泛型可以参数化变量的类型 当你需要用不同类型的基本类型变量来调用构造方法时你需要泛型 public class Test { public static void main(String[] args) { A a=new A("a"); System.out.println(a.e); A a1=new ...
  • C语言实现一个泛型栈

    2012-11-07 20:25:24
    C语言不能很好的处理泛型数据,不过下面这个泛型栈提供了一种思路,把对数据的操作看作是对一格一格内存的操作,利用Memory头文件里的函数可以做到这一点。可以通过这种思路延伸到队列等其他数据结构中,把对数据的...
  • 今天突然发现利用java语言特性能很
  • C/C++泛型编程实现数据结构之

    万次阅读 2018-09-14 10:37:05
    在这里我们会把它分成顺序存储结构和链式存储结构两种方案进行划分,也就是说这里我们会编写两个模板类来实现栈的基本操作。 栈的基本操作 判栈满(顺序存储结构) 判栈空 入栈 出栈 取栈顶元素 初始化栈 顺序...
  • 泛型栈的学习

    2015-05-26 21:08:50
    进行到泛型栈的学习(其实已经知道很多数据结构和算法,只是希望 用Java配个这本书实现学习一遍,巩固,增强)泛型栈代码: FixedCapacityStackOfStrings.java package fixedCapacityStackOfStrings;public class ...
  • 1. 泛型泛型”意思就是适用于许多类型。 使用泛型的目的之一: 指定容器持有什么类型,让编译器确保正确性,而不是在运行期发现错误。 这个容器可以看成是有其他类型对象作为成员的类,而不单单只是JDK中的容器...
  • 泛型允许我们使用类型参数Type parameter,它用一个自定义的标识符(T、V、E)来代表一个类型,用括住,放在类名后面。然后在类定义中所有使用该类型的地方都用这个标识符来代替,因为在定义这个类的时候还不知道这个...
  • 栈的创建-----用链表实现栈

    千次阅读 2018-11-01 09:09:03
    2、节点存储的是泛型数据 3、创建一个的接口----定义如下函数: 4、接口实现类(栈顶元素指针和链表元素计数器) 代码实现: 接口类:StackADT  public interface StackADT &lt;T&gt; { /** ...
  • Java泛型实现:“禁止”泛型数组

    千次阅读 多人点赞 2016-07-28 20:24:44
    1. 问题来源今天在刷题时,遇到了需要使用泛型数组的场景。题目是按之字形打印二叉树。这道题目需要交替使用两个来解决,我的初始代码为:ArrayDeque[] stacks = new ArrayDeque[2]; //1 stacks[0] = new ...
  • C/C++泛型编程实现数据结构之广义表

    万次阅读 2018-09-18 09:23:58
    C/C++泛型编程实现数据结构之广义表 广义表是线性表的推广,又称列表。线性表的元素只限于原子项,即每个数据元素只能是一个数或一个记录,如果放松对线性表元素的这种限制,允许他们自身具有结构,那么就产生了广义...
  • 什么是泛型?为什么要使用泛型

    千次阅读 2018-04-19 20:57:45
    我们在编写程序时,经常遇到两个模块的功能非常相似...在方法中传入通用的数据类型,就可以用来合并代码,这就是泛型。 为什么要使用泛型 为了了解这个问题,我们先看下面的代码,代码省略了一些内容,但功能
  • Java集合面试题

    万次阅读 多人点赞 2019-06-25 14:46:19
    Java 平台不提供这个接口任何直接的实现。 Set ,是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模,被用来代表集合,就如一副牌。 List ,是一个有序集合,可以包含重复元素。你可以通过它的索引来...
  • (stack)是一种特殊的线性表,其插入和删除操作只允许在线性表的一端进行。 ... * 接口,描述的抽象数据类型,泛型参数T表示数据元素的数据类型 */ public interface SStack<T>...
  • Swift3.0中文教程:23.泛型

    千次阅读 2016-12-15 11:05:33
    泛型代码让你能够根据自定义的需求,编写出适用于任意类型、灵活可重用的函数及类型。它能让你避免代码的重复,用一种清晰和抽象的方式来表达代码的意图。 泛型是 Swift 最强大的特性之一,许多 Swift 标准库是通过...
  • 泛型特性、队列与

    2019-07-09 17:09:00
    利用“参数化类型” 将类型抽象化,从而实现灵活的复用。 泛型是C#2.0以后的一种新语法,不是语法糖 为什么用泛型 1、减少装箱和拆箱,提高运行效率 List<int> list = new List<int>(); 2、类型...
  • (利用继承实现MyStack)在程序清单11-10中,MyStack是用组合实现的。创建一个继承自 ArrayList的新的类MyStack。编写一个测试程序,提示用户输人5个字符串,然后以逆序显示这些字符串。 【课本389页11-10】 运行...
  • JAVA用数组实现顺序

    2021-04-02 20:11:24
    想要实现栈需要有以下方法:isEmpty()(判断为空),peek()(返回到栈顶),push()(出栈),pop()(入栈). 提示:以下是本篇文章正文内容,下面案例可供参考 一、首先需要定义一个栈类 首先需要创建一个Stack类,然后定义一...
  • java中基于数组的栈实现

    千次阅读 2018-09-18 14:51:06
    在java中利用数组来实现栈以及相关操作。 首先我们要新建一个类,该类中new一个固定大小的数组,来充当我们的栈,来容纳入栈的数据。 在该类中我们可以对栈进行出栈入栈,扩容,和获取栈顶元素等操作。在该类中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,221
精华内容 6,888
关键字:

利用泛型实现栈