【无标题】

层次遍历

queue<TreeNode*>q;

        TreeNode p;

        q.push(root);

        while(!q.empty()){

            p=q.front();

            printf("%dv",p->val);

            q.pop();

            if(p->left){

                q.push(p->left);

            }

            if(p->right){

                q.push(p->right);

            }

        }

    }

折半搜索

 力扣

class Solution {

public:

    int search(vector<int>& nums, int target) {

        int mid;

        int i=0,j=nums.size()-1;

        int flag=0;

        while(i<=j){

            mid=(i+j)/2;

            if(nums[mid]==target){

                flag=1;

                break;

            }

            if(nums[mid]>target){

                j=mid-1;

            }

            else i=mid+1;

        }

     if(flag==1)return mid;

     else return -1;

    }

};

第二种方法

class Solution {

public:

    int search(vector<int>& nums, int target) {

        int mid;

        int i=0,j=nums.size()-1;

        while(i<=j){

            mid=(i+j)/2;

            if(nums[mid]==target){

                return mid;

            }

            if(nums[mid]>target){

                j=mid-1;

            }

            else i=mid+1;

        }

     return -1;

     

    }

};

考试题目

int search(int* nums, int n, int target) {

        int left = 0, right = n - 1; //查询区间的左、右端点

        while(left <= right){

            int mid = left + (right - left) / 2; //查询区间的中点

            if(nums[mid] == target)

                return mid;

            else if(nums[mid] < target)

                left = mid + 1;

            else right = mid - 1;

        }

        return -1;

    }

二叉搜索

力扣

法一；

递归一

class Solution {

public:

    TreeNode* searchBST(TreeNode* root, int val) {

        if(root){

            if(root->val==val)return root;

        if(root->val>val)

        return searchBST(root->left, val);

        else return searchBST(root->right,val);

        }

        return NULL;

    }

};

递归二

class Solution {

public:

    TreeNode* searchBST(TreeNode* root, int val) {

        if(root==NULL||root->val==val)     //一定要==NULL在前面；

        return root;

        if(root->val>val)

        return searchBST(root->left, val);

        else 

        return searchBST(root->right,val);

    }

};

法二

迭代

class Solution {

public:

    TreeNode* searchBST(TreeNode* root, int val) {

      while(root){

          if(root->val==val)return root;

          if(root->val>val)

          root=root->left;

          else root=root->right;

      }

      return root;

    }

};

Flyd

#include <bits/stdc++.h>

using namespace std;

const int MAX=50,inf=0x3f3f3f; 

int main(){

    int i,n,j;

    int g[MAX][MAX];

    scanf("%d",&n);

    for(i=0;i<n;i++){

        for(j=0;j<n;j++){

            scanf("%d ",&g[i][j]);

            if(g[i][j]==0&&i!=j){

                g[i][j]=inf;

            }

        }

    }

    int k;

    for(k=0;k<n;k++){

        for(i=0;i<n;i++){

            for(j=0;j<n;j++){

                if(g[i][j]>g[i][k]+g[k][j]){

                    g[i][j]=g[i][k]+g[k][j];

                }

            }

        }

    }

    for(i=0;i<n;i++){

        for(j=0;j<n;j++){

            

            if(g[i][j]==inf){

                printf("-1 ");}

            else

                printf("%d ",g[i][j]);

        }

        printf("\n");

    }

}

图的遍历

d DFS( MatGraph* G, VertexType V)

{

    /**

    * 请在下面的begin..end间编写程序代码，

    * 勿修改begin..end之外的代码。

    */

    /*******************begin*******************/

    int j;

    visited[V]=1;

    printf(" %d",V);

    for(j=0;j<G->n;j++){

        if(G->edges[V][j]!=0&&visited[j]!=1){

            DFS(G,j);

        }

    }

    /*******************end********************/

}

以邻接矩阵存储图的DFS

以邻接表存储的BFS

void BFS( AdjGraph* G, VertexType V)

{

    /*******************begin*******************/

    int visited[MAXV];

    memset(visited,0, sizeof(visited));

    queue<int>q;

    visited[V]=1;

    q.push(V);

    while(!q.empty()){

        int m=q.front();

        printf(" %d",m); q.pop();

            ArcNode* p=G->adjlist[m].firstarc;

            while(p){

                if(visited[p->adjvex]==0){

                    q.push(p->adjvex);

                    visited[p->adjvex]=1;

                    }

                p=p->nextarc;

            }

    }

/*******************end******************

构造二叉树

TNode* InPreToTree(char *pa, char *ia, int p1, int p2, int i1, int i2)

{

    /*请在BEGIN和END之间实现你的代码*/

    /*****BEGIN*****/

    TNode *b;

    int k,i;

    if(p2<0)return NULL;

    b=(TNode*)malloc(sizeof(TNode));

    b->data=*pa;

    for(i=i1;i<=i2;i++){

        if(*(ia+i)==*pa)break;

    }

    k=i;

    b->left=InPreToTree(pa+1,ia,p1,k-1,i1,k-1);

    b->right=InPreToTree(pa+k+1,ia+k+1,p1,p2-k-1,i1,i2-k-1);

    return b;

    /******END******/

    /*请不要修改[BEGIN,END]区域外的代码*/

} 

先序程序创建二叉树

BiTreeNode* CreatBiTree(char* s, int &i, int len)

// 利用先序遍历创建二叉树

// 参数：先序遍历字符串s，字符串初始下标i=0，字符串长度len。

// 返回：二叉树

{

    // 请在这里补充代码，完成本关任务

    /********** Begin *********/

    if(s[i]=='#')return NULL;

    BiTreeNode* root=(BiTreeNode*)malloc(sizeof(BiTreeNode));

    root->data=s[i];

    i++;

    root->left=CreatBiTree(s,i,len);

    i++;

    root->right=CreatBiTree(s,i,len);

    return root;

    /********** End **********/

}