算法练习
把二元查找树转变成排序的双向链表，这个代码是别人写的，在此作为记录。
package org.hnust.cn.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
1.把二元查找树转变成排序的双向链表
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ \
6 14
/ \ / \
4 8 12 16
转换成双向链表
4=6=8=10=12=14=16。
首先我们定义的二元查找树 节点的数据结构如下：
struct BSTreeNode
{
int m_nValue; // value of node
BSTreeNode *m_pLeft; // left child of node
BSTreeNode *m_pRight; // right child of node
};
*/
/**
* 二元查找树
*/
class BSTree implements Cloneable,Serializable {
/**
* v0.8
*/
private static final long serialVersionUID = -7240326774488306261L;
private BSNode m_root; // 根节点
private BSNode tempListNode; // 创建doubleList的时候使用的临时变量
private BSNode tempListHead; // 创建doubleList的时候使用的临时变量
public void setM_root(BSNode mRoot) {
m_root = mRoot;
}
public BSNode getM_root() {
return m_root;
}
/**
* 深拷贝
*/
public Object clone() {
try {
// 没有去想树的节点拷贝算法，先用这种简便方法，再复杂的类型拷贝也不怕，不过所有相关类都必须是Serializable
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
Object ob = ois.readObject();
ois.close();
return (BSTree) ob;
} catch (Exception e) {
System.out.println("CloneNotSupportedException: " + e);
e.printStackTrace();
}
return null;
}
/**
* 增加子节点
* @param 二元查找树节点
*/
public synchronized void addNode(BSNode node) {
if (null == this.m_root) {
this.m_root = node;
return;
}
BSNode tempNode = this.m_root;
while (true) {
if (node.getM_nValue() > tempNode.getM_nValue()) { // 大于父节点
if (null == tempNode.getM_pRight()) {
tempNode.setM_pRight(node);
return;
} else {
tempNode = tempNode.getM_pRight();
continue;
}
} else if (node.getM_nValue() < tempNode.getM_nValue()) { // 小于父节点
if (null == tempNode.getM_pLeft()) {
tempNode.setM_pLeft(node);
return;
} else {
tempNode = tempNode.getM_pLeft();
continue;
}
} else { // 等于父节点
return;
}
}
}
/**
* 生成双向链表
* @return 双向链表
* @throws CloneNotSupportedException
*/
public synchronized BSDoubleList changeToDoubleList() {
BSTree tempTree = (BSTree) this.clone(); // 临时树，替死鬼，被转换得面目全非，垃圾回收了吧...
// 其实改为changeTreeToDoubleList(this.getM_root());才符合题意，不过个人喜欢使用深拷贝，不破坏原来的树
if (null != tempTree) {
changeTreeToDoubleList(tempTree.getM_root());
}
BSDoubleList dlist = new BSDoubleList();
dlist.setHead(tempListHead);
return dlist;
}
private void changeTreeToDoubleList(BSNode node) {
if (null == node) {
return;
}
if (null != node.getM_pLeft()) {
changeTreeToDoubleList(node.getM_pLeft());
}
// -------------转换---------------
node.setM_pLeft(tempListNode);
if (null == tempListNode){
tempListHead = node;
} else {
tempListNode.setM_pRight(node);
}
//---------------------------------
tempListNode = node;
if (null != node.getM_pRight()) {
changeTreeToDoubleList(node.getM_pRight());
}
}
/**
* 打印中序遍历
*/
public synchronized void print() {
if (null == this.m_root) {
System.out.print("HashCode: " + this.hashCode() + "; 空树;");
return;
}
System.out.print("HashCode: " + this.hashCode() + "; 树: ");
print(this.m_root);
System.out.println();
}
private void print(BSNode node) {
if (null != node) {
print(node.getM_pLeft());
System.out.print(node.getM_nValue() + " ");
print(node.getM_pRight());
}
}
}
/**
* 二元查找树(双向链表)节点
*/
class BSNode implements Serializable {
/**
* v1.0
*/
private static final long serialVersionUID = 6136767364555910395L;
private int m_nValue; // 值
private BSNode m_pLeft; // 左(前驱)节点
private BSNode m_pRight; // 右(后继)节点
public BSNode(int value) {
this.m_nValue = value;
}
public int getM_nValue() {
return m_nValue;
}
public void setM_nValue(int mNValue) {
m_nValue = mNValue;
}
public BSNode getM_pLeft() {
return m_pLeft;
}
public void setM_pLeft(BSNode mPLeft) {
m_pLeft = mPLeft;
}
public BSNode getM_pRight() {
return m_pRight;
}
public void setM_pRight(BSNode mPRight) {
m_pRight = mPRight;
}
}
/**
* 双向链表
*/
class BSDoubleList {
private BSNode head; // 最左边的头结点
public BSNode getHead() {
return head;
}
public void setHead(BSNode head) {
this.head = head;
}
public synchronized void print() {
if (null != this.head) {
System.out.print("HashCode: " + this.hashCode() + "; 双向链表(正向): ");
while (true) {
if (null != this.head.getM_pRight()) {
System.out.print(this.head.getM_pRight().getM_nValue() + " ");
this.head = this.head.getM_pRight();
} else {
break;
}
}
System.out.println();
System.out.print("HashCode: " + this.hashCode() + "; 双向链表(逆向): ");
while (true) {
if (null != this.head) {
System.out.print(this.head.getM_nValue() + " ");
this.head = this.head.getM_pLeft();
} else {
break;
}
}
} else {
System.out.println("HashCode: " + this.hashCode() + "; 空链表;");
}
System.out.println();
}
}
public class BTreeToList {
public static void main(String[] args) {
BSTree tree = new BSTree();
tree.addNode(new BSNode(10));
tree.addNode(new BSNode(6));
tree.addNode(new BSNode(14));
tree.addNode(new BSNode(4));
tree.addNode(new BSNode(8));
tree.addNode(new BSNode(12));
tree.addNode(new BSNode(16));
tree.print();
BSDoubleList dlist = tree.changeToDoubleList();
dlist.print();
System.out.println("原来的树:");
tree.print();
}
}
设计包含min函数的栈；
LinkStack;;;
package org.hnust.cn.test;
import org.hnust.cn.util.LinkStack;
/***
* 找出栈中最小元素
* @author zzg
*/
public class MinValStack {
private LinkStack propertyStack=new LinkStack();//原生栈，存储本来数据
private LinkStack minStack=new LinkStack(); // 辅助栈，栈顶元素为最小值
public void insert(int val){
if(propertyStack.isEmpty()||minStack.isEmpty()){
propertyStack.push(val);
minStack.push(val);
}else{
if(minStack.peek()>=val){
minStack.push(val);
}
propertyStack.push(val);
}
}
/***
* 获取栈中最小元素
* @return
*/
public int min(){
if(minStack.isEmpty()){
return -1;
}else{
return minStack.peek();
}
}
public static void main(String[] args) {
MinValStack stack=new MinValStack();
stack.insert(4);
stack.insert(5);
stack.insert(3);
stack.insert(8);
stack.insert(10);
stack.insert(9);
System.out.println("最小元素："+stack.min());
}
}