"《算法导论》之‘栈’"：栈的三种实现（静态数组、动态数组及指针）
本文有关栈的介绍部分参考自网站数据结构。
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包里拎了出来,可以直接使用,顺便比 ...
随机推荐
- Leetcode解题-链表(2.2.2)ReverseLinkedList
题目:2.2.2 Reverse Linked List II Reverse a linked list from position m to n. Do it in-place and in on ...
- [Flask]学习杂记一 Hello程序
这几天买了本 <Flask Web开发:基于Python的Web应用开发实战>,之前也用过flask 但是不怎么系统,有时候需要搭建一些临时的测试服务,用falsk比较方面,一个文件就可 ...
- [Vim]vim学习笔记--多个文件打开，切换，关闭
一种情况是在shell中用vim打开多个文件,另一种是在vim编辑器中打开多个文件 同时打开多个文件 vim file1 file2 打开文件并水平窗口显示 vim -o file1 file2 打 ...
- java项目管理工具maven使用初级
一.前言 早就知道maven 在java 项目的管理方面名声显赫,于是就想着学习掌握之,于是查阅了大量文档.发现这些文档的作者都是java 的大腕,大多都是站在掌握了一定maven 基础 ...
- make、make clean、make install、make uninstall、make dist、make distcheck和make distclean
Makefile在符合GNU Makefiel惯例的Makefile中,包含了一些基本的预先定义的操作:make根据Makefile编译源代码,连接,生成目标文件,可执行文件.make clean清除 ...
- UITableView如何撤销移动操作
大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请多提意见,如果觉得不错请多多支持点赞.谢谢! hopy ;) 我们知道使用UITableView的委托方法canMoveRo ...
- Cocos2D中Action的进阶使用技巧(一)
大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请多提意见,如果觉得不错请多多支持点赞.谢谢! hopy ;) 大家对Cocos2d中动作的使用大概都很清楚了,其实本身act ...
- 【翻译】Ext JS 6.2 早期访问版本发布
原文:Announcing Ext JS 6.2 Early Access 非常开心,Sencha Ext JS 6.2早期访问版本今天发布了.早期访问版本的主要目的是为了让大家进行测试并评估Ext ...
- [ExtJS5学习笔记]第二节 Sencha Cmd 学习笔记 使你的sencha cmd跑起来
本文地址: http://blog.csdn.net/sushengmiyan/article/details/38313537 本文作者:sushengmiyan ----------------- ...
- pig里面没有if：不能判断一个条件后决定一个执行步骤
pig是处理流 的工具,所以数据集是流对象,处理步骤也是一样的. Pig中存在按条件处理流对象的方式有 1)filter X= FILTER A BY (f1 == 8); 2)CASE WHEN T ...