mgm娱乐场c语言实现双链表

[cpp]
#include <assert.h>    
#include <stdlib.h>    
#include <stdio.h>    
   
   
typedef struct myList  DNode;   
struct myList   
{   
    DNode *next;   
    DNode *prev;   
    int data;   
};   
DNode* init(int data);   
void insertLastNode(DNode* L,int data);   
void insertNode(DNode* L,int data);   
DNode* findPrev(DNode* L,int data);   
void deleNode(DNode* L,int data);   
DNode* findCur(DNode* L,int data);   
   
/************************************************************************/   
/* 初始化第一个节点                                                    
*/   
/************************************************************************/   
DNode* init(int data)   
{   
    DNode* headNode=(DNode*)malloc(sizeof(DNode));   
    assert(headNode);   
    headNode->next = NULL;   
    headNode->prev = NULL;   
    headNode->data = data;   
    return headNode;   
}   
   
int isEmpty(DNode* L)   
{   
    return L->next ==NULL;   
}   
   
int isLast(DNode* L,DNode* p)   
{   
    return p->next==NULL;   
}   
   
DNode* findCur(DNode* L,int data)   
{   
    DNode* curNode;   
   
    curNode = L->next;   
   
    while(curNode !=NULL&& curNode->data!=data)   
        curNode = curNode->next;   
   
    return curNode;   
}   
/************************************************************************/   
/* 将节点插入到队列后端                                                
*/   
/************************************************************************/   
void insertLastNode(DNode* L,int data)   
{   
    assert(L);   
    DNode* oNode=(DNode*)malloc(sizeof(DNode));   
    oNode->data = data;   
    L->next = oNode;   
    oNode->prev = L;   
}   
/** 
    插入到链表指定位置 
**/   
void insertNode(DNode* L,int data)   
{   
    assert(L);   
    DNode* qNode=(DNode*)malloc(sizeof(DNode));   
    DNode* prevNode= findPrev(L,data);   
   
   
       
    qNode->next = prevNode->next;   
    prevNode->next->prev = qNode;   
       
    prevNode->next = qNode;   
    qNode->prev = prevNode;   
    return;   
}   
   
DNode* findPrev(DNode* L,int data)   
{   
    assert(L);   
    DNode* tmpNode;    
    tmpNode = L;   
   
    while (tmpNode->next!=NULL&&tmpNode->next->data!=data)   
    {   
        tmpNode = tmpNode->next;   
    }   
    return tmpNode;   
}   
   
void deleNode(DNode* L,int data)   
{   
   DNode* tmpNode = findCur(L,data);   
   if (tmpNode==NULL)   
   {   
       return ;   
   }   
   if (isLast(L,tmpNode))   
   {   
       tmpNode->prev =NULL;   
        tmpNode->prev->next =NULL;   
        free(tmpNode);   
   }   
   
    tmpNode ->prev->next = tmpNode->next;   
    tmpNode->next->prev = tmpNode->prev;   
    free(tmpNode);   
   return ;   
}   
int _tmain(int argc, _TCHAR* argv[])   
{   
    DNode* myDNode;   
    myDNode = init(1);   
    return 0;   
}   

view plaincopy to clipboardprint?#include <stdio.h>  
#include <stdlib.h>  
#include <assert.h>  
 
#define STACK_SIZE 100  
 
typedef struct TREE 

    char data; 
    struct TREE *left; 
    struct TREE *right; 
}*Tree,Node; 
 
typedef struct STACK 

    Node node[STACK_SIZE]; 
    int top; 
}Stack; 
 
void init_stack(Stack * stack) 

    stack->top = 0; 

 
int is_empty(Stack *stack) 

    return stack->top == 0; 

 
int push(Stack *stack,Node * node) 

    if(stack->top == STACK_SIZE) 
        return 0; 
 
    stack->node[stack->top++] = *node; 
    return 1; 

 
int top(Stack *stack,Node *node) 

    if(stack->top == 0) 
        return 0; 
 
    *node = stack->node[stack->top-1]; 
    return 1; 

 
int pop(Stack *stack,Node *node) 

    if(stack->top == 0) 
        return 0; 
 
    *node = stack->node[–stack->top]; 
    return 1; 

 
void creat_tree(Tree * tree) 

    char data[1]; 
    scanf(“%s”,data); 
 
//  char data;  
//  scanf(“%c”,data); //会把回车当输入!why?  
 
    if(data[0] == ‘a’) 
    { 
        *tree = NULL; 
    } 
    else 
    { 
        *tree = malloc(sizeof(Node)); 
        if(*tree == NULL) 
        { 
            exit(0); 
        } 
             
        (*tree)->data = data[0]; 
        creat_tree(&((*tree)->left)); 
        creat_tree(&((*tree)->right)); 
    } 
    return ; 

 
void pre_order(Tree tree) 

    if(tree == NULL) 
        return ; 
     
    printf(“%c”,tree->data); 
    pre_order(tree->left); 
    pre_order(tree->right); 

 
void in_order(Tree tree) 

    if(tree == NULL) 
        return ; 
     
    in_order(tree->left); 
    printf(“%c”,tree->data); 
    in_order(tree->right); 

 
void post_order(Tree tree) 

    if(tree == NULL) 
        return ; 
     
    post_order(tree->left); 
    post_order(tree->right); 
    printf(“%c”,tree->data); 

 
void in_order_stack(Tree tree) 

    if(tree == NULL) 
        return ; 
 
    Stack stack; 
    init_stack(&stack); 
 
    Node * node = malloc(sizeof(Node)); 
 
    while(!is_empty(&stack) || tree) 
    { 
        if(tree != NULL) 
        { 
            push(&stack,tree); 
            tree = tree->left; 
        } 
        else 
        { 
            pop(&stack,node); 
            printf(“%c “,node->data); 
            if(node->right != NULL) 
                tree = node->right; 
        } 
    } 
    printf(“\n”); 

 
int tree_heigh(Tree tree) 

    if(tree == NULL) 
        return 0; 
    else 
    { 
           int left = tree_heigh(tree->left); 
           int right = tree_heigh(tree->right); 
           return left > right ? left+1 : right+1; 
    } 

 
// 1 2 3 a 4 a a a a  
//     1  
//   2   3  
// a  4 a  a  
//   a a  
int main() 

    Tree tree = NULL; 
    creat_tree(&tree); 
    printf(“pre:\n”); 
    pre_order(tree); 
    printf(“\nin:\n”); 
    in_order(tree); 
    printf(“\npost:\n”); 
    post_order(tree); 
    printf(“\n”); 
    printf(“Tree heigh is %d\n”,tree_heigh(tree)); 
 
    in_order_stack(tree); 
 
    return 0; 

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include <assert.h> 
#include <stdlib.h> 
#include <stdio.h> 
 
 
typedef struct myList  DNode; 
struct myList 

    DNode *next; 
    DNode *prev; 
    int data; 
}; 
DNode* init(int data); 
void insertLastNode(DNode* L,int data); 
void insertNode(DNode* L,int data); 
DNode* findPrev(DNode* L,int data); 
void deleNode(DNode* L,int data); 
DNode* findCur(DNode* L,int data); 
 
/************************************************************************/ 
/* 初始化第一个节点                                                    
*/ 
/************************************************************************/ 
DNode* init(int data) 

    DNode* headNode=(DNode*)malloc(sizeof(DNode)); 
    assert(headNode); 
    headNode->next = NULL; 
    headNode->prev = NULL; 
    headNode->data = data; 
    return headNode; 

 
int isEmpty(DNode* L) 

    return L->next ==NULL; 

 
int isLast(DNode* L,DNode* p) 

    return p->next==NULL; 

 
DNode* findCur(DNode* L,int data) 

    DNode* curNode; 
 
    curNode = L->next; 
 
    while(curNode !=NULL&& curNode->data!=data) 
        curNode = curNode->next; 
 
    return curNode; 

/************************************************************************/ 
/* 将节点插入到队列后端                                                
*/ 
/************************************************************************/ 
void insertLastNode(DNode* L,int data) 

    assert(L); 
    DNode* oNode=(DNode*)malloc(sizeof(DNode)); 
    oNode->data = data; 
    L->next = oNode; 
    oNode->prev = L; 

/**
    插入到链表指定位置
**/ 
void insertNode(DNode* L,int data) 

    assert(L); 
    DNode* qNode=(DNode*)malloc(sizeof(DNode)); 
    DNode* prevNode= findPrev(L,data); 
 
 
     
    qNode->next = prevNode->next; 
    prevNode->next->prev = qNode; 
     
    prevNode->next = qNode; 
    qNode->prev = prevNode; 
    return; 

 
DNode* findPrev(DNode* L,int data) 

    assert(L); 
    DNode* tmpNode;  
    tmpNode = L; 
 
    while (tmpNode->next!=NULL&&tmpNode->next->data!=data) 
    { 
        tmpNode = tmpNode->next; 
    } 
    return tmpNode; 

 
void deleNode(DNode* L,int data) 

   DNode* tmpNode = findCur(L,data); 
   if (tmpNode==NULL) 
   { 
       return ; 
   } 
   if (isLast(L,tmpNode)) 
   { 
       tmpNode->prev =NULL; 
        tmpNode->prev->next =NULL; 
        free(tmpNode); 
   } 
 
    tmpNode ->prev->next = tmpNode->next; 
    tmpNode->next->prev = tmpNode->prev; 
    free(tmpNode); 
   return ; 

int _tmain(int argc, _TCHAR* argv[]) 

    DNode* myDNode; 
    myDNode = init(1); 
    return 0; 

#define STACK_SIZE 100

 

typedef struct TREE
{
 char data;
 struct TREE *left;
 struct TREE *right;
}*Tree,Node;

http://www.bkjia.com/Cyy/491518.htmlwww.bkjia.comtruehttp://www.bkjia.com/Cyy/491518.htmlTechArticle\[cpp\] #include assert.h #include stdlib.h
#include stdio.h typedef struct myList DNode; struct myList { DNode
*next; DNode *prev; int data; }; DNode* init(int data); void
insertLas…

typedef struct STACK
{
 Node node[STACK_SIZE];
 int top;
}Stack;

void init_stack(Stack * stack)
{
 stack->top = 0;
}

int is_empty(Stack *stack)
{
 return stack->top == 0;
}

int push(Stack *stack,Node * node)
{
 if(stack->top == STACK_SIZE)
  return 0;

 stack->node[mgm娱乐场,stack->top++] = *node;
 return 1;
}

int top(Stack *stack,Node *node)
{
 if(stack->top == 0)
  return 0;

 *node = stack->node[stack->top-1];
 return 1;
}

int pop(Stack *stack,Node *node)
{
 if(stack->top == 0)
  return 0;

 *node = stack->node[–stack->top];
 return 1;
}

void creat_tree(Tree * tree)
{
 char data[1];
 scanf(“%s”,data);

// char data;
// scanf(“%c”,data); //会把回车当输入!why?

相关文章