test - Delphi K.Top 討論區

發表時間：2007-04-29 20:24:31

IP:219.81.xxx.xxx 訂閱

like :

http://docs.google.com/a/actionxp.com/Doc?id=dd8jsrzr_1fxkg7b

But k.top have bug in color by paste data.

// tree.java
// demonstrates binary tree
// to run this program: C>java TreeApp
import java.io.*;
import java.util.*; // for Stack class
////////////////////////////////////////////////////////////////
class Node
{
iData; // data item (key)
public dData; // data item
public Node leftChild; // this node's left child
public Node rightChild; // this node's right child

public displayNode() // display ourself
{
System.out.print('{');
System.out.print(iData);
System.out.print(", ");
System.out.print(dData);
System.out.print("} ");
}
// end class Node
////////////////////////////////////////////////////////////////
} class Tree
{
Node root; // first node of tree

// -------------------------------------------------------------
public Tree() // constructor
{ root = null; } // no nodes in tree yet
// -------------------------------------------------------------
public Node find(key) // find node with given key
{ // (assumes non-empty tree)
Node current = root; // start at root
whilecurrent.iData != key) // while no match,
{
key < current.iData) // go left?
current = current.leftChild;
else // or go right?
current = current.rightChild;
ifcurrent == null// if no child,
) return ; null// didn't find it
}
current; // found it
} // end find()
// -------------------------------------------------------------
public insert(id, double dd)
Node newNode = new Node(); // make new node
newNode.iData = id; // insert data
newNode.dData = dd;
ifroot==null// no node in root
) root = newNode;
else // root occupied
{
Node current = root; // start at root
Node parent;
while// (exits internally)
(true) {
parent = current;
ifid < current.iData) // go left?
{
current = current.leftChild;
ifcurrent == null// if end of the line,
) { // insert on left
parent.leftChild = newNode;
return;
}
// end if go left
} else // or go right?
{
current = current.rightChild;
ifcurrent == null// if end of the line
) { // insert on right
parent.rightChild = newNode;
return;
}
// end else go right
} } // end while
} // end else not root
} // end insert()
// -------------------------------------------------------------
public delete(key) // delete node with given key
{ // (assumes non-empty list)
Node current = root;
Node parent = root;
boolean isLeftChild = true;

whilecurrent.iData != key) // search for node
{
parent = current;
ifkey < current.iData) // go left?
{
isLeftChild = true;
current = current.leftChild;
}
// or go right?
else {
isLeftChild = false;
current = current.rightChild;
}
current == null// end of the line,
) return ; false// didn't find it
} // end while
// found node to delete

// if no children, simply delete it
ifcurrent.leftChild==null &&
current.rightChild==nullcurrent == root) // if root,
root = null; // tree is empty
else ifisLeftChild)
parent.leftChild = null; // disconnect
else // from parent
parent.rightChild = null;
}

// if no right child, replace with left subtree
else ifcurrent.rightChild==nullcurrent == root)
root = current.leftChild;
else ifisLeftChild)
parent.leftChild = current.leftChild;
else
parent.rightChild = current.leftChild;

// if no left child, replace with right subtree
else ifcurrent.leftChild==nullcurrent == root)
root = current.rightChild;
else ifisLeftChild)
parent.leftChild = current.rightChild;
else
parent.rightChild = current.rightChild;

else // two children, so replace with inorder successor
{
// get successor of node to delete (current)
Node successor = getSuccessor(current);

// connect parent of current to successor instead
ifcurrent == root)
root = successor;
else ifisLeftChild)
parent.leftChild = successor;
else
parent.rightChild = successor;

// connect successor to current's left child
successor.leftChild = current.leftChild;
} // end else two children
// (successor cannot have a left child)
return ; true// success
} // end delete()
// -------------------------------------------------------------
// returns node with next-highest value after delNode
// goes to right child, then right child's left descendents
private Node getSuccessor(Node delNode)
Node successorParent = delNode;
Node successor = delNode;
Node current = delNode.rightChild; // go to right child
whilecurrent != null// until no more
) { // left children,
successorParent = successor;
successor = current;
current = current.leftChild; // go to left child
}
// if successor not
ifsuccessor != delNode.rightChild) // right child,
{ // make connections
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
successor;
}
// -------------------------------------------------------------
public traverse(traverseType)
traverseType)
{
case 1: System.out.print("\nPreorder traversal: ");
preOrder(root);
break;
case 2: System.out.print("\nInorder traversal: ");
inOrder(root);
break;
case 3: System.out.print("\nPostorder traversal: ");
postOrder(root);
break;
}
System.out.println();
}
// -------------------------------------------------------------
private preOrder(Node localRoot)
localRoot != nullSystem.out.print(localRoot.iData " ");
preOrder(localRoot.leftChild);
preOrder(localRoot.rightChild);
}
// -------------------------------------------------------------
}
private inOrder(Node localRoot)
localRoot != nullinOrder(localRoot.leftChild);
System.out.print(localRoot.iData " ");
inOrder(localRoot.rightChild);
}
// -------------------------------------------------------------
}
private postOrder(Node localRoot)
localRoot != nullpostOrder(localRoot.leftChild);
postOrder(localRoot.rightChild);
System.out.print(localRoot.iData " ");
}
// -------------------------------------------------------------
}
public displayTree()
{
Stack globalStack = new Stack();
globalStack.push(root);
int nBlanks = 32;
boolean isRowEmpty = false;
System.out.println(
"......................................................");
whileisRowEmpty==falseStack localStack = new Stack();
isRowEmpty = true;

forj=0; j<nBlanks; j )
System.out.print(' ');

whileglobalStack.isEmpty()==falseNode temp = (Node)globalStack.pop();
iftemp != nullSystem.out.print(temp.iData);
localStack.push(temp.leftChild);
localStack.push(temp.rightChild);

iftemp.leftChild != null ||
temp.rightChild != nullisRowEmpty = false;
}
System.out.print("--");
localStack.push(;
null)localStack.push(;
null)}
j=0; j<nBlanks*2-2; j )
System.out.print(' ');
} // end while globalStack not empty
System.out.println();
nBlanks /= 2;
whilelocalStack.isEmpty()==falseglobalStack.push( localStack.pop() );
} // end while isRowEmpty is false
System.out.println(
"......................................................");
} // end displayTree()
// -------------------------------------------------------------
} // end class Tree
////////////////////////////////////////////////////////////////
class TreeApp
{
static public void main(args) IOException
{
value;
Tree theTree = new Tree();

theTree.insert(50, 1.5);
theTree.insert(25, 1.2);
theTree.insert(75, 1.7);
theTree.insert(12, 1.5);
theTree.insert(37, 1.2);
theTree.insert(43, 1.7);
theTree.insert(30, 1.5);
theTree.insert(33, 1.2);
theTree.insert(87, 1.7);
theTree.insert(93, 1.5);
theTree.insert(97, 1.5);

whileSystem.out.print("Enter first letter of show, ");
System.out.print("insert, find, delete, or traverse: ");
int choice = getChar();
switchchoice)
{
case 's':
theTree.displayTree();
break;
case 'i':
System.out.print("Enter value to insert: ");
value = getInt();
theTree.insert(value, value 0.9);
break;
case 'f':
System.out.print("Enter value to find: ");
value = getInt();
Node found = theTree.find(value);
iffound != nullSystem.out.print("Found: ");
found.displayNode();
System.out.print("\n");
}
System.out.print("Could not find ");
System.out.print(value '\n');
break;
case 'd':
System.out.print("Enter value to delete: ");
value = getInt();
boolean didDelete = theTree.delete(value);
ifdidDelete)
System.out.print("Deleted " value '\n');
else
System.out.print("Could not delete ");
System.out.print(value '\n');
break;
case 't':
System.out.print("Enter type 1, 2 or 3: ");
value = getInt();
theTree.traverse(value);
break;
default:
System.out.print("Invalid entry\n");
} // end switch
} // end while
} // end main()
// -------------------------------------------------------------
public static String getString() throws IOException
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
// -------------------------------------------------------------
public static char getChar() throws IOException
{
s = getString();
return s.charAt(0);
}
//-------------------------------------------------------------
public static int getInt() throws IOException
{
s = getString();
return Integer.parseInt(s);
}
// -------------------------------------------------------------
} // end class TreeApp
////////////////////////////////////////////////////////////////
String String (else
)
{
(((true)
{
int throws String[] )
(for(int else
{
)
()
{
()
{
((int )
{
(void )
{
{
if(void )
{
{
if(void )
{
{
if(void {
switch(int void return (({
((()
if((()
if((()
{
if((if(((int boolean (((({
int void return (if((int private void double public int
RainbowEditor v3.2

編輯記錄

system72 重新編輯於 2007-04-29 20:32:49，註解無‧
system72 重新編輯於 2007-04-29 20:36:17，註解無‧