"《算法导论》之‘栈’"：栈的三种实现（静态数组、动态数组及指针）
本文有关栈的介绍部分参考自网站数据结构。
1. 栈
1.1 栈的定义
栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。
（1）通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。
（2）当表中没有元素时称为空栈。
（3）栈为后进先出（Last In First Out）的线性表，简称为LIFO表。
栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。
【示例】元素是以a1，a2，…，an的顺序进栈，退栈的次序却是an，an-1，…，a1。
1.2 栈的运算
（1）initStack（S）
构造一个空栈S。
（2）isEmpty（S）
判栈空。若S为空栈，则返回TRUE，否则返回FALSE。
（3）isFull（S）
判栈满。若S为满栈，则返回TRUE，否则返回FALSE。
注意：
该运算只适用于栈的顺序存储结构。
（4）push（S，x）
进栈。若栈S不满，则将元素x插入S的栈顶。
（5）pop（S）
退栈。若栈S非空，则将S的栈顶元素删去，并返回该元素。
（6）top（S）
取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。
2. 栈的三种实现
我在实现的时候，栈的基本函数都有（isEmpty、push、pop、top）。因为我是用面向对象的方法来设计栈，所以栈的初始化、拷贝构造、赋值运算符重载等也都具备。另外，我采取了C++中的模板类来设计栈，使得该栈设计能适应更多的场合。
2.1 基于静态数组
基于静态数组的栈的最大特点就是栈的大小是固定的，用户在初始化之后就无法改变。在编译期，编译器就已经给这个栈分配好内存，在“内存的栈”上分配。
这是我所设计的栈模板类：
template<class T, int defCapacity = >
class Stack
{
public:
Stack();
virtual ~Stack();
bool isEmpty();
bool push(T val); // 进栈。若栈不满，则将元素插入栈顶。
T top(); // 取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。
bool pop(); // 退栈。若栈非空，则将栈顶元素删去，并返回是否退栈成功的标志。
// 这里没有采用返回被删栈顶元素的原因在于这里写的是一个模板，
// 当栈为空的时候不方便返回。当然，这个问题是可以通过断言或
// 抛异常来解决的。具体做法可根据具体情况来定。
int getSizeOfStack(); private:
T stack[defCapacity];
int sizeOfStack; };
具体实现代码为：
#include <iostream>
#include <cassert>
using namespace std; // const int CAPACITY = 1024; template<class T, int defCapacity = >
class Stack
{
public:
Stack();
virtual ~Stack();
bool isEmpty();
bool push(T val); // 进栈。若栈不满，则将元素插入栈顶。
T top(); // 取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。
bool pop(); // 退栈。若栈非空，则将栈顶元素删去，并返回是否退栈成功的标志。
// 这里没有采用返回被删栈顶元素的原因在于这里写的是一个模板，
// 当栈为空的时候不方便返回。当然，这个问题是可以通过断言或
// 抛异常来解决的。具体做法可根据具体情况来定。
int getSizeOfStack(); private:
T stack[defCapacity];
int sizeOfStack; }; template<class T, int defCapacity>
Stack<T, defCapacity>::Stack()
{
sizeOfStack = ;
} template<class T, int defCapacity>
Stack<T, defCapacity>::~Stack()
{ } template<class T, int defCapacity>
bool Stack<T, defCapacity>::isEmpty()
{
return sizeOfStack == ;
} template<class T, int defCapacity>
bool Stack<T, defCapacity>::push(T val)
{
// assert(sizeOfStack < defCapacity);
bool isSuccess = true;
if (sizeOfStack == defCapacity)
{
cerr << "There is no space for new elements." << endl;
isSuccess = false;
}
else
{
stack[sizeOfStack] = val;
sizeOfStack++;
}
return isSuccess;
} template<class T, int defCapacity>
T Stack<T, defCapacity>::top()
{
return stack[sizeOfStack - ];
} template<class T, int defCapacity>
bool Stack<T, defCapacity>::pop()
{
// assert(sizeOfStack > 0);
bool isSuccess = true;
if (sizeOfStack == )
{
cerr << "There is no element in stack." << endl;
isSuccess = false;
}
else
{
sizeOfStack--;
}
return isSuccess;
} template<class T, int defCapacity>
int Stack<T, defCapacity>::getSizeOfStack()
{
return sizeOfStack;
}
stack.hpp
Boost单元测试代码为：
#define BOOST_TEST_MODULE Stack_Test_Module #include "stdafx.h"
#include "../Stack/stack.hpp" const int MAXSIZE = ;
struct Stack_Fixture
{
public:
Stack_Fixture()
{
testStack = new Stack<int, MAXSIZE>();
} ~Stack_Fixture()
{
delete testStack;
} Stack<int, MAXSIZE> * testStack;
}; BOOST_FIXTURE_TEST_SUITE(Stack_Test_Fixture, Stack_Fixture) BOOST_AUTO_TEST_CASE( Stack_Test )
{
// isEmpty ------------------------------------
BOOST_REQUIRE(testStack->isEmpty() == true); // isEmpty ------------------------------------
BOOST_REQUIRE(testStack->getSizeOfStack() == ); // push & top ---------------------------------
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == false);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); // pop & top ----------------------------------
BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == false); } BOOST_AUTO_TEST_SUITE_END()
BoostUnitTest.cpp
2.2 基于动态数组
基于动态数组的栈的特点是栈的大小是可以运行时改变的，即可以通过重新分配栈来实现栈的扩容与压缩。还有，跟基于静态数组的栈不一样的是，基于动态数组的栈是在程序运行时才分配（堆上分配）。
栈模板类：
template<class T, int defCapacity>
class Stack
{
public:
Stack();
virtual ~Stack();
Stack(const Stack& orig); // 拷贝构造函数
Stack& operator=(const Stack& orig); // 赋值运算符重载
bool isEmpty();
bool push(T val); // 进栈。若栈不满，则将元素插入栈顶。
T top(); // 取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。
bool pop(); // 退栈。若栈非空，则将栈顶元素删去，并返回是否退栈成功的标志。
// 这里没有采用返回被删栈顶元素的原因在于这里写的是一个模板，
// 当栈为空的时候不方便返回。当然，这个问题是可以通过断言或
// 抛异常来解决的。具体做法可根据具体情况来定。
int getSizeOfStack(); private:
T * stack;
int capacity;
int sizeOfStack; };
具体实现代码为：
#include <iostream>
#include <cassert>
using namespace std; template<class T, int defCapacity>
class Stack
{
public:
Stack();
virtual ~Stack();
Stack(const Stack& orig); // 拷贝构造函数
Stack& operator=(const Stack& orig); // 赋值运算符重载
bool isEmpty();
bool push(T val); // 进栈。若栈不满，则将元素插入栈顶。
T top(); // 取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。
bool pop(); // 退栈。若栈非空，则将栈顶元素删去，并返回是否退栈成功的标志。
// 这里没有采用返回被删栈顶元素的原因在于这里写的是一个模板，
// 当栈为空的时候不方便返回。当然，这个问题是可以通过断言或
// 抛异常来解决的。具体做法可根据具体情况来定。
int getSizeOfStack(); private:
T * stack;
int capacity;
int sizeOfStack; }; template<class T, int defCapacity>
Stack<T, defCapacity>::Stack()
{
capacity = defCapacity;
//assert(capacity > 0);
stack = new T[capacity];
//assert(stack != NULL);
sizeOfStack = ;
} template<class T, int defCapacity>
Stack<T, defCapacity>::~Stack()
{
delete[] stack;
} template<class T, int defCapacity>
Stack<T, defCapacity>::Stack(const Stack& orig)
{
capacity = defCapacity; // 需要特别注意的是，调用拷贝构造函数时并不会“提前”调用构造函数
//assert(capacity > 0);
if (capacity < orig.capacity)
{
capacity = orig.capacity;
}
sizeOfStack = orig.sizeOfStack;
stack = new T[capacity];
//assert(stack != NULL);
for (int i = ; i < sizeOfStack; i++)
{
stack[i] = orig.stack[i];
}
} template<class T, int defCapacity>
Stack<T, defCapacity>& Stack<T, defCapacity>::operator=(const Stack& orig) // 这里需要非常注意返回值要写为
// Stack<T, defCapacity>而不是Stack
{
if (capacity < orig.capacity)
{
capacity = orig.capacity;
stack = new T[capacity];
//assert(stack != NULL);
} sizeOfStack = orig.sizeOfStack;
for (int i = ; i < sizeOfStack; i++)
{
stack[i] = orig.stack[i];
} return *this;
} template<class T, int defCapacity>
bool Stack<T, defCapacity>::isEmpty()
{
return sizeOfStack == ;
} template<class T, int defCapacity>
bool Stack<T, defCapacity>::push(T val)
{
// assert(sizeOfStack < defCapacity);
bool isSuccess = true;
if (sizeOfStack == capacity)
{
cerr << "There is no space for new elements." << endl;
isSuccess = false;
}
else
{
stack[sizeOfStack] = val;
sizeOfStack++;
}
return isSuccess;
} template<class T, int defCapacity>
T Stack<T, defCapacity>::top()
{
return stack[sizeOfStack - ];
} template<class T, int defCapacity>
bool Stack<T, defCapacity>::pop()
{
// assert(sizeOfStack > 0);
bool isSuccess = true;
if (sizeOfStack == )
{
cerr << "There is no element in stack." << endl;
isSuccess = false;
}
else
{
sizeOfStack--;
}
return isSuccess;
} template<class T, int defCapacity>
int Stack<T, defCapacity>::getSizeOfStack()
{
return sizeOfStack;
}
stack.hpp
Boost单元测试代码为：
#define BOOST_TEST_MODULE Stack_Test_Module #include "stdafx.h"
#include "../Stack/stack.hpp" const int MAXSIZE = ;
struct Stack_Fixture
{
public:
Stack_Fixture()
{
testStack = new Stack<int, MAXSIZE>();
}
~Stack_Fixture()
{
delete testStack;
}
Stack<int, MAXSIZE> * testStack;
}; BOOST_FIXTURE_TEST_SUITE(Stack_Test_Fixture, Stack_Fixture) BOOST_AUTO_TEST_CASE(Stack_Test)
{
// isEmpty ------------------------------------
BOOST_REQUIRE(testStack->isEmpty() == true); // isEmpty ------------------------------------
BOOST_REQUIRE(testStack->getSizeOfStack() == ); // push & top ---------------------------------
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == false);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); // pop & top ----------------------------------
BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == false);
} BOOST_AUTO_TEST_CASE(Stack_CopyConstructor_Test)
{
// initialize ---------------------------------
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true); Stack<int, MAXSIZE> * testStack2 = new Stack<int, MAXSIZE>(*testStack); BOOST_REQUIRE(testStack2->getSizeOfStack() == );
BOOST_REQUIRE(testStack2->top() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == false);
} BOOST_AUTO_TEST_CASE(Stack_EqualOperator_Test)
{
// initialize ---------------------------------
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true); Stack<int, MAXSIZE> * testStack2 = new Stack<int, MAXSIZE>();
*testStack2 = *testStack; BOOST_REQUIRE(testStack2->getSizeOfStack() == );
BOOST_REQUIRE(testStack2->top() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == false);
} BOOST_AUTO_TEST_SUITE_END()
BoostUnitTest.cpp
2.3 基于指针
基于指针的栈也是在程序运行时才动态分配内存的。不过，它跟前两者不一样的是，它的内存利用效率高，不会存在内存浪费的问题。当然，这也就需要额外更多的内存申请及释放操作。
栈模板类：
template<class T>
class Node
{
public:
T data;
Node * next;
}; template<class T>
class Stack
{
public:
typedef Node<T> * NodePointer; public:
Stack();
virtual ~Stack();
Stack(const Stack& orig); // 拷贝构造函数
Stack& operator=(const Stack& orig); // 赋值运算符重载
bool isEmpty();
bool push(T val); // 进栈。若栈不满，则将元素插入栈顶。
T top(); // 取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。
bool pop(); // 退栈。若栈非空，则将栈顶元素删去，并返回是否退栈成功的标志。
// 这里没有采用返回被删栈顶元素的原因在于这里写的是一个模板，
// 当栈为空的时候不方便返回。当然，这个问题是可以通过断言或
// 抛异常来解决的。具体做法可根据具体情况来定。
int getSizeOfStack(); private:
NodePointer stack; };
具体实现代码为：
#include <iostream>
#include <cassert>
using namespace std; template<class T>
class Node
{
public:
T data;
Node * next;
}; template<class T>
class Stack
{
public:
typedef Node<T> * NodePointer; public:
Stack();
virtual ~Stack();
Stack(const Stack& orig); // 拷贝构造函数
Stack& operator=(const Stack& orig); // 赋值运算符重载
bool isEmpty();
bool push(T val); // 进栈。若栈不满，则将元素插入栈顶。
T top(); // 取栈顶元素。若栈S非空，则返回栈顶元素，但不改变栈的状态。
bool pop(); // 退栈。若栈非空，则将栈顶元素删去，并返回是否退栈成功的标志。
// 这里没有采用返回被删栈顶元素的原因在于这里写的是一个模板，
// 当栈为空的时候不方便返回。当然，这个问题是可以通过断言或
// 抛异常来解决的。具体做法可根据具体情况来定。
int getSizeOfStack(); private:
NodePointer stack; }; template<class T>
Stack<T>::Stack()
{
stack = NULL;
} template<class T>
Stack<T>::~Stack()
{
NodePointer ptr = stack, tmpPtr;
while (ptr != NULL)
{
tmpPtr = ptr;
ptr = ptr->next;
delete tmpPtr;
}
} template<class T>
Stack<T>::Stack(const Stack& orig)
{
stack = NULL; // 需要特别注意的是，调用拷贝构造函数时并不会“提前”调用构造函数
NodePointer tmpPtr = orig.stack;
while (tmpPtr != NULL)
{
push(tmpPtr->data);
tmpPtr = tmpPtr->next;
}
} template<class T>
Stack<T>& Stack<T>::operator=(const Stack& orig) // 这里需要非常注意返回值要写为
// Stack<T>而不是Stack
{
//stack = NULL; 在这里可以不用，因为调用“赋值运算符”前会提前调用构造函数
NodePointer tmpPtr = orig.stack;
while (tmpPtr != NULL)
{
push(tmpPtr->data);
tmpPtr = tmpPtr->next;
} return *this;
} template<class T>
bool Stack<T>::isEmpty()
{
return stack == NULL;
} template<class T>
bool Stack<T>::push(T val)
{
bool isSuccess = true;
NodePointer ptr = new Node<T>(), tmpPtr;
//assert(ptr != NULL);
//isSuccess = false;
ptr->data = val;
if (stack == NULL) // when the stack is empty
{
stack = ptr;
ptr->next = NULL;
}
else // others
{
tmpPtr = stack;
int len = getSizeOfStack();
int count = ;
while (tmpPtr != NULL && count < len - )
{
tmpPtr = tmpPtr->next;
count++;
}
tmpPtr->next = ptr;
ptr->next = NULL;
} return isSuccess;
} template<class T>
T Stack<T>::top()
{
NodePointer tmpPtr = stack;
int len = getSizeOfStack();
int count = ;
while (tmpPtr != NULL && count < len - )
{
tmpPtr = tmpPtr->next;
count++;
} return tmpPtr->data;
} template<class T>
bool Stack<T>::pop()
{
bool isSuccess = true;
int len = getSizeOfStack();
if (len == )
{
cerr << "There is no element in stack." << endl;
isSuccess = false;
}
else
{
NodePointer tmpPtr = stack, tmpPtr2;
if (len == )
{
delete tmpPtr;
stack = NULL;
}
else
{
int count = ;
while (tmpPtr != NULL && count < len - )
{
tmpPtr = tmpPtr->next;
count++;
}
tmpPtr2 = tmpPtr->next;
tmpPtr->next = NULL;
delete tmpPtr2;
}
} return isSuccess;
} template<class T>
int Stack<T>::getSizeOfStack()
{
int len = ;
NodePointer ptr = stack;
while (ptr != NULL)
{
len++;
ptr = ptr->next;
}
return len;
}
stack.hpp
Boost单元测试代码为：
#define BOOST_TEST_MODULE Stack_Test_Module #include "stdafx.h"
#include "../Stack/stack.hpp" struct Stack_Fixture
{
public:
Stack_Fixture()
{
testStack = new Stack<int>();
}
~Stack_Fixture()
{
delete testStack;
}
Stack<int> * testStack;
}; BOOST_FIXTURE_TEST_SUITE(Stack_Test_Fixture, Stack_Fixture) BOOST_AUTO_TEST_CASE(Stack_Test)
{
// isEmpty ------------------------------------
BOOST_REQUIRE(testStack->isEmpty() == true); // isEmpty ------------------------------------
BOOST_REQUIRE(testStack->getSizeOfStack() == ); // push & top ---------------------------------
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); // pop & top ----------------------------------
BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->top() == );
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == true);
BOOST_REQUIRE(testStack->getSizeOfStack() == ); BOOST_REQUIRE(testStack->pop() == false);
} BOOST_AUTO_TEST_CASE(Stack_CopyConstructor_Test)
{
// initialize ---------------------------------
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true); Stack<int> * testStack2 = new Stack<int>(*testStack); BOOST_REQUIRE(testStack2->getSizeOfStack() == );
BOOST_REQUIRE(testStack2->top() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == false);
} BOOST_AUTO_TEST_CASE(Stack_EqualOperator_Test)
{
// initialize ---------------------------------
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true);
BOOST_REQUIRE(testStack->push() == true); Stack<int> * testStack2 = new Stack<int>();
*testStack2 = *testStack; BOOST_REQUIRE(testStack2->getSizeOfStack() == );
BOOST_REQUIRE(testStack2->top() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->top() == );
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == true);
BOOST_REQUIRE(testStack2->getSizeOfStack() == ); BOOST_REQUIRE(testStack2->pop() == false);
} BOOST_AUTO_TEST_SUITE_END()
BoostUnitTest.cpp
本篇博文的代码均托管到Taocode : http://code.taobao.org/p/datastructureandalgorithm/src/.
"《算法导论》之‘栈’"：栈的三种实现（静态数组、动态数组及指针）的更多相关文章
- python全栈开发day38-css三种引入方式、基础选择器、高级选择器、补充选择器
一.昨日内容回顾 div:分割整个网站,很多块 (1)排版标签 (2)块级标签 独占一行 可以设置高和宽,如果不设置宽高,默认是父盒子的宽 span: (1) 小区域 (2)文本标签 (3)在一行内显 ...
- Java的三种代理模式(Spring动态代理对象)
Java的三种代理模式 1.代理模式 代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩 ...
- 数组的三种方式总结 多维数组的遍历 Arrays类的常用方法总结
一.数组的三种声明方式总结 public class WhatEver { public static void main(String[] args) { //第一种 例: String[] tes ...
- java实现单链表、栈、队列三种数据结构
一.单链表 1.在我们数据结构中,单链表非常重要.它里面的数据元素是以结点为单位,每个结点是由数据元素的数据和下一个结点的地址组成,在java集合框架里面 LinkedList.HashMap(数组加 ...
- 基于visual Studio2013解决算法导论之019栈实现（基于数组）
题目 用数组实现栈 解决代码及点评 #include <stdio.h> #include <stdlib.h> #include <time.h> #in ...
- 基于visual Studio2013解决算法导论之018栈实现（基于链表）
题目 用链表实现栈 解决代码及点评 #include <stdio.h> #include <stdlib.h> #include <time.h> #in ...
- Stack栈的三种含义
理解stack栈对于理解程序的执行至关重要.easy混淆的是,这个词事实上有三种含义,适用于不同的场合,必须加以区分. 含义一:数据结构 stack的第一种含义是一组数据的存放方式,特点为LIFO,即 ...
- 基于C#程序设计语言的三种组合算法
目录 基于C#程序设计语言的三种组合算法 1. 总体思路 1.1 前言 1.2 算法思路 1.3 算法需要注意的点 2. 三种组合算法 2.1 普通组合算法 2.2 与自身进行组合的组合算法 2.3 ...
- OpenCV3三种超像素分割算法源码以及效果
OpenCV3中超像素分割算法SEEDS,SLIC, LSC算法在Contrib包里,需要使用Cmake编译使用.为了方便起见,我将三种算法的源码文件从contrib包里拎了出来,可以直接使用,顺便比 ...
随机推荐
- Xcode7.3.1中通过最新的CocoaPod安装pop动画引擎
CocoaPod是一个用ruby实现,用于方便的管理Xcode中第三方插件的管理器.用它我们可以很方便的安装和升级插件而不用担心破坏原有的项目. 而pop是一个用于实现App中动画的引擎,它是由Fac ...
- Java之String类型详解
字符串的特点 A:字符串一旦被赋值,就不能改变. 注意:这里指的是字符串的内容不能改变,而不是引用不能改变. B:字面值作为字符串对象和通过构造方法创建对象的不同 String s = new Str ...
- 为什么不要在viewDidLoad方法中设置开始监听键盘通知
大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请多提意见,如果觉得不错请多多支持点赞.谢谢! hopy ;) 一个普遍的错误是,程序猿(媛)试图在view controll ...
- ROS_Kinetic_x 基於ROS和Gazebo的RoboCup中型組仿真系統（多機器人協作）
國防科學技術大學發布了RoboCup中型組仿真平臺,基於ROS和Gazebo設計. 該平臺可以用於多機器人協作研究.參考資料如下: ROS新聞:1 http://www.ros.org/news ...
- 编译GDAL支持ArcObjects
编译GDAL支持ArcObjects. 首先修改nmake.opt文件中对应的ArcObjects,修改后的如下所示: #uncomment to use ArcObjects ARCOBJECTS_ ...
- C++对象模型的那些事儿之二：对象模型（下）
前言 上一篇博客C++对象模型的那些事儿之一为大家讲解了C++对象模型的一些基本知识,可是C++的继承,多态这些特性如何体现在对象模型上呢?单继承.多重继承和虚继承后内存布局上又有哪些变化呢?多态真正 ...
- C++对C语言register的增强
register关键字 请求编译器让变量a直接放在寄存器里面,速度快 在c语言中 register修饰的变量 不能取地址,但是在c++里面做了内容 1 register关键字的变化 register关 ...
- Hessian源码分析--HessianProxyFactory
HessianProxyFactory是HessianProxy的工厂类,其通过HessianProxy来生成代理类. 如下面代码: HessianProxyFactory factory = new ...
- ubuntu14.04使用root用户登录桌面
ubuntu安装好之后,默认是不能用root用户登录桌面的,只能使用普通用户或者访客登录.怎样开启root用户登录桌面呢? 先用普通用户登录,然后切换到root用户,然后执行如下命令: vi /usr ...
- 深入Java关键字instanceof
深入Java关键字instanceof instanceof关键字用于判断一个引用类型变量所指向的对象是否是一个类(或接口.抽象类.父类)的实例. 举个例子: public interface ...