后续算法
A. 请分别对顺序表和单链表写出求线性表中下标为i的（第i+1个）元素的前驱和后续的算法
顺序表：前驱a[i-1],后继a[i+1]
线性表：p=head;
int j=0;
while（j!=i）
{
j++;
p=p->next ;
}
前驱p->data，后继p->next->next->data
B. 二叉数的前序、中序、后续三种方式的递归与非递归的算法。
小哥分这么少
=============tree.cpp=============
#include<iostream>
#include<queue>
#include<stack>
#include<fstream>
using namespace std;
#include"tree.h"
//构造二叉树
template<class T>
bool bitree<T>::insert(const T& e)
{
btnode<T>* anew=new btnode<T>(e);
_insert(anew, this->root);
count++;
return true;
}
template<class T>
void bitree<T>::_insert(btnode<T> *anew, btnode<T>* &node)
{
if(NULL== node)
{
node=anew;
return;
}
if(anew->data < node->data)
_insert(anew, node->left);
if(anew->data > node->data)
_insert(anew, node->right);
}
//前序遍历递归和非递归版本
template<class T>
void bitree<T>::preorder( void(*visit)(btnode<T>*u) )
{
_preorder(visit, this->root);
}
template<class T>
void bitree<T>::_preorder(void(*visit)(btnode<T>*u), btnode<T> *node)
{
if( NULL == node) return;
visit(node);
_preorder(visit, node->left);
_preorder(visit, node->right);
}
//前序遍历的非递归版本，用stack实现
template<class T>
void bitree<T>::preorder_nr(void (*visit)(btnode<T>*u))
{
if(NULL==this->root) return;
btnode<T> *tempnode;
stack<btnode<T>*> astack;
astack.push(this->root);
while(!astack.empty())
{
tempnode=astack.top();
visit(tempnode);
astack.pop();
if(tempnode->right !=NULL) astack.push(tempnode->right);
if(tempnode->left !=NULL) astack.push(tempnode->left);
}
}
//后序遍历
template<class T>
void bitree<T>::postorder( void(*visit)(btnode<T>*u) )
{
_postorder(visit, this->root);
}
template<class T>
void bitree<T>::_postorder(void(*visit)(btnode<T>*u), btnode<T> *node)
{
if( NULL == node) return;
_postorder(visit, node->left);
_postorder(visit, node->right);
visit(node);
}
//中序遍历
template<class T>
void bitree<T>::inorder( void(*visit)(btnode<T>*u) )
{
_inorder(visit, this->root);
}
template<class T>
void bitree<T>::_inorder(void(*visit)(btnode<T>*u), btnode<T> *node)
{
if( NULL == node) return;
_inorder(visit, node->left);
visit(node);
_inorder(visit, node->right);
}
//层次遍历
template<class T>
void bitree<T>::levelorder(void (*visit)(btnode<T>*u))
{
queue<btnode<T> * > aqueue;
_levelorder(visit, this->root, aqueue);
}
template<class T>
void bitree<T>::_levelorder(void (*visit)(btnode<T>*u), btnode<T> *node, queue<btnode<T> *>& aqueue)
{
if(NULL == node) return;
btnode<T>* tempnode;
aqueue.push(node);
while(! aqueue.empty() )
{
tempnode=aqueue.front();
visit(tempnode);
if(tempnode->left != NULL )aqueue.push(tempnode->left);
if(tempnode->right !=NULL) aqueue.push(tempnode->right);
aqueue.pop();
}
}
//树的高度
template<class T>
int bitree<T>::height()const
{
return _height(root);
}
template<class T>
int bitree<T>::_height(btnode<T>*root)
{
if( NULL == root) return 0;
int hl=_height(root->left);
int hr=_height(root->right);
if(hl > hr) return ++hl;
else return ++hr;
}
//树的节点数
template<class T>
int bitree<T>::size()
{
return count;
}
void visit(btnode<int> *root)
{
cout<<root->data<<" ";
}
int main()
{
//
cout<<endl<<endl;
bitree<int> atree;
cout<<" 请在aaa.txt中 输入你要排序的数组 ，没有aaa.txt则创建之"<<endl;
fstream fin("aaa.txt");
if(!fin)
{
cout<<"cannot open aaa.txt"<<endl;
return 1;
}
int input;
while(fin>>input)
{
cout<<" insert "<<input<<endl;
atree.insert(input);
}
cout<<endl<<endl;
cout<<"前序遍历：";
atree.preorder(visit);
cout<<endl<<endl;
cout<<"前序遍历（非递归） ";
atree.preorder_nr(visit);
cout<<endl<<endl;
cout<<"后序遍历：";
atree.postorder(visit);
cout<<endl<<endl;
cout<<"中序遍历：";
atree.inorder(visit);
cout<<endl<<endl;
cout<<"层次遍历：";
atree.levelorder(visit);
cout<<endl<<endl;
return 1;
}
==============tree.h==========
//二叉树的实现
#include<iostream>
using namespace std;
//二叉树的节点
template<class T>
class btnode
{
public:
btnode()
{
left=right=0;
}
btnode(const T & data)
{
left=right=0;
this->data=data;
}
btnode(const T &data, btnode<T> *l, btnode<T> *r)
{
this->data=data;
left=l;
right=r;
}
btnode<T> *left,*right;
T data;
};
//二叉树
template<class T>
class bitree
{
public:
//构造函数
bitree(){root=0;count=0;}
//构造二叉树
bool insert(const T& e);
//判空运算
bool isempty()
{
return 0==root?true:false;
}
//前序遍历递归和非递归版本
void preorder( void(*visit)(btnode<T>*u) );
void preorder_nr( void(*visit)(btnode<T>*u));
//后序遍历
void postorder(void(*visit)(btnode<T> *u));
//中序遍历
void inorder(void(*visit)(btnode<T>*u));
//层次遍历
void levelorder(void (*visit)(btnode<T>*u));
//树的高度
int height()const;
//树的节点数
int size();
//删除运算
private:
int count;
btnode<T> *root;//root
void _insert(btnode<T> *anew, btnode<T>* &node);
void _preorder(void(*visit)(btnode<T>*u), btnode<T> *root);
void _postorder(void(*visit)(btnode<T>*u), btnode<T> *root);
void _inorder(void(*visit)(btnode<T>*u), btnode<T> *root);
void _levelorder(void (*visit)(btnode<T>*u), btnode<T> *node,queue<btnode<T>* >&);
int _height(btnode<T>*root);
btnode<T>* _deepsearch(const T&data, btnode<T>*& node);
btnode<T>* _breadsearch(const T&data, btnode<T>*& node);
};
C. 学习java的后续问题...
学习Java最主要的就是多上机练，最好做到每天能练2-3个小时。这里面的语法很简单，主要的是要会灵活运用，要掌握一些常用的算法，至于用什么软件，我推荐你使用MyEclipse.
MyEclipse企业级工作平台（MyEclipse Enterprise Workbench ，简称MyEclipse）是对Eclipse IDE的扩展，利用它我们可以在数据库和J2EE的开发、发布，以及应用程序服务器的整合方面极大的提高工作效率。它是功能丰富的J2EE集成开发环境，包括了完备的编码、调试、测试和发布功能，完整支持HTML, Struts, JSF, CSS, Javascript, SQL, Hibernate。
在结构上，MyEclipse的特征可以被分为7类：
1. J2EE模型
2. WEB开发工具
3. EJB开发工具
4. 应用程序服务器的连接器
5. J2EE项目部署服务
6. 数据库服务
7. MyEclipse整合帮助
对于以上每一种功能上的类别，在Eclipse中都有相应的功能部件，并通过一系列的插件来实现它们。MyEclipse结构上的这种模块化，可以让我们在不影响其他模块的情况下，对任一模块进行单独的扩展和升级。
简单而言，MyEclipse是Eclipse的插件，也是一款功能强大的J2EE集成开发环境，支持代码编写、配置、测试以及除错。
windows集成版本下载地址：
http://downloads.myeclipseide.com/downloads/procts/eworkbench/7.0/myeclipse-7.0-win32.exe
D. 后续治疗费的计算方法
单纯的后续治疗医学建议并不能解决具体赔偿数额问题。后续治疗费的计算是个非常复杂的医学和法律问题，涉及多种因素。在司法实践中，法院认定后续治疗费用的方法各不相同，主要分为以下几种：
1. 按既往已发生费用的平均数计算。这是一种最为简单的计算方法。但是因为疾病发展阶段不同、住院治疗与否等因素影响，这种计算方法也存在非科学性，对于被告医院可能存在不公平，而且在某些特定案例中对原告也可能不公平。
2. 委托司法鉴定机构进行治疗费用评估。
3. 根据医疗机构的诊断证明或医生建议进行计算。
4. 其他计算方法。
基本医疗费用对于基本医疗费用，在实践中，可以参照疾病的常规治疗和护理标准进行计算。例如，肿瘤病人化疗药物的选择应按国内普通化疗药物的价格进行计算，而不应按照进口同类药品计算。
E. lpr利率后续算法
刚买了房子，LPR是国家强制执行的利率，一般银行都会在这个基础上加几个点，以保证自已贷款的收益，至于加几个点，每个地方的每个银行都不一样，一般地方银行加的点会比大银行少。你实付的利率就是lpr加点后的利率
F. 固定资产后续支出计算方法
固定资产后续支出分为可资本化的后续支出和费用化的后续支出。新《企业会计准则》规定，固定资产发生的可资本化后续支出时，可能涉及到替换原固定资产的某组成部分，当发生的后续支出符合固定资产确认条件的，应将其计入固定资产成本，同时将被替换部分的账面价值扣除，也就是说：如果固定资产的后续支出能增强固定资产获取...未来经济利益的能力，能提高固定资产使用效能，能延长固定资产使用寿命，能使产品质量有实质性提高或者能使产品成本有实质性的降低，能使可能流入企业的经济利益超过原先的估计，在不导致计入后固定资产账面价值超过其可回收的金额前提下，应将其后续支出予以资本化。其会计核算是：当固定资产发生可资本化的后续支出时，应将该固定资产的原价、以计提的累计折旧和减值准备转销，将其固定资产账面价值（净值）转入“在建工程”。发生的固定资产可资本化的后续支出通过“在建工程”科目核算，追加该项工程成本，在固定资产的后续支出完工并达到预定可使用状态时，应将后续支出资本化后的固定资产账面价值在不超过其可收回金额的范围内从“在建工程”科目转入固定资产；费用化的后续支出一般指企业固定资产投入使用后，由于磨损，可能导致各组成部分局部损坏等，为使固定资产正常运转和使用，发挥其使用效能进行必要的维护，它并不能使固定资产性能改变和产生经济利益，对不符合固定资产确认条件的，在发生时直接计入“当期损益”。你是说固定资产没有给出使用年限的话，你可以 问一下你的领导，共同商讨一下它的使用年限。
G. 求普通树的非递归后续遍历算法
可以给node加上额外的状态信息吗？
如果可以的话，给node设定状态status,0为第一次进栈，1为已展开。
节点第一次进栈的时候，status设为0。在节点出栈的时候，如果status为0，则将status改为1，先将此节点进栈，再将其子节点进栈；如果status为1，说明其子节点已全部访问，即可访问该节点。
//////////////////////////////////////
那么，可以添加一个保存子节点数目的栈n，在孩子进栈之前将父节点再次进栈，同时将子节点数目进栈n，每次访问一个节点后将栈n顶的数字减1。当栈n顶的数字为0时，即可访问该节点，同时将n顶元素出栈。
//////////////////////////////////////
这和前序遍历不一样啊，你把子节点序列入栈的时候，就已经丢失了一部分树的结构信息，这时候如果不添加额外的信息，似乎不能把子节点序列和之前的节点区分开。从入栈时机和访问数据的时机方面我认为是不能做到后续遍历的。
我记得在学校的时候，老师教的非递归后续遍历的标准算法就是我前面说的第一种。而且，只增加一个最大长度只有树深度的int 型栈开销也不是很大阿。
////////////////////////////////////////
node = root;
stack.push(root);
while(!stack.isEmpty()){
node = stack.pop();
if (node 是叶结点){
//访问代码,stack_num栈顶元素减一
while(stack.top()==0){
stack.pop(node1)
//访问node1
stack_num.pop();
//stack_num栈顶减一
}
continue;
}
childs = node.getChilds();
stack.push(node);
for(int i=childs.length-1;i>=0;i--){
stack.push(childs[i]);
}
stack_num.push(childs.length);
}
H. C计算后续日期的算法设计思路，文字叙述即可，
使用儒略日
I. 求p所指结点的中序后继算法
q=p->right;
while(q->left) q=q->left;
return q
J. 给出后序线索二叉树中求后序后继节点的算法代码!!!要代码!不要分析!