bpGraph_t* bipartGraphCreate(int part1VertNum, int part2VertNum)
{
/* TODO: Implement me! */
bpGraph_t *pGraph = (bpGraph_t*) safeMalloc(sizeof(bpGraph_t));
pGraph->vertNum1 = part1VertNum;
pGraph->vertNum2 = part2VertNum;
pGraph->vpVertsP1 = NULL;
pGraph->vpVertsP2 = NULL;
int i;
int j;
for (i = 0; i < part1VertNum; i++) {
if(pGraph->vpVertsP1 == NULL) {
pGraph->vpVertsP1 = createTreeNode(i, createList());
} else {
binTreeNode_t *pNewNode = createTreeNode(i, createList());
insertTreeNode(pGraph->vpVertsP1, pNewNode);
}
}
for (j = 0; j < part2VertNum; j++) {
if(pGraph->vpVertsP2 == NULL) {
pGraph->vpVertsP2 = createTreeNode(j, createList());
} else {
binTreeNode_t *pNewNode = createTreeNode(j, createList());
insertTreeNode(pGraph->vpVertsP2, pNewNode);
}
}
return pGraph;
} /* end of bipartGraphDestroy() */
int bipartGraphInsertVertex(bpGraph_t* pGraph, int vertId, int partite)
{
/* TODO: Implement me! */
binTreeNode_t *currentNode = NULL, *left = NULL, *right = NULL;
if (partite == 1) {
if(pGraph->vpVertsP1 == NULL) {
pGraph->vpVertsP1 = createTreeNode(vertId, createList());
pGraph->vertNum1 += 1;
return NEW_VERTEX;
} else {
binTreeNode_t *pNewNode = createTreeNode(vertId, createList());
if (insertTreeNode(pGraph->vpVertsP1, pNewNode)) {
pGraph->vertNum1 += 1;
return NEW_VERTEX;
}
return EXISTING_VERTEX;
}
}
if (partite == 2) {
if(pGraph->vpVertsP2 == NULL) {
pGraph->vpVertsP2 = createTreeNode(vertId, createList());
pGraph->vertNum2 += 1;
return NEW_VERTEX;
} else {
binTreeNode_t *pNewNode = createTreeNode(vertId, createList());
if (insertTreeNode(pGraph->vpVertsP2, pNewNode)) {
pGraph->vertNum2 += 1;
return NEW_VERTEX;
}
return EXISTING_VERTEX;
}
}
} /* end of bipartGraphInsertVertex() */
//------------------------------search---------------------------------------------------
void test_searchs_the_given_data_in_list(){
Tree tree = createTree(areNodesEqual);
int num1 = 1,num2=2;
insertTreeNode(&tree, NULL, &num1);
insertTreeNode(&tree, &num1, &num2);
ASSERT(searchInTree(tree, &num1));
ASSERT(searchInTree(tree, &num2));
}
void test_removing_node_that_has_childs_should_fail(){
Tree tree = createTree(cmpInt);
int element1 = 10,element2 = 20,element3 = 30,element4 = 40;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
ASSERT(0 == removeTreeNode(&tree,&element1));
disposeTree(&tree);
};
void test_insert_child_node_to_root_in_tree(){
Iterator it;
int _10 = 10,_20 = 20;
ASSERT(insertTreeNode(tree, &_10,NULL));
ASSERT(insertTreeNode(tree, &_20, &_10));
it = getChildren(tree,&_10);
ASSERT(&_20 == next(&it));
ASSERT(NULL == next(&it));
}
void test_insert_root_node_in_tree_having_root_node_already(){
Iterator it;
int _10 = 10,_20 = 20;
ASSERT(insertTreeNode(tree, &_20,NULL));
ASSERT(insertTreeNode(tree, &_10,NULL));
it = getChildren(tree,&_10);
ASSERT(&_20 == next(&it));
ASSERT(NULL == next(&it));
}
void test_inserts_a_child_of_root_into_tree(){
Tree tree = createTree(areNodesEqual);
int nums[2] = {12,25};
Iterator it;
ASSERT(insertTreeNode(&tree, NULL, &nums[0]));
ASSERT(insertTreeNode(&tree, &nums[0], &nums[1]));
it = getChildren(tree, &nums[0]);
ASSERT(25 == *(int*)it.next(&it));
}
void test_removing_node_that_is_absent(){
Tree tree = createTree(cmpInt);
int element1 = 10,element2 = 20,element3 = 30;
Iterator it;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
ASSERT(0 == removeTreeNode(&tree,&element3));
disposeTree(&tree);
};
void test_deletes_child_of_root(){
Tree tree = createTree(areNodesEqual);
int nums[3] = {1,2,3};
insertTreeNode(&tree, NULL, &nums[0]);
insertTreeNode(&tree, &nums[0], &nums[1]);
insertTreeNode(&tree, &nums[0], &nums[2]);
ASSERT(1 == searchInTree(tree, &nums[1]));
ASSERT(1 == deleteFromTree(&tree, &nums[1]));
ASSERT(0 == searchInTree(tree, &nums[1]));
}
void test_searching_nodes_depth_one(){
Tree tree = createTree(cmpInt);
int element1 = 10,element2 = 20,element3 = 30;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
insertTreeNode(&tree,&element1,&element3);
ASSERT(1 == search(&tree,&element2));
ASSERT(1 == search(&tree,&element3));
disposeTree(&tree);
};
void test_gives_iterator_to_check_childrens_data_of_a_given_parent(){
Tree tree = createTree(areNodesEqual);
int nums[3] = {12,25,14};
Iterator it;
ASSERT(insertTreeNode(&tree, NULL, &nums[0]));
ASSERT(insertTreeNode(&tree, &nums[0], &nums[1]));
ASSERT(insertTreeNode(&tree, &nums[0], &nums[2]));
it = getChildren(tree, &nums[0]);
ASSERT(25 == *(int*)it.next(&it));
ASSERT(14 == *(int*)it.next(&it));
}
void test_delete_child_node_of_root_from_tree(){
Iterator it;
int _10 = 10,_20 = 20,_30 = 30;
ASSERT(insertTreeNode(tree, &_10,NULL));
ASSERT(insertTreeNode(tree, &_20, &_10));
ASSERT(insertTreeNode(tree, &_30, &_10));
ASSERT(deleteTreeNode(tree,&_30));
it = getChildren(tree,&_10);
ASSERT(&_20 == next(&it));
ASSERT(NULL == next(&it));
}
void test_inserting_two_nodes_one_root_and_its_child(){
Tree tree = createTree(cmpInt);
Iterator it;
int element1 = 10,element2 = 20;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
it = getChildren(&tree,&element1);
ASSERT(element2 == *(int*)it.next(&it));
ASSERT(NULL == it.next(&it));
disposeTree(&tree);
};
void test_removing_leaf_node(){
Tree tree = createTree(cmpInt);
int element1 = 10,element2 = 20;
Iterator it;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
ASSERT(1 == removeTreeNode(&tree,&element2));
it = getChildren(&tree,&element1);
ASSERT(NULL == it.next(&it));
disposeTree(&tree);
};
int bipartGraphInsertVertex(bpGraph_t* pGraph, int vertId, int partite)
{
int status;
binTreeNode_t *vertex;
if(partite==1){
vertex=searchValue(*pGraph->vertices1, vertId);
/* Check if vertex already exists */
if(vertex==NULL){
if(*pGraph->vertices1==NULL){
*pGraph->vertices1 = createTreeNode(vertId, NULL);
return NEW_VERTEX;
}
else{
/* initialise new node */
binTreeNode_t *newNode = createTreeNode(vertId, NULL);
status = insertTreeNode(*pGraph->vertices1,newNode);
return status;
}
}
return EXISTING_VERTEX;
}else if(partite==2){
vertex=searchValue(*pGraph->vertices2, vertId);
/* Check if vertex already exists */
if(vertex==NULL){
if(*pGraph->vertices2==NULL){
*pGraph->vertices2 = createTreeNode(vertId, NULL);
return NEW_VERTEX;
}
else{
/* initialise new node */
binTreeNode_t *newNode = createTreeNode(vertId, NULL);
status = insertTreeNode(*pGraph->vertices2,newNode);
return status;
}
}
return EXISTING_VERTEX;
}
return ERROR_VALUE;
} /* end of bipartGraphInsertVertex() */
void test_does_not_delete_node_with_children(){
Tree tree = createTree(areNodesEqual);
int nums[4] ={1,2,3,4};
insertTreeNode(&tree, NULL, &nums[0]);
insertTreeNode(&tree, &nums[0], &nums[1]);
insertTreeNode(&tree, &nums[0], &nums[2]);
insertTreeNode(&tree, &nums[2], &nums[3]);
ASSERT(1 == searchInTree(tree, &nums[2]));
ASSERT(0 == deleteFromTree(&tree, &nums[2]));
}
void test_inserting_three_nodes_one_after_the_other(){
Tree tree = createTree(cmpInt);
Iterator it;
int element1 = 10,element2 = 20,element3 = 30,element4 = 40;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
insertTreeNode(&tree,&element1,&element3);
insertTreeNode(&tree,&element1,&element4);
it = getChildren(&tree,&element1);
ASSERT(element4 == *(int*)it.next(&it));
ASSERT(element3 == *(int*)it.next(&it));
ASSERT(element2 == *(int*)it.next(&it));
disposeTree(&tree);
};
void test_removing_node_from_depth_two(){
Iterator it;
Tree tree = createTree(cmpInt);
int element1 = 10,element2 = 20,element3 = 30,element4 = 40;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
insertTreeNode(&tree,&element2,&element3);
insertTreeNode(&tree,&element2,&element4);
ASSERT(1 == removeTreeNode(&tree,&element3));
it = getChildren(&tree,&element2);
ASSERT(element4 == *(int*)it.next(&it));
ASSERT(NULL == it.next(&it));
disposeTree(&tree);
};
void test_inserting_node_at_depth_two(){
Tree tree = createTree(cmpInt);
void * element;
Iterator it;
int element1 = 10,element2 = 20,element3 = 30,element4 = 40;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
insertTreeNode(&tree,&element2,&element3);
insertTreeNode(&tree,&element2,&element4);
it = getChildren(&tree,&element2);
ASSERT(element4 == *(int*)it.next(&it));
ASSERT(element3 == *(int*)it.next(&it));
disposeTree(&tree);
};
struct TreeNode* insertTreeNode(struct TreeNode *T, int value)
{
if (T == NULL) {
T = (struct TreeNode*)malloc(sizeof(struct TreeNode));
T->value = value;
T->lchild = NULL;
T->rchild = NULL;
}
else if (value < T->value)
T->lchild = insertTreeNode(T->lchild, value);
else if (value > T->value)
T->rchild = insertTreeNode(T->rchild, value);
return T;
}
void test_insert_child_node_to_random_parent_in_tree(){
Iterator _10sChildren,_20sChildren;
int _10 = 10,_20 = 20,_30 = 30,_40 = 40;
ASSERT(insertTreeNode(tree, &_10,NULL));
ASSERT(insertTreeNode(tree, &_20, &_10));
ASSERT(insertTreeNode(tree, &_30, &_10));
ASSERT(insertTreeNode(tree, &_40, &_20));
_10sChildren = getChildren(tree,&_10);
_20sChildren = getChildren(tree,&_20);
ASSERT(&_20 == next(&_10sChildren));
ASSERT(&_30 == next(&_10sChildren));
ASSERT(NULL == next(&_10sChildren));
ASSERT(&_40 == next(&_20sChildren));
ASSERT(NULL == next(&_20sChildren));
}
void test_inserts_children_to_different_level(){
Tree tree = createTree(areNodesEqual);
int nums[5] = {10,20,30,40,50};
Iterator it;
insertTreeNode(&tree, NULL, &nums[0]);
insertTreeNode(&tree, &nums[0], &nums[1]);
insertTreeNode(&tree, &nums[0], &nums[2]);
ASSERT(insertTreeNode(&tree, &nums[1], &nums[3]));
ASSERT(insertTreeNode(&tree, &nums[2], &nums[4]));
it = getChildren(tree, &nums[1]);
ASSERT(40 == *(int*)it.next(&it));
ASSERT(NULL == it.next(&it));
it = getChildren(tree, &nums[2]);
ASSERT(50 == *(int*)it.next(&it));
ASSERT(NULL == it.next(&it));
}
void test_deletes_the_root_from_the_tree(){
Tree tree = createTree(areNodesEqual);
int number = 12;
insertTreeNode(&tree, NULL, &number);
ASSERT(searchInTree(tree, &number));
ASSERT(1 == deleteFromTree(&tree, &number));
}
void test_removing_root_node_when_it_has_no_childs(){
Tree tree = createTree(cmpInt);
int element1 = 10;
insertTreeNode(&tree,NULL,&element1);
ASSERT(1 == removeTreeNode(&tree,&element1));
ASSERT(0 == search(&tree,&element1));
};
void test_searching_root_node(){
Tree tree = createTree(cmpInt);
int element1 =10;
ASSERT(1 == insertTreeNode(&tree,NULL,&element1));
ASSERT(1 == search(&tree,&element1));
disposeTree(&tree);
};
//--------------------------------------create and insert-------------------------------------
void test_inserts_a_root_node_into_tree(){
Tree tree = createTree(areNodesEqual);
int number = 12;
Iterator it;
ASSERT(insertTreeNode(&tree, NULL, &number));
it = getChildren(tree, &number);
ASSERT(NULL == it.next(&it));
}
void test_inserting_first_node_in_linked_list(){
Tree tree = createTree(cmpInt);
Iterator it;
void *element;
int element1 =10;
ASSERT(1 == insertTreeNode(&tree,NULL,&element1));
it = getChildren(&tree,NULL);
element = it.next(&it);
ASSERT(*(int*)element == element1);
disposeTree(&tree);
};
int bipartGraphInsertVertex(bpGraph_t* pGraph, int vertId, int partite)
{
char **vertExists;
binTreeNode_t **adjTree;
int *numVerts, i;
if (partite == 1)
{
vertExists = &pGraph->vertExistsP1;
adjTree = &pGraph->adjTreeP1;
numVerts = &pGraph->numVertsP1;
}
else if (partite == 2)
{
vertExists = &pGraph->vertExistsP2;
adjTree = &pGraph->adjTreeP2;
numVerts = &pGraph->numVertsP2;
}
else
{
return ERROR_VALUE;
}
if (vertId >= *numVerts)
{
/* need to expand exists array */
*vertExists = safeRealloc(*vertExists, vertId + 1, (vertId + 1) - *numVerts);
for (i = *numVerts; i < vertId; i++)
{
(*vertExists)[i] = 0;
}
*numVerts = vertId + 1;
}
else if ((*vertExists)[vertId])
{
return EXISTING_VERTEX;
}
if (*adjTree == NULL)
{
/* create tree */
*adjTree = createTreeNode(vertId, createList());
}
else
{
/* or insert a node */
insertTreeNode(*adjTree, createTreeNode(vertId, createList()));
}
/* set exists flag */
(*vertExists)[vertId] = 1;
return NEW_VERTEX;
} /* end of bipartGraphInsertVertex() */
JsonEditorMain::JsonEditorMain(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::JsonEditorMain),
newInsertText(tr("Insert new data")),
treeViewColumnKey(tr("Node")),
treeViewColumnValue(tr("Value")),
treeViewColumnType(tr("Type"))
{
ui->setupUi(this);
connect(ui->menuCodeTools, SIGNAL(toggled(bool)), this, SLOT(toggleCodeToolbar(bool)));
connect(ui->menuFindTools, SIGNAL(toggled(bool)), this, SLOT(toggleFindToolbar(bool)));
connect(ui->menuFileTools, SIGNAL(toggled(bool)), this, SLOT(toggleFileToolbar(bool)));
connect(ui->menuEditTools, SIGNAL(toggled(bool)), this, SLOT(toggleEditToolbar(bool)));
connect(ui->menuRefresh, SIGNAL(triggered()), this, SLOT(refreshJsonTree()));
connect(ui->menuInsertNode, SIGNAL(triggered()), this, SLOT(insertTreeNode()));
connect(ui->menuInsertChild, SIGNAL(triggered()), this, SLOT(insertTreeChild()));
connect(ui->menuDeleteNode, SIGNAL(triggered()), this, SLOT(deleteTreeNode()));
connect(ui->jsonTree, SIGNAL(clicked(QModelIndex)), this, SLOT(updateActions()));
connect(ui->menuFormat, SIGNAL(triggered()), this, SLOT(formatCode()));
connect(ui->menuHelp, SIGNAL(triggered()), this, SLOT(showHelp()));
connect(ui->jsonTree, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(dataEdit(QModelIndex)));
// connect(ui->menuNewFile, SIGNAL(triggered()), this, SLOT(newFile()));
connect(ui->menuOpenFile, SIGNAL(triggered()), this, SLOT(open()));
connect(ui->menuSaveFile, SIGNAL(triggered()), this, SLOT(save()));
connect(ui->menuSaveAs, SIGNAL(triggered()), this, SLOT(saveAs()));
JSHighlighter * highlight = new JSHighlighter(ui->jsonCode->document());
setCurrentFile("");
textEdit = ui->jsonCode;
connect(textEdit->document(), SIGNAL(contentsChanged()),
this, SLOT(documentWasModified()));
setUnifiedTitleAndToolBarOnMac(true);
m_findDialog = new FindDialog(this);
m_findDialog->setModal(false);
m_findDialog->setTextEdit(textEdit);
m_findReplaceDialog = new FindReplaceDialog(this);
m_findReplaceDialog->setModal(false);
m_findReplaceDialog->setTextEdit(textEdit);
connect(ui->menuFind, SIGNAL(triggered()), m_findDialog, SLOT(show()));
connect(ui->menuReplace, SIGNAL(triggered()), m_findReplaceDialog, SLOT(show()));
// connect(ui->actionFindNext, SIGNAL(triggered()), m_findDialog, SLOT(findNext()));
// connect(ui->actionFindPrevious, SIGNAL(triggered()), m_findDialog, SLOT(findPrev()));
readSettings();
}
int main(int argc, char *argv[])
{
struct tree at;
int op,lr,parent,child;
initTree(&at);
while(scanf("%d",&op)==1 && op!=0){
switch(op){
case 1://insert node
scanf("%d%d%d",&parent,&lr,&child);
printf("insert node(p=%d lr=%d c=%d):",parent,lr,child);
if(insertTreeNode(&at,parent,lr,child)){
printf("success\n");
}else{
printf("fail\n");
}
break;
case 2://breadfirst traversal
printf("breadthfirst:");
breadthFirstTraversal(&at);
printf("\n");
break;
case 3://pre order traversal
printf("depth preorder:");
depthFirstTraversal(&at,PREORDER);
printf("\n");
break;
case 4://in order traversal
printf("depth inorder:");
depthFirstTraversal(&at,INORDER);
printf("\n");
break;
case 5://post order traversal
printf("depth postorder:");
depthFirstTraversal(&at,POSTORDER);
printf("\n");
break;
default:
printf("error operator\n");
break;
}
}
releaseTree(&at);
return 0;
}
