精华内容
下载资源
问答
  • 记一下可能会用到的东西vector.resize(n) 将向量改成空间大小为n的数组 priority_queue.top() 还有就是记一下这鬼单词咋写... .front() 这个是普通queue的 .pop() 删除队首 stack.push( )...先跳过,感觉自己不会...

    记一下可能会用到的东西

    vector

    .resize(n) 将向量改成空间大小为n的数组
    

    priority_queue

    .top() 还有就是记一下这鬼单词咋写...
    .front()  这个是普通queue的
    .pop()   删除队首
    

    stack

    .push( )...栈先跳过,感觉自己不会用
    
    展开全文
  • c++模版编程构造栈和向量vector向量栈 向量 //使用 声明通例 template <typename T> class my_vector{ T* my_array; unsigned size; unsigned block_size; public: my_vector(unsigned bsz):my...

    c++模版编程构造栈和向量vector

    向量

    
        //使用 声明通例
    template <typename T>
    class my_vector{
        T* my_array;
        unsigned size;
        unsigned  block_size;
    
    public:
        my_vector(unsigned bsz):my_array((T*)malloc(sizeof(T)*bsz)),size(0),block_size(bsz){}
    
        ~my_vector(){
            if(my_array)
                free(my_array);
        }
    
        void push_back(T const & elem) throw (std::runtime_error){
            if (size == block_size){
                //已经有的空间已经用完,需要重新分配空间
                block_size *=2;
                T*new_array=(T*)realloc(my_array,block_size* sizeof(T));
                if(new_array != NULL){
                    my_array=new_array;
                }else{
                    //申请空间失败,内存耗尽
                    free(my_array);
                    my_array=NULL;
                    throw std::runtime_error("out of memory");
                }
    
            }
            my_array[size++]=elem;
        }
    
        T&operator[](unsigned i){
            return my_array[i];
        }
    
        const T &operator[](unsigned  i) const {
            return  my_array[i];
        }
    
        //告诉占用了多少内存
        unsigned get_mem_size()const{
            return block_size*sizeof(T);
        }
    
    
    };
    //声明my_vector的特例
    
    template <>
    class my_vector<bool>{
        int * array;
        unsigned size;
        unsigned block_size;
    
        //一个段(segment)即是一个整数值,段的大小极为一个整数值所能容纳的作答的布尔值
        // =sizeof(int)*8
        const static unsigned seg_size;
    
    public:
        my_vector(unsigned bsz=1):array((int*)malloc(sizeof(int)*bsz)),size(0),block_size(bsz){}
    
        ~my_vector(){
            if (array){
                free(array);
            }
    
        }
    
        void  push_back(bool elem) throw (std::runtime_error){
            if(size == block_size*seg_size){
                block_size*=2;
                int * new_array=(int*)realloc(array,block_size* sizeof(int));
                if(new_array!=NULL){
                    array=new_array;
                }else{
                    free(array);
                    array=NULL;
                    throw std::runtime_error("Out of memory");
                }
            }
    
            set(size++,elem);
        }
    
        void set(unsigned i,bool elem){
            if(elem){
                array[i/seg_size] |=(0x1<<(i%seg_size));
            }else{
                array[i/seg_size] &= ~(0x1<<(i%seg_size));
            }
        }
    
        bool operator[](unsigned i)const {
            return (array[i/seg_size]&(0x1<<(i%seg_size)))!=0;
        }
        unsigned get_mem_size()const{
            return block_size* sizeof(int);
        }
    };
    const unsigned my_vector<bool>::seg_size = sizeof(int)*8;
    
    

    // 文件名:stack.hpp
        #include <stdexcept>
        template<typename T> class my_stack;   //前置栈类模板声明
        template<typename T>
        class list_node
        {
            T value;
            list_node *next;
            // 私有构造函数,只能由其友类构造
            list_node(T const &v, list_node *n) :
                value(v), next(n) {}
            // 友类必须是类模板my_stack的实例
            friend class my_stack<T>;
        };
        template<typename T=int>
        class my_stack {
            typedef list_node<T> node_type;
            node_type *head;
            // my_stack不可复制构造,也不可赋值
            my_stack operator=(my_stack const &) {}
            my_stack(my_stack const &s) {}
        public:
            // 构造与析构
            my_stack() : head(0) {}
            ~my_stack() {while (!empty()) pop();}
            // 在类模板内实现的成员函数模板
            bool empty() const {return head == 0;}
            T const& top() const throw (std::runtime_error) {
                if (empty())
                      throw std::runtime_error("stack is empty.");
                return head->value;
            }
    void push(T const &v) {head = new node_type(v, head);}
        // 成员函数声明,将在类模板外实现
        void pop();
    };
    // 在类模板外实现的成员函数模板
    template<typename T>
    void my_stack<T>::pop()
    {
        if (head) {
            node_type *tmp = head;
            head = head->next;
            delete tmp;
        }
    }
    
    展开全文
  • 通过向量实现

    2012-10-17 14:35:16
    //通过向量实现 package tt; import java.util.*; public class dds { // 字段 Vector v; // 构造函数 public dds() { v = new Vector(); } // 元素的个数 public int size() { return v.size();...
    //通过向量实现栈
    package tt;
    
    import java.util.*;
    
    public class dds
    {
    	// 字段
    	Vector v;
    
    	// 构造函数
    	public dds()
    	{
    		v = new Vector();
    	}
    
    	// 元素的个数
    	public int size()
    	{
    		return v.size();
    	}
    
    	// 是否为空
    	public boolean isEmpty()
    	{
    		return size() == 0;
    	}
    
    	// 进栈
    	public Object Push(Object obj)
    	{
    		v.addElement(obj);
    		return obj;
    	}
    
    	// 出栈方法
    	public Object Pop()
    	{
    		int len = size();
    		Object obj = Peek();
    		v.removeElementAt(len - 1);
    		return obj;
    	}
    
    	// 查看栈顶元素
    	public Object Peek()
    	{
    		int len = size();
    		if (len == 0)
    			throw new EmptyStackException();
    		return v.elementAt(len - 1);
    	}
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args)
    	{
    		// TODO Auto-generated method stub
    		dds vst = new dds();
    		System.out.println("大小:" + vst.size());
    		vst.Push("123");
    		vst.Push("456");
    		vst.Push("789");
    		vst.Push("abc");
    		System.out.println("大小:" + vst.size());
    		System.out.println("栈顶:" + vst.Peek());
    		System.out.println("出栈:" + vst.Pop());
    		vst.Push("def");
    		vst.Push("147");
    		System.out.println("大小:" + vst.size());
    		System.out.println("栈顶:" + vst.Peek());
    		System.out.println("出栈:" + vst.Pop());
    		System.out.println(vst.Peek());
    		vst.Push("def");
    		vst.Push("147");
    		System.out.println(vst.Pop());
    		System.out.println(vst.Pop());
    		System.out.println(vst.Peek());
    		System.out.println(vst.Pop());
    		System.out.println(vst.Pop());
    		vst.Push("1aadf");
    		vst.Push("2dafad");
    		vst.Push("123789");
    		System.out.println(vst.Pop());
    		System.out.println(vst.Peek());
    		System.out.println(vst.Pop());
    		System.out.println(vst.Peek());
    		System.out.println("------------------end------------");
    		VectorStackTest llst = new VectorStackTest();
    		llst.Push("123");
    		llst.Push("456");
    		System.out.println("栈顶:" + llst.Peek());
    		System.out.println("出栈:" + llst.Pop());
    		System.out.println(llst.Peek());
    		llst.Push("789");
    		llst.Push("abc");
    		System.out.println("栈顶:" + llst.Peek());
    		System.out.println("出栈:" + llst.Pop());
    		System.out.println(llst.size());
    		System.out.println("栈顶:" + llst.Peek());
    	}
    
    }
    


    展开全文
  • 模板,向量

    2020-05-23 10:33:45
    1.模板提供了在函数和类中参数化类型的能力。 2.可以定义适用于通用类型的函数和类,编译器会将通用类型替换为特定的具体类型。 3.模板函数的定义以关键字...6.如果元素按照后进先出的方式访问则应使用来存储元素。 7.

    1.模板提供了在函数和类中参数化类型的能力。
    2.可以定义适用于通用类型的函数和类,编译器会将通用类型替换为特定的具体类型。
    3.模板函数的定义以关键字 template开始,后接一个参数列表。每个参数必须以关键字 class或 typename开头,形式为或
    4.设计一个通用函数,最好先设计非通用版本,调试测试完毕后,再转换为通用版本。
    5.声明模板类的语法基本上与声明模板函数相同。在类声明前需放置模板前缀,就像在模板函数前放置模板前缀一样。
    6.如果元素按照后进先出的方式访问则应使用栈来存储元素。
    7.数组在创建后大小就固定了。C++提供了 vector类,比数组更加灵活
    8. vector类是一个通用类,可以用它创建各种具体类型的对象。
    9.可以像使用数组一样使用 vector对象而且在需要的时候该对象的大小可以自动增加。

    展开全文
  • 数据结构中“字符串 向量 链表 和队列”等类型的模板实现
  • C++程序设计模板 1. 模板基础 模板功能提供了在函数和类中将类型作为参数的能力,可以设计具有通用类型的函数和类,而编译 器可在编译时将通用类型确定为一种特定类型 //一个求最大值的通用模板 ...
  • 向量、队列、

    2021-01-29 16:16:10
    name //typename:向量元素类型 name:向量名字 int main() { int myArray[] = {1, 2, 3, 4, 5}; vector<int> myVector1; vector<int> myVector2(myArray, myArray + 5); vector<int> ...
  • 22.9 向量类Vector和类StackJava集合框架是在Java 2中引入的。Java 2之前的版本也支持一些数据结构,其中就有向量类Vector与类Stack。为了适应Java集合框架,Java 2对这些类进行了重新设计,但是为了向后兼容,...
  • 向量(Vector) (Stack) 字典(Dictionary) 哈希表(Hashtable) 属性(Properties) 以上这些类是传统遗留的,在Java2中引入了一种新的框架-集合框架(Collection)。 枚举(Enumeration)...
  • 第2章 向量 2.1 向量的插入和删除 方向比较重要,插入从后往前移动;删除从前往后移动,如果从后往前,会导致重叠部分覆盖掉。 ----------------*********|||||||||||||||||| --------------...
  • 非空时,依次将栈顶元素出栈,并和字符向量后半段的元素比较,当栈顶元素和当前字符向量不相同,说明不是回文字符向量,返回FALSE;反之,将新的栈顶元素和下一个字符比较,直到为空时,说明是回文向量。 2.当...
  • 可以定义一个输出中元素的函数模板,函数参数是的引用: #include #include #include #include <sstream> // 将数字转化为字符串 #include <algorithm> #include "E:\back_up\code\c_plus_code\...
  • 自学数据结构和算法到现在时间也不短了,一直犹豫着要不要写一写向量等几个最最基本的数据结构,因为总觉得是最基本的,太容易了,不想花这个时间去写。然而学着学着慢慢发现,虽然这个很基本,但我并不一定能够做好...
  • 、队列、向量

    2017-09-28 19:24:32
    #include #include #include #include #include #include using namespace std; bool IsPrime(int nInteger) { if (nInteger ) return false; for (int i = 2; i*i ; i++)
  • 用两个来实现一个队列 题目描述 用两个来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。 class Solution { public: void push(int node) { //将所有数据存储在stack1后再加入新元素 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,256
精华内容 502
关键字:

向量栈