精华内容
下载资源
问答
  • 查找数据:把排序好的数据拆分为数大致相等的半,因为有排序,查找的时候先和其中一半数据种的最大或者最小的数进行比较来断定要查找的数据是否会包含被分割后的一半数据种,然后在满足判定条件的数据集中一次...

    二分法原理概述

    简单粗暴一点理解二分法

    1. 将数据有序排列:先将一个数据集进行有序排列(可根据某种数值的大小降序或升序<当然排序的规则可根据业务规则自定义>,前提是需要查找的数据具备该规则同样的属性);

    2. 数据分半:就是将排序好的数据集切分成大致相等的两份数据;

    3. 查找数据:把排序好的数据拆分为个数大致相等的两半,因为有排序,查找的时候先和其中一半数据种的最大或者最小的数进行比较来断定要查找的数据是否会包含被分割后的一半数据种,然后在满足判定条件的数据集中一次获取数据进行比对直到找到数据或者比较完所有数据返回没有该数据,

    python实现代码

    # -*- coding: utf-8 -*-
    import  os
    import sys
    
    
    def dichotomySreach(list,val):
        pass
        begin = 0
        end = len(list) -1
    
        while begin <= end :
            mid = (begin + end) // 2 #向下取整
            if val == list[mid]:
                return mid
            elif val < list[mid]:
                end = mid -1
            elif val > list[mid]:
                begin = mid + 1
    
        return None
    
    if __name__ == "__main__":
        # pass
        print(os.path.basename(__file__))
        print(os.path.abspath(__file__))
        print(__file__)
        print(sys.argv[0])
    
        list =[1, 2 ,3 ,5 ,66 ,77 , 98, 100, 453,676,712,774]
    
        print(dichotomySreach(list,98))
        print(dichotomySreach(list,1))
        print(dichotomySreach(list,100))
        print(dichotomySreach(list,200))
        if not dichotomySreach(list,200):
            print("200 not in list")

    运行结果

    dichotomy.py
    L:\DEV\XYD文件集合\电子字典设计文档\A_DictPick\dichotomy.py
    L:/DEV/XYD文件集合/电子字典设计文档/A_DictPick/dichotomy.py
    L:/DEV/XYD文件集合/电子字典设计文档/A_DictPick/dichotomy.py
    6
    0
    7
    None
    200 not in list
    展开全文
  • 循环条件根据旋转数组的特点,序列应满足第一元素大于最后一元素(特例1,2,3,4,5) 二分查找(此处的mid,left,right表示数值):如果mid大于等于left,说明mid属于前一递增数组,最小元素应该在mid 的后面...

    剑指 Offer 11. 旋转数组的最小数字

    题目链接

    个人思路

    题意

    题目中的数组被分割成两部分,且两部分均为递增序列,找出序列中的最小元素,要利用递增数组的特性,要采用二分查找

    思路

    • 循环条件:根据旋转数组的特点,序列应满足第一个元素大于最后一个元素(特例1,2,3,4,5)
    • 二分查找(此处的mid,left,right表示数值):如果mid大于等于left,说明mid属于前一个递增数组,最小元素应该在mid 的后面;如果mid小于等于right,说明mid属于后一个递增数组,最小元素应该在mid前面,也可能就是mid
    • 循环终止条件:当right和left相差1时,此时left指向前一个递增数组的最后一个元素,right指向后一个递增数组的第一个元素,right即为最小元素,返回right

    注意

    此题有许多特例

    • 当数组为已经排序的数组,即1,2,3,4,5,此时第一个元素小于最后一个元素,应返回left
    • 当最小元素夹在相同元素中,即10,1,10,10,10,此时会出现mid== left ==right的情况,此时无法判断当前的mid在哪一个递增数组中,只能顺序遍历

    个人错误思路代码

    • 判断条件没有搞清楚
    • 对于mid== left ==right的特例没有处理好
    class Solution {
    public:
        const int inf = 0x3fffffff;
        int minArray(vector<int>& numbers) {
            if(numbers.size() == 0){
                return 0;
            }
            int left = 0, right = numbers.size() - 1;
            if(left == right){
                return numbers[left];
            }
            int temp = inf;
            if(numbers[left] <= numbers[right]){
                temp = numbers[left];
            }
            while(left <= right){
                
                int mid = (left + right) / 2;//下标
                int midData = numbers[mid];//数据
    
                //cout << left << " " << mid << " " << right << endl;
                if(right - left == 1){//此时是最小元素,即分界处
                    if(numbers[right] > temp){
                        return temp;
                    }else{
                        return numbers[right];
                    }
                }
                if(midData >= numbers[left]){//说明当前元素在前面的递增数组中,最小元素则在后半段
                    left = mid;
                    continue;
                }
                if(midData <= numbers[right]){
                    right = mid;
                    continue;
                }
            }   
            return numbers[left];
        }
    };
    

    正确解题代码

    class Solution {
    public:
        int minArray(vector<int>& numbers) {
            if(numbers.size() == 0){
                return 0;
            }
            int left = 0, right = numbers.size() - 1;
            if(numbers[left] < numbers[right]){//说明数组是排序的
                return numbers[left];
            }
            while(numbers[left] >= numbers[right]){
                int mid = (left + right) >> 1;
                //cout << left << " " << mid << " " << right << endl;
                
                if(right - left == 1){//左右指针位置相差1
                    return numbers[right];
                }
                if(numbers[left] == numbers[mid] && numbers[mid] == numbers[right]){//当三个指针数值相同时,无法判断最小元素的位置
                    int temp = numbers[left];
                    for(int i = left + 1; i < right; ++i){
                        if(numbers[i] < temp){
                            temp = numbers[i];
                        }
                    }
                    return temp;
                }
                if(numbers[mid] >= numbers[left]){//说明当前元素属于前一个递增数组中,最小元素在当前元素后面
                    left = mid;
                    continue;
                }
                if(numbers[mid] <= numbers[right]){//说明当前元素属于后一个递增数组,最小元素可能是当前元素,也可能在当前元素前面
                    right = mid;
                    continue;
                }
            }
            return numbers[right];
        }
    };
    

    测试样例

    input:1,2,3,4,5
    output:1
    
    input:10,1,10,10,10
    output:1
    
    展开全文
  • 范例1-39 归并两个单链表 88 ∷相关函数:concatenate函数 1.3.9 动态堆栈 90 范例1-40 动态堆栈 90 ∷相关函数:push函数 Pop函数 1.3.10 动态队列 93 范例1-41 动态队列 93 ∷相关函数:Enqueue函数 ...
  • 查找数据公式两个(基本查找函数为VLOOKUP,MATCH) 【输入数据的技巧】 谈谈Excel输入的技巧 一列中不输入重复数字 如果要查找重复输入的数字 单元格输入 大量0值输入超级技巧 如何在C列中输入工号在D列显示姓名 输入...
  • 入门学习Linux常用必会60命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    在前种格式中,会将<来源>复制至<目的地>或将多<来源>文件复制至已存在的<目录>,同时设定权限模式及所有者/所属组。在第三种格式中,会创建所有指定的目录及它们的主目录。长选项必须用的参数在使用短选项时也...
  • 4.支持双条件查找,例如定位于从60到100的所有数据区域。或者不包括60到100的所有区域。 工具: 【根据工资计算钞票面额张数】 功能: 根据工资计算需要发工资时需要多少张100元、50元、20元、10元等等面额的钞票...
  • Java开发技术大全(500源代码).

    热门讨论 2012-12-02 19:55:48
    outputMax.java 求两个数中的最大数 overflowExample.java 演示溢出 precedence.java 演示自加运算符的优先级 primeNumber.java 输出100-200之间的所有素数 ranking.java 评定成绩等级 rankingBySwitch.java ...
  • 4.支持双条件查找,例如定位于从60到100的所有数据区域。或者不包括60到100的所有区域。 工具: 【根据工资计算钞票面额张数】 功能: 根据工资计算需要发工资时需要多少张100元、50元、20元、10元等等面额的钞票...
  • 函数作用:在多工作表中查找范围内符合某个指定条件的项目对应指定范围加总求和..........................59 '35.函数作用:返回 Column 英文字.......................60 '36.函数作用:查找指定列名的列数.......
  • EXCEL函数公式集

    热门讨论 2010-03-16 03:26:38
    查找数据公式两个(基本查找函数为VLOOKUP,MATCH) 【输入数据的技巧】 谈谈Excel输入的技巧 一列中不输入重复数字 如果要查找重复输入的数字 单元格输入 大量0值输入超级技巧 如何在C列中输入工号在D列显示姓名 输入...
  • javascript文档

    2009-08-11 10:44:24
    :) 根据条件执行两个表达式之一。 constructor 属性 指定创建对象的函数。 continue 语句 停止循环的当前迭代,并开始一次新的迭代。 cos 方法 返回一个数的余弦。 Date 对象 提供日期和时间的基本存储和检索。...
  • JScript 语言参考

    2009-05-28 08:53:39
    :) 根据条件执行两个表达式之一。 constructor 属性 指定创建对象的函数。 continue 语句 停止循环的当前迭代,并开始一次新的迭代。 cos 方法 返回一个数的余弦。 Date 对象 提供日期和时间的基本存储和检索。...
  • 微软JavaScript手册

    2009-04-08 22:54:53
    :) 根据条件执行两个表达式之一。 constructor 属性 指定创建对象的函数。 continue 语句 停止循环的当前迭代,并开始一次新的迭代。 cos 方法 返回一个数的余弦。 Date 对象 提供日期和时间的基本存储和检索。...
  • Zut_round 7(二分答案)

    2020-04-24 08:28:50
    二分答案的基本思路,对所求数值的所在范围进行二分查找,对特定数值进行判断是否符合要求。 但是难点在于f(x)函数,要根据题目来写。 A - 二分(经典题)(*)(最大化最小值) fun函数内贪心判断,设两个指针,找到...

    题目链接:(https://vjudge.net/contest/368387#problem)
    **

    二分答案其实就是在已知条件下又增加了一个条件

    **
    二分答案的基本思路,对所求数值的所在范围进行二分查找,对特定数值进行判断是否符合要求。
    但是难点在于f(x)函数,要根据题目来写。

    A - 二分(经典题)(*)(最大化最小值)
    fun函数内贪心判断,设两个指针,找到最近的前面的不小于后面的位置坐标,,M-1头牛全部找到即可。

    #include <iostream>
    #include<algorithm>
    using namespace std;
    
    int n,c;
    int a[100005];
    bool fun(int x){
        int t1=0;
        for(int i=1;i<c;i++){
            int t2=t1+1;
            while(t2<n&&a[t2]-a[t1]<x){//在有解范围内没找到解
                t2++;
            }
            if(t2==n){
                return false;
            }
            t1=t2//找到的话进行位置的更新
        return true;
    }
    int main()
    {
        cin>>n>>c;
        for(int i=0;i<n;i++){
            cin>>a[i];
        }
        sort(a,a+n);
        int minn=0,maxx=a[n-1],mid;
        while(maxx-minn>1){
            mid=(maxx+minn)/2;
            if(fun(mid))
                minn=mid;
            else
                maxx=mid;
        }
        cout<<minn<<endl;
        return 0;
    }

    B - 二分(*)

    #include <iostream>
    #include<bits/stdc++.h>
    using namespace std;
    char a[200005],b[200005];
    int del[200005],vis[200005];
    int la,lb;
    int fun(int mid){
        memset(vis,0,sizeof(vis));
        for(int i=0;i<=mid;i++){
            vis[del[i]-1]=1;
        }
        int now=0;
        for(int i=0;i<la;i++){
            if(vis[i]==0){
                if(a[i]==b[now]){
                    now++;
                }
            }
        }
        if(now==lb) return 1;
        else return 0;
    }
    int main()
    {
        cin>>a;
        cin>>b;
        la=strlen(a);lb=strlen(b);
        for(int i=0;i<la;i++){
            cin>>del[i];
        }
        int ans=-1,l=0,r=la-1;
        while(r-l>=0){
            int mid=(l+r)/2;
            if(fun(mid)==1){
                l=mid+1;
                ans=mid;
            }
            else{
                r=mid-1;
            }
        }
        cout<<ans+1<<endl;
        return 0;
    }

    D - Snowball
    直接模拟一遍

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        int w,h,u1,d1,u2,d2;
        cin>>w>>h>>u1>>d1>>u2>>d2;
        for(int i=h;i>0;i--){
            w+=i;
            if(i==d1)
                w-=u1;
            else if(i==d2)
                w-=u2;
            if(w<0)
                w=0;
        }
        cout<<w<<endl;
        return 0;
    }

    E - Squares and Segments
    长与宽越接近,可以使得面积最大,长与宽的和最小。
    所以比较长宽的大小,小的那个进行加一处理。

    #include <iostream>
    
    using namespace std;
    int n,w=1,h=1;
    int main()
    {
        cin>>n;
        while(w*h<n){
            if(w<h)
                w++;
            else
                h++;
        }
        cout<<w+h<<endl;
        return 0;
    }
    展开全文
  • C#.net_经典编程例子400

    热门讨论 2013-05-17 09:25:30
    256 实例175 清空回收站 257 6.2 查找文件 258 实例176 搜索文件 259 实例177 检查文件是否存在 260 实例178 提取指定文件夹目录 261 6.3 修改文件 261 实例179 更改文件名称 ...
  • 二叉排序树:是一种树,我们用这种结构存储数据 那么什么才算二叉排序树?   ...* 并且根节点的左右子树都要满足上面两个条件才称为二叉排序树 * 根据前两个性质可得二叉排序树不能有重复数值...

    二叉排序树:是一种树,我们用这种结构存储数据

    那么什么才算二叉排序树?

     

    二叉排序树:
    * 特点:又称为二叉查找树,要么是一个空树要么符合下面列性质
    * 若左子树不为空,则左子树上的所有节点的值均小于它的根结构的值
    * 若右子树不为空,则右子树上的所有节点的值均大于它的根结构的值
    * 并且根节点的左右子树都要满足上面两个条件才称为二叉排序树
    * 根据前两个性质可得二叉排序树不能有重复数值
    * 这个树因为左边都是小数,中间都是中数,右边都是大数,所以我们直接通过中序遍历便可按顺序输出
    * 目的:为了提高查找和插入删除关键字的速度

    所有的步骤全在代码中写了,直接贴代码。

    package sorttree;
    
    
    import org.omg.Messaging.SYNC_WITH_TRANSPORT;
    
    import java.util.ArrayList;
    import java.util.List;
    
    //二叉排序树
    /*二叉排序树:
    * 特点:又称为二叉查找树,要么是一个空树要么符合下面列性质
    * 若左子树不为空,则左子树上的所有节点的值均小于它的根结构的值
    * 若右子树不为空,则右子树上的所有节点的值均大于它的根结构的值
    * 并且根节点的左右子树都要满足上面两个条件才称为二叉排序树
    * 根据前两个性质可得二叉排序树不能有重复数值
    * 这个树因为左边都是小数,中间都是中数,右边都是大数,所以我们直接通过中序遍历便可按顺序输出
    * 目的:为了提高查找和插入删除关键字的速度
    *
    * 创建的算法我想了很久:这里说下它和创建普通二叉树的区别
    *普通二叉树:创建时递归一次建立一个
    *排序二叉树:它必须递归找到它该放的位置才建立
    * */
    
    class TreeNode{
        int data;//数据域
        TreeNode leftNode;//左子树
        TreeNode rightNode;//右子树
    }
    
    
    
    public class SortTree {
        static TreeNode treeNode = new TreeNode();//设置根节点为类变量。
        static TreeNode cordNode = new TreeNode();//设置记录节点为类变量。
    
        public static void main(String[] args) {
            int i;
            int[] sort = new int[]{42, 12, 23, 64, 74, 34, 76, 24, 53, 63, 6};//建立一个普通数组:
            //TreeNode treeNode = new TreeNode();//设置根节点
            treeNode.data = sort[0];//初始化根节点是数组第一个数
            TreeNode parNode = new TreeNode();//设置记录双亲的节点
            //TreeNode cordNode = new TreeNode();//设置记录最后的节点
            for (i = 1; i < sort.length; i++)//对sort的所有元素进行排序,前面已经对第一个数赋值了,直接从第二个数开始操作
                createSortTree(sort[i], treeNode);
            printTree(treeNode);//中序遍历输出
            System.out.println(" ");
            searchRorF(treeNode, 25, parNode, cordNode);//查找顺序二叉树的点
            // treeNode = insert(treeNode, 13);//第一种插入调用语句
            treeNode = insert(treeNode, 13, cordNode);
            printTree(treeNode);//中序遍历输出
            System.out.println(" ");
            treeNode=deletBST(treeNode,treeNode,42);
            printTree(treeNode);
        }
    
        //需求:每次只确定sort数组中的一个单元,,对这个单元排序,
        public static void createSortTree(int i, TreeNode treeNode) {//完成一个无序数列到一个二叉排序树的建立
            /*建立思想:先选取第一个数字为根节点,依次读取顺序表的内容,将大于这个节点放在右子树,小于节点的放在左子树
             * 通过循环遍历每个数,对这个数按照要求一直遍历整个树,直到找到适合它的位置,循环结束创建完成
             *
             * 参数:int[] sortTree用户输入的列表,获得
             * */
    
            if (i < treeNode.data)//判断节点是否小于当前根节点,是的话向左子树遍历
            {
    
                if (treeNode.leftNode == null) {//如果没有左子树,就要连接
                    TreeNode treeNode1 = new TreeNode();
                    treeNode1.data = i;
                    treeNode.leftNode = treeNode1;
    
                } else {
                    createSortTree(i, treeNode.leftNode);
                }
            } else if (i > treeNode.data)//判断节点是否大于当前根节点,是的话向右子树遍历
            {
    
                if (treeNode.rightNode == null) {//如果没有右子树,就要连接
                    TreeNode treeNode1 = new TreeNode();
                    treeNode1.data = i;
                    treeNode.rightNode = treeNode1;
                } else {
                    createSortTree(i, treeNode.rightNode);
                }
            }
    
    
        }
    
        public static void printTree(TreeNode treeNode) {//中序输出顺序二叉树 ,接受参数为排好序的二叉树顶点,
            if (treeNode != null) {//如果递归到的节点为空,结束这层递归,返回上一次递归执行
                printTree(treeNode.leftNode);//先一直搜寻左节点到最底部,当递归到底部的下一个节点时为空,我们通过最外层的控制语句结束这层递归
                System.out.print(treeNode.data + " ");//当上面的那层递归结束到了这里说明当前节点是最后一个节点,输出这个节点便是最底层的左节点
                printTree(treeNode.rightNode);//开始递归查询它的右节点,直到查到空为止
            }
        }
    
    
        public static boolean searchRorF(TreeNode treeNode, int num, TreeNode parNode, TreeNode cordNode) {
            if (treeNode == null)//第一次传进来判断传入的数是否为空,为空则直接返回false结束查找,之后传进来如果为空也说明找完了并没找到那个数
            {
                cordNode = parNode;//如果没找到,将双亲结点赋值给记录节点
    
                return false;//返回false
    
            } else if (treeNode.data == num)//再判断传入的点是否等于treeNode的data,如果相等则返回true退出。
            {
                cordNode = treeNode;//如果找到,则赋值给找到的节点
                System.out.println("找到了要查找的数据");
                return true;
            } else if (num < treeNode.data) { //如果传入值小于当前结点数据,则去它的左子树查找。
                return searchRorF(treeNode.leftNode, num, treeNode, cordNode);
            } else { //如果传入值大于当前结点数据,则去它的右子树查找。
                return searchRorF(treeNode.rightNode, num, treeNode, cordNode);
            }
        }
    
        //第三种方法把存储结点设置为全局变量,就不实现了,因为还要改seach的方法
    
    //第二种方法:insert里直接包含了查找位置的代码,这样可以直接获得记录节点,但是无法使用递归,只能使用迭代循环操作
        //参数说明
        public static TreeNode insert(TreeNode treeNode, int num, TreeNode cordNode) {
            TreeNode insNode = new TreeNode();//初始化要插入的节点,
            TreeNode operaNode;//操作用的点
            operaNode=treeNode;//把根结点赋值给操作点,让操作点进行操作,保留根节点,最后返回
            insNode.data = num;//赋值
            if (operaNode == null) {//如果根节点为空直接将值赋给根节点
                operaNode = insNode;
                return treeNode;//完成操作返回这个数
            }
            while (operaNode != null) {//当节点为空时说明到了这个结点该插入的位置了
                if (operaNode.data == num)//如果相等,则退出,不允许有重复值
                    return treeNode;//相等返回没操作的根节点就行了
                else if (num < operaNode.data) {//如果查询数小于当前结点数
                    cordNode = operaNode;//先记录父节点
                    operaNode = operaNode.leftNode;//向左子树查询
                } else {//如果查询数大于当前结点
                    cordNode = operaNode;//先记录父节点
                    operaNode = operaNode.rightNode;//向右子树查询
                }
            }
            //循环完就得到了这个该插入的位置
            //判断插入到哪里
            System.out.println("插入"+cordNode.data);
            if (num < cordNode.data) {//小于的话插入左子树
                cordNode.leftNode = insNode;
            } else {
                cordNode.rightNode = insNode;
                }
                return treeNode;
        }
    
    
    /*删除算法的思路:
    先通过递归找到要删除的元素
    *要删除的结点如果只有左子树,删除这个点后连接左子树
    *要删除的结点如果只有右子树,删除这个点后连接右子树
    * 要删除的结点如果有左右子树,找到它的大于它的最小结点或者小于它的最大结点,然后替换,再删除结点,这时候这个结点的位置只有左或者右子树,再连接左右子树就行了
    * 在中序遍历中他们三个结点相邻,所以选择他们替换不会对序列有任何影响
    * */
    /**
     * rootNode再这里设置是因为最后要返回根节点
     *treeNode在这里设置是操作的结点
     * 算法思路:
     * 先找到要删除的点,没找到的话就直接退出,找到的话通过delet函数进行删除
     *
     ***/
    
    public static TreeNode deletBST(TreeNode rootNode,TreeNode treeNode,int num) {
        if (num != treeNode.data) {//如果没找到则结束
            return rootNode;
        }
            else{
                if(num==treeNode.data)//找到就进行删除操作
                    return delete(rootNode,treeNode);
            else if (num < treeNode.data) {//如果小于去左子树
                    return deletBST(rootNode,treeNode.leftNode,num);
                }
                else
                   return deletBST(rootNode,treeNode.rightNode,num);
                //如果小于去右子树
            }
        }
    
    //删除操作思路:
    //先判断是否只有左右子树,有的话直接删除
    //如果左右子树都有,我们找到小于要删除点的最大结点记为max
    //这个max点便是要删除点的下一个左结点的右子树的最后一个右结点
    //如果max点有右子树 ,那么要拼接替换删除后的右子树
    //如果max点只有左子树没有右子树,那么所找的点max只有左子树,替换后拼接左子树就好
    public static TreeNode delete(TreeNode rootNode,TreeNode treeNode){
        TreeNode operaNode;//用作这个节点向下遍历最后得到max结点,传进来的结点并不动
        TreeNode cordNode;//这个节点用来记录max结点的前驱,功能代码中会讲
                    if(treeNode.rightNode==null) {//如果只有左子树
                        treeNode = treeNode.leftNode;//拼接
                        return rootNode;
                    }
                   else if (treeNode.leftNode==null) {//只有右子树
                        treeNode = treeNode.rightNode;//拼接
                        return rootNode;
                    }
                   else {//如果左右子树都有,先找到那个max点,就是要删除结点的下一个左结点的最右结点
                          cordNode=treeNode;//先将传入结点赋给操作结点以便进行接下来的操作
                          operaNode=treeNode.leftNode;//先获得要删除结点的左结点,
                        while(operaNode.rightNode!=null){//一直查找左结点的最后一个右结点,这个循环结束后,得到的opera为max结点
                            //保存当前结点为前驱节点后,向右子树继续遍历
                            cordNode=operaNode;
                            operaNode=operaNode.rightNode;
                        }
                        treeNode.data=operaNode.data;//把查到的max的值覆盖到要删除节点
                        if (cordNode!=treeNode){//如果前驱结点不等于删除位置结点,说明刚开始的要删除的结点的左结点有右结点,这是max是最后一个右结点,并没有右子树
                            cordNode.rightNode=operaNode.leftNode;//我们把max结点的左子树赋值给前驱结点的右子树后,相当于去除了这个结点
                            return rootNode;
                        }else {//到这步说明刚开始的要删除的结点的左结点没右结点,我们只需要将左子树拼接就好
                            cordNode.leftNode = operaNode.leftNode;
                            return rootNode;
                        }
                    }
    }
    }
    
    这里补充java是可以通过对象参数传递的
    
    
    //第一种:两个查找法。我又写了一个seach方法,专门返回记录的结点,通过两个seach方法结合使用
        //先通过返回boolean值的seach方法来确定是否有相同值,再通过返回记录结点的seach方法返回记录结点。
        //然后进行判断插入操作
    
    
        /// /顺序二叉树数的查找。接受一个数字,每次判断它是大于还是小于当前点,如果大于去这个点的右子树寻找,如果小于到这个数的左子树寻找
        // 直到最后判断了所有的点
        //参数说明:
        // TreeNode treeNode:根节点   int num:查找的数
        //  TreeNode parNode:记录双亲节点用  TreeNode cordNode最后返回的节点(如果没找到就是最后查找的哪个null节点的双亲,找到的话就是找到的那个元素)
        //  一开始parnode为null,因为根节点没有双亲结点
    //    public static  TreeNode searchNode(TreeNode treeNode,int num,TreeNode parNode,TreeNode cordNode){
    //        if(treeNode==null)//第一次传进来判断传入的数是否为空,为空则直接返回false结束查找,之后传进来如果为空也说明找完了并没找到那个数
    //         {
    //             cordNode=parNode;//如果没找到,将双亲结点赋值给记录节点
    //             System.out.println("没找到要查找的数据");
    //            return cordNode;//返回记录结点
    //
    //        }
    //       else if(treeNode.data==num)//再判断传入的点是否等于treeNode的data,如果相等则返回true退出。
    //        {
    //            cordNode=treeNode;//如果找到,则赋值给找到的节点
    //            System.out.println("找到了要查找的数据");
    //            return cordNode;
    //        }
    //         else     if (num<treeNode.data) { //如果传入值小于当前结点数据,则去它的左子树查找。
    //            return searchNode(treeNode.leftNode, num,treeNode,cordNode);
    //        }
    //        else     { //如果传入值大于当前结点数据,则去它的右子树查找。
    //            return searchNode(treeNode.rightNode,num,treeNode,cordNode);
    //        }
    //        }
            /*方法说明:
            * 方法思路:先查找节点,如果查找到不操作,因为排序二叉树不允许有重复数字
            *   没查找到节点,这时cordTree会返回查到最后返回的空节点的双亲节点,也就是我们要插入的地方
            *   如果这个记录节点为null,说明排序二叉树为空,当作根节点使用
            *   如果这个值小于当前记录节点,当作cord的左子树
            *   如果这个值大于当前记录节点,当作cord的右子树
            * 方法参数:接受排序二叉树根节点和要插入的数
            * */
    //        public static TreeNode insert(TreeNode treeNode,int ins){
    //            TreeNode parNode=new TreeNode();//设置记录双亲的节点
    //            TreeNode cordNode=new TreeNode();//设置最后获得元素的节点
    //            TreeNode insNode=new TreeNode();//初始化要插入的节点
    //            insNode.data=ins;//赋值
    //            if(!searchRorF(treeNode,ins,parNode,cordNode)) {//先查找节点,如果查找到不操作,因为排序二叉树不允许有重复数字
    //                cordNode=searchNode(treeNode,ins,parNode,cordNode);
    //                if (cordNode == null)  //如果这个记录节点为null,说明排序二叉树为空,当作根节点使用
    //                    treeNode = insNode;//将这个要插入的结点当作根结点
    //                else if (ins < cordNode.data) { //如果这个值小于当前记录节点,当作cord的左子树
    //                    cordNode.leftNode = insNode;
    //                }
    //                else  {   //如果这个值大于当前记录节点,当作cord的右子树
    //                    cordNode.rightNode = insNode;
    //                }
    //                return treeNode;
    //            }else {
    //                return treeNode;//有关键字退出
    //            }
    //        }
    // }

     

    创建的算法我想了很久:这里说下它和创建普通二叉树的区别
    普通二叉树:创建时递归一次建立一个
    排序二叉树:它必须递归找到它该放的位置才建立

     

     

    这里着重说下插入方法,我看的大话结构里用的是c语言可以直接用指针操作地址,因此可以在插入操作里直接调用查询操作找到记录点进行插入,而java无法直接操作地址,只能通过返回值,问题在于返回值只能返回一个,我既需要查询里判断是否查到的false/true值,又需要记录结点,所以这条路走不通。

    我想了三种办法:
    1.最简单的方法,修改根结点和记录节点都为全局变量,这样就可以直接在函数里对结点进行操作。
    2.写两个查询方法,一个返回true/false,另一个返回记录结点,通过两个返回值便可进行操作,但是时间复杂度很高
    3.可以把查询的方法融入到insert的方法,这样不用再查询一次,提高程序效率。

    展开全文
  • 训练总结 9.10

    2017-09-10 22:43:56
    周末场比赛,周六比赛做了三道题,有一道是寻找滑雪的...还有一道题没有做出来,根据公式查找符合条件的最小值,数值很大,但是符合要求的数很少,才23,可以先写程序,for循环打表输出,然后再列数组,根据题意
  • 第二种思路根据数组的特点,出现次数超过一半的数,他出现的次数比其他数字出现的总和还要多,因此可以最开始保存两个数值:数组中的一个数字以及它出现的次数,然后遍历,如果下一个数字等于这个数字,那么次数加一...
  • 4.2.3 OR——判断多个条件中是否至少有一个条件成立 155 4.2.4 XOR——判断多个条件中是否有一个条件成立 156 4.2.5 IF——根据条件判断而返回不同结果 156 4.2.6 IFNA——判断公式是否出现#N/A错误 158 4.2.7 ...
  • EXCEL函数功能整理版

    2010-05-30 15:56:24
    18 AND 这个函数用于检验两个或更多(最多30个)条件,看它们是否都为TRUE. 19 CELL 返回某一引用区域的左上角单元格的格式、位置或内容等信息。 20 CEILING 这个函数可以根据用户要求把一个数字向上...
  • 210 根据员工编号或者姓名查找提成工资 403 211 根据员工姓名和编号查找员工信息 406 212 根据职务和工龄计算年限工资 408 213 根据产品名称的拼音生成产品编号 410 214 根据本月收入查询应采用税率和速算...
  • VBSCRIPT中文手册

    热门讨论 2010-11-12 10:13:06
    And 运算符 执行两个表达式的逻辑连接。 Array 函数 返回含一数组的 变体 。 Asc 函数 返回字符串首字母的 ANSI 字符代码。 赋值运算符 (=) 给变量或属性赋值。 Atn 函数 返回数的反正切值。 调用语句 将控制...
  • vb Script参考文档

    2009-07-28 22:13:02
    And 运算符 执行两个表达式的逻辑连接。 Array 函数 返回含一数组的 变体 。 Asc 函数 返回字符串首字母的 ANSI 字符代码。 赋值运算符 (=) 给变量或属性赋值。 Atn 函数 返回数的反正切值。 调用语句 将控制...
  • EXCEL 2007 宝典 附光盘文件

    热门讨论 2010-04-02 14:43:05
    weather combination chart.xlsx:一个演示使用两个数值轴的合并图表的工作簿。 Chapter 21 daily staffing levels.xlsx:一个演示设置条件格式的颜色刻度的工作簿。 conditional formatting formulas.xlsx:一个...
  • • 使用两个一维数组构造二维数组 • 部门评价等级转换 • 使用MMULT 函数计算产品结构指数 • 产生1-10 的自然数垂直序列和水平序列 • 等比例构造一维循环数组 • SUMIF函数对产品产量进行逐行汇总 • 利用MMULT...
  • @If 判定一个条件 @Implode 连接文本列表中的成员,并返回文本字符串 @InheritedDocumentUniqueID 当前文档继承的父文档的唯一标识符 @Integer 将数字或数字列表截断成一个整数,去掉其小数部分 @IsAgentEnabled ...
  • 8.1写两个函数,分别求两个整数的最大公约数和最小公倍数,用主函数调用这两个函数,并输出结果,两个整数由键盘输入。 47 8.2 47 8.3写一个判素数的函数,在主函数输入一个整数,输出是否素数的信息。 49 8.4写一...
  • 140.计算两个日期之间相隔的年份,比如年龄,工龄等.可计算从1000年01月01日起的日期 141.从字符串提取纯数字 142.将一个数组按升序排列 143.将一个数组按降序排列 144.删除空白列 145.判断工作表是否为空白 146.将...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 208
精华内容 83
关键字:

根据两个条件查找数值