C/C++軟件工程師就業求職手冊學習筆記---第十章

1、鏈表反轉

Node*reverse(Node *head)
{
         if(head==NULL)
                  return NULL;
         if(head->next==NULL)
                  return head;
         else
         {
                  Node*pre=head,cur=head->next,post;
                  pre->next=NULL;
                  while(cur！=NULL)
                  {
                          post=cur->next;
                          cur->next=pre;
                          pre=cur;
                          cur=post;
                  }
                  return pre;               
         }
}

 

2、在有序鏈表中插入新元素，保證仍然有序

Node*insertsort(Node *head)
{
         Node *newhead=head,new,cur;
         int d;
         while(1)
         {
                  scanf("%d",&data);
                  if(0==d)
                          break;
                  else
                  {
                          new=(Node*)malloc(sizeof(Node));
                          new->data=d;
                          new->next=NULL;
                          if(!head)
                          {
                                   newhead=new;
                                   continue;
                          }
                          else
                          {
                                   if(d<=newhead->data)
                                   {
                                            new->next=newhead;
                                            newhead=new;
                                            continue;
                                   }
                                   else
                                   {
                                       cur=newhead;
                                            while(cur->next!=NULL&& d>cur->next->data)
                                            {
                                                     cur=cur->next;
                                            }
                                            if(cur->next==NULL)
                                            {
                                                     cur->next=new;
                                                     continue;
                                            }
                                            else
                                            {
                                                    new->next=cur->next;
                                                     cur->next=new;
                                                     continue;
                                            }
                                           
                                   }
                          }
                  }
         }
 
}

3、判斷給定的輸出順序是否可能是棧的出棧順序。

BOOL check(int a[],int len1,int s[],int len2)
{
         if(len2>len1 || len1==0 || len2==0)
           return false;
         stack<int> T;
         int i=0,j=0;
         while(i<len1 && j<len2)
         {
                  T.push(a[i++]);
                  while(!T.empty() &&T.top()==s[j])
                  {
                          T.pop();
                          ++j;
                  }
         }
         if(j>=len2)
           return TRUE；
         else
                  return FALSE;
}

 

4、二叉搜索樹的各種操作

定義結點：

struct {
Node*parent;
Node*left;
Node*right;
int  data;
}Node;

1>

void insert(Node *p,int d)
{
         if(p==NULL)
                  return;
         Node* par=p;
         Node *NewNode=(Node*)malloc(sizeof(Node));
         Node *ptemp=NULL;
         NewNode->data=d;
         NewNode->left=NULL;
         NewNode->right=NULL;
         NewNode->parent=NULL;
         if(p==NULL)
         {
          p=NewNode;
          return;
         }
         while(par!=NULL)
         {
                  ptemp=par;
                  if(NewNode->data>par->data)
                  {
                          par=par->right;
                  }
                  elseif(NewNode->data<par->data)
                  {
                          par=par->left;
                  }
                  else
                  {
                          free(NewNode);
                          NewNode=NULL;
                  }
         }
         NewNode->parent=ptemp;
         if(NewNode->data>ptemp->data)
         {
                  ptemp->right=NewNode;
         }
         else
         {
                  ptemp->left=NewNode;
         }
}

5、二叉樹中序遍歷

 

BOOL MainInOrder(Node *root)
{
         if(root==NULL)
                  return FALSE;
         Node *p=root;       
         InOrder(p);     
}
void InOrder(Node *root)
{
         if(root==NULL)
         {
            return;
         }
         else
         {
                  median(root->left);
                  cout<<root->data;
                  median(root->right);
         }
}
 
void InOrderStack(Node *root)
{
    stack<Node *> s;
    Node *ptr=root;
         while(ptr!=NULL || !s.empty())
         {
                  while(ptr!=NULL)
                  {
                          s.push(ptr);
                          ptr=ptr->left;
                  }
                  if(!s.empty())
                  {
                      Node *p=s.pop();
                      cout<<p->data<<endl;
                      ptr=p->right;
                  }
         }
}

6、二叉樹前序遍歷

BOOL MainPreOrder(Node *root)
{
         if(root==NULL)
         {
                  return FALSE;
         }
         else
         {
                  PreOrder(root);
         }
}
voidPreOrder(Node* root)
{
         if(root!=NULL)
         {
                  cout<<root->data<<endl;
                  PreOrder(root->left);
                  PreOrder(root->right);
         }
}

7、二叉樹的後序遍歷

BOOL MainPostOrder(Node* root)
{
         if(root==NULL)
         {
                  return FALSE;
         }
         else
         {
                  PostOrder(root);
         }
}
 
void PostOrder(Node* root)
{
         if(root!=NULL)
         {
                  PostOrder(root->left);
                  PostOrder(root->right);
                  cout<<root->data<<endl;
         }
}

非遞歸實現後序遍歷，因爲在訪問到左子樹爲空後，會返回到某節點，但是此時並不能將其出棧，因爲在訪問完其右子樹後還需要訪問此節點，因此需要確定標誌位，來表示此節點是否被訪問過。

 

struct {
        Node*left;
        Node*right;
        int  data;
        char tag;
}Node;

BOOL PostOrderStack(Node *root)
{
         stack<Node *>s;
         Node *p=root;
         while(p!=NULL)
         {
                  s.push(p);
                  p=p->left;
         }
         if(!s.empty())
         {
                  Node* ptr=s.top();
                  if(ptr->tag==1)
                  {
                          s.pop();
                          cout<<ptr->data<<endl;
                          ptr==NULL;
                  }
                  else
                  {
                          ptr->tag=1;
                          p=p->right;
                  }
         }
}

 

8、二叉樹按層遍歷，利用隊列實現

void LevelOrder(Node * root)
{
         queue<Node *> q;
         Node *p=root;
         if(p!=NULL)
         {
                  q.push(p);
         }
         while(!q.empty())
         {
                  p=q.front();
                  q.pop();
                  cout<<p->data<<endl;
                  if(p->left!=NULL)
                  {
                          q.push(p->left);
                  }
                  if(p->right!=NULL)
                  {
                          q.push(p->right);
                  }
         }
}

9、判斷二叉樹是不是二叉排序樹

BOOL CheckBST(Node *root)
{
         if(root==NULL)
         {
                  return FALSE;
         }
         else
         {
                  stack<Node*>s;
                  Node* p=root;
                  Node* ptr=NULL;
                  int last=0;
                  while(p!=NULL || !s.empty())
                  {
                          while(p!=NULL)
                          {
                                   s.push(p);
                                   p=p->left;
                          }
                          if(!s.empty())
                          {
                                   ptr=s.top();
                                   if(last==0 ||last<ptr->data)
                                   {
                                            last=ptr-<data;
                                            p=p->right;
                                   }
                                   elseif(last>ptr->data)
                                   {
                                            returnFALSE;
                                   }                                 
                          }
                  }
         }
         return TRUE;
}

------------------------------第十章結束---------------------------------------