算法4——BinarySearch系列

最新推荐文章于 2024-04-23 18:52:22 发布
最新推荐文章于 2024-04-23 18:52:22 发布
阅读量285 收藏
点赞数
文章标签： java 开发工具 python
原文链接：https://my.oschina.net/duoduo3369/blog/142384
版权

1 白名单过滤

问题描述：

    想象有一家信用卡公司，需要检查用户的交易账号是否有效，为此，他需要：

  1. 将客户的账号保存到一个文件中，我们称它为白名单；
  2. 从标准输入中得到每笔交易的账号；
  3. 使用这个测试用例在标准输出中打印所欲与任何账户无关的账号，公司可能拒绝侧类交易。

将白名单排序后，二分查找

画图与控制台的实现如下（没用之前准备工作的DrawArray，以为那个封装的还不是很好），输入为官网提供的两个文件，eclipse配置如下：data\tinyW.txt data\tinyT.txt 

package com.duoduo.algs4.Fundamentals;

import java.awt.Color;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

import com.duoduo.algs4.util.RedirectStream;
import com.duoduo.std.DrawArray;

import edu.princeton.cs.introcs.Draw;
import edu.princeton.cs.introcs.In;
import edu.princeton.cs.introcs.StdIn;
import edu.princeton.cs.introcs.StdOut;

public class BinarySearch {

	// precondition: array a[] is sorted
	public static int rank(int key, int[] a) {
		int lo = 0;
		int hi = a.length - 1;
		while (lo <= hi) {
			// Key is in a[lo..hi] or not present.
			int mid = lo + (hi - lo) / 2;
			if (key < a[mid])
				hi = mid - 1;
			else if (key > a[mid])
				lo = mid + 1;
			else
				return mid;
		}
		return -1;
	}

	public static double X_DOWN = 0.5;
	public static double Y_DOWN = 200;

	public static Draw DrawArray(int[] a, int loc, Draw draw) {
		return DrawArray(a, X_DOWN, Y_DOWN, loc, draw);
	}

	public static Draw DrawArray(int[] a, double X_DOWN, double Y_DOWN,
			int loc, Draw draw) {
		int N = a.length;

		double x = 1.0 * loc / N;
		double y = a[loc] / Y_DOWN;
		double rw = X_DOWN / N;
		double rh = a[loc] / Y_DOWN;
		draw.setPenColor(Color.RED);
		draw.filledRectangle(x, y, rw, rh);
		draw.setPenColor();
		return draw;
	}

	public static void testConsole(String whiteListName,String guestListName) throws IOException {
		StdOut.println("console");
		int[] whiteList = In.readInts(whiteListName);
		FileInputStream fis = RedirectStream.redirectFileToStdin(guestListName);
		Arrays.sort(whiteList);
		while (!StdIn.isEmpty()){
			int key = StdIn.readInt();
			if(rank(key, whiteList) == -1)
				StdOut.println(key);
			
		}
		if(fis!=null){
			fis.close();
		}
		
	}
	public static void testDraw(String whiteListName,String guestListName) {
		StdOut.println("testDraw");
		int[] whitelist = In.readInts(whiteListName);
		int[] guestlist = In.readInts(guestListName);

		Arrays.sort(whitelist);
		Draw draw1 = DrawArray.DrawArray(whitelist, X_DOWN, Y_DOWN,"白名单");
		Draw draw2 = DrawArray.DrawArray(guestlist, X_DOWN, Y_DOWN,"黑名单");
		int local;
		int key;
		int N = guestlist.length;
		for (int i = 0; i < N; i++) {
			key = guestlist[i];
			local = rank(key, whitelist);
			// 白名单中匹配了多少条，以及黑名单有多少条没被匹配。
			if (local == -1) {
				StdOut.println(key);
				//guest中下标为i的元素不在白名单中
				DrawArray(guestlist, i, draw2);
			} else {
				DrawArray(whitelist, local, draw1);

			}
		}
	}
	public static void main(String[] args) throws IOException {
		testDraw(args[0],args[1]);
		testConsole(args[0],args[1]);

		

	}
}
运行结果：

控制台输出： 

testDraw
50
99
13
console
50
99
13
图形结果

防止溢出 

int mid = lo + (hi - lo) / 2;

2 将rank改为递归（1），打印递归深度，以及lo和hi

    打印深度是加了一个deeps保存深度值： 

package com.duoduo.algs4.Fundamentals;

import java.awt.Color;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

import com.duoduo.algs4.util.RedirectStream;
import com.duoduo.std.DrawArray;

import edu.princeton.cs.introcs.Draw;
import edu.princeton.cs.introcs.In;
import edu.princeton.cs.introcs.StdIn;
import edu.princeton.cs.introcs.StdOut;

public class BinarySearchRecursion {

	public static int rank(int key, int[] a) {
		//打印深度
		return rank(key, a, 0, a.length - 1, 0);
		//不打印深度
		// return rank(key, a, 0, a.length - 1);

	}

	public static int rank(int key, int[] a, int lo, int hi) {
		if (lo > hi) {
			return -1;
		}
		int mid = lo + (hi - lo) / 2;
		if (key == a[mid]) {
			return mid;
		} else if (key < a[mid]) {
			hi = mid - 1;
		} else {
			lo = mid + 1;
		}
		return rank(key, a, lo, hi);
	}

	// 打印递归深度 P35 1.1.22
	public static int rank(int key, int[] a, int lo, int hi, int deeps) {
		StdOut.println("此次递归的深度为:" + deeps + " lo:" + lo + " hi:" + hi);
		if (lo > hi) {
			return -1;
		}
		int mid = lo + (hi - lo) / 2;
		if (key == a[mid]) {
			return mid;
		} else if (key < a[mid]) {
			hi = mid - 1;
		} else {
			lo = mid + 1;
		}
		return rank(key, a, lo, hi, deeps + 1);
	}

	public static void testConsole(String whiteListName, String guestListName)
			throws IOException {
		int[] whiteList = In.readInts(whiteListName);
		FileInputStream fis = RedirectStream.redirectFileToStdin(guestListName);
		Arrays.sort(whiteList);
		while (!StdIn.isEmpty()) {
			int key = StdIn.readInt();
			if (rank(key, whiteList) == -1)
				StdOut.println(key);

		}
		if (fis != null) {
			fis.close();
		}

	}

	public static void main(String[] args) throws IOException {

		testConsole(args[0], args[1]);

	}
}

运行结果 

此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:0 hi:6
此次递归的深度为:2 lo:4 hi:6
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:8 hi:10
此次递归的深度为:3 lo:10 hi:10
此次递归的深度为:4 lo:10 hi:9
50
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:0 hi:6
此次递归的深度为:2 lo:0 hi:2
此次递归的深度为:3 lo:0 hi:0
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:3 lo:14 hi:15
此次递归的深度为:4 lo:15 hi:15
此次递归的深度为:5 lo:16 hi:15
99
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:0 hi:6
此次递归的深度为:2 lo:4 hi:6
此次递归的深度为:3 lo:4 hi:4
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:0 hi:6
此次递归的深度为:2 lo:4 hi:6
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:3 lo:14 hi:15
此次递归的深度为:4 lo:15 hi:15
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:3 lo:14 hi:15
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:0 hi:6
此次递归的深度为:2 lo:0 hi:2
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:0 hi:6
此次递归的深度为:2 lo:0 hi:2
此次递归的深度为:3 lo:0 hi:0
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:8 hi:10
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:0 hi:6
此次递归的深度为:2 lo:0 hi:2
此次递归的深度为:3 lo:2 hi:2
此次递归的深度为:4 lo:3 hi:2
13
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:8 hi:10
此次递归的深度为:3 lo:10 hi:10
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:3 lo:14 hi:15
此次递归的深度为:4 lo:15 hi:15
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:0 lo:0 hi:15
此次递归的深度为:1 lo:8 hi:15
此次递归的深度为:2 lo:12 hi:15
此次递归的深度为:3 lo:12 hi:12

3 删除重复元素

  •  步骤1：排序
  •  步骤2：二分搜索[i+1,...n]
  •  步骤3：如果不存在，加入新数组，如果存在，go next
    （做这玩意儿的时候就感觉python的数组可以切片真是幸福啊） 
package com.duoduo.algs4.Fundamentals;

import java.io.IOException;
import java.util.Arrays;

import com.duoduo.algs4.util.ArrayUtil;

import edu.princeton.cs.introcs.In;
import edu.princeton.cs.introcs.StdOut;

public class RemoveDuplicateElement {
	// 删除重复元素

	// 步骤1：排序
	// 步骤2：二分搜索[i+1,...n]
	// 步骤3：如果不存在，加入新数组，如果存在，go next
	public static int[] removeDuplicateElement(int[] a) {
		int M = a.length;
		if (M <= 0) {
			return null;
		}
		int[] b = new int[M];
		int index = 0;

		int hi = M - 1;
		int lo, key;
		for (int i = 0; i < M; i++) {
			lo = i + 1;
			key = a[i];
			if (-1 == BinarySearch.rank(key, a, lo, hi)) {
				b[index++] = key;
			}

		}
		// 剔除掉0
		int[] result = b;
		if (index < M) {
			result = new int[index];
			for (int i = 0; i < index; i++) {
				result[i] = b[i];
			}
			b = null;
		}
		return result;

	}

	public static void testConsole(String whiteListName) {
		StdOut.println("console");
		int[] whiteList = In.readInts(whiteListName);

		Arrays.sort(whiteList);
		int[] afterRemove = removeDuplicateElement(whiteList);
		ArrayUtil.printArray(whiteList);
		ArrayUtil.printArray(afterRemove);
	}

	public static void main(String[] args) {
		testConsole(args[0]);
	}

}
运行结果 
console
数组为:
10 10 11 13 18 23 23 48 50 54 68 77 77 77 84 98 98 99 
数组为:
10 11 13 18 23 48 50 54 68 77 84 98 99

使用data\largeT.txt （6.67M）,不知道是不因因为数组太大还是怎么回事儿，输出一闪而过

测试方法 

public static void testConsole(String whiteListName) {
		StdOut.println("console");
		int[] whiteList = In.readInts(whiteListName);

		Arrays.sort(whiteList);
		int[] afterRemove = removeDuplicateElement(whiteList);
		StdOut.println("print");
		StdOut.println(whiteList.length);
		StdOut.println(afterRemove.length);
		
		ArrayUtil.printArray(whiteList);
		ArrayUtil.printArray(afterRemove);
	}
public static void printArray(int[] a){
		int M = a.length;
		StdOut.println("数组为:");
		for (int i = 0; i < M; i++) {
			StdOut.print(a[i] + " ");
		}
		StdOut.println();
	}

注释掉ArrayUtil.printArray后输出
console
print
1000000
631959


转载于:https://my.oschina.net/duoduo3369/blog/142384

chitudai8716
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
4 Divide and Conquer_binarysearch_源码
10-04
二分查找，多种二分查找的例子和方法。最后一种算法的时间复杂度最小。
简单实用算法——二分查找法（BinarySearch）
chinaherolts2008的博客
01-03 3850
算法概述# 二分查找（英语：binary search），也叫折半查找（英语：half-interval search），是一种在有序数组中查找特定元素的搜索算法。所以，二分查找的前提是数组必须是有序的。 时间复杂度、空间复杂度请参照下图（图片来自wikipedia）： 适用情况# 二分查找只适用顺序存储结构。为保持表的有vb.net教程序性，在顺序结构里插入和删除都必须移动大量的结点。因此，二分查找特别适用于那种一经建立就很少改动、而又经常需要查找的线性表。 对那些查找少而又经常需要改动的线性表，可采用
算法---二分算法
qq_57229058的博客
03-26 5753
详解二分查找算法 Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky… 思路很简单，细节是魔鬼。 一：二分法算法分析 1、二分查找算法定义 二分查找又称折半查找，它是一种效率较高的查找方法。 二分查找要求：线性表是有序表，即表中结点按关键字有序，并且要用向量作为表的存储结构。 2、基本思想 （1）首先确定该区间的中点位置 （2）将
【算法】二分搜索
代码星辰的博客
01-07 3257
本文对二分搜索算法进行了详细地介绍，包括概述、代码实现和应用。
二分查找算法（BinarySearch）
程序袁的CSDN
05-22 770
Java语言实现二分查找算法。
BinarySearch(二分查找）
MADE_Y
10-04 1860
//二分查找 package Algorithms; import java.util.Arrays; import edu.princeton.cs.algs4.In; import edu.princeton.cs.algs4.StdIn; import edu.princeton.cs.algs4.StdOut; public class P28_BinarySearch { pu
Java binarysearch方法原理详解
08-25
主要介绍了Java binarysearch方法原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
BST.zip_binary search tree
09-23
CpluPlus code for a Text & command based Binary Search Tree Has a menu and base function. Complete but simple
BinarySearch_C++_算法_折半查找_
10-04
这是一个用c++做的简单的折半查找算法，在递增的序列数组中，找到对应的数字的位置
二分查找算法BinarySearch.rar
11-26
安徽大学本科课程《算法设计与分析》实验二《二分查找算法BinarySearch》，包括.m文件和实验报告。
BinarySearch
04-02
NULL 博文链接：https://enria.iteye.com/blog/1441105
西工大算法分析二分查找(BinarySearch)
05-01
描述： 给定一个单调递增的整数序列，问某个整数是否在序列中。 输入： 第一行为一个整数n，表示序列中整数的个数；第二行为n（n不超过10000）个整数；第三行为一个整数m（m不超过50000），表示查询的个数；接下来m行每行一个整数k。 输出： 每个查询的输出占一行，如果k在序列中，输出Yes，否则输出No。
运行《算法》第四版的BinarySearch
oldwangold的博客
04-15 446
开始学习《算法》第四版，但环境搭建费了很久时间，终于找到了这篇，使用方法三进行实验，搭建成功。目前先按照这么做，后来如果有更好的方法，再进行添加。 原文地址：https://blog.csdn.net/sinat_41104353/article/details/81028672 ...
如何让《算法》（第4版）的BinarySearch跑起来
Kazama_Kenji的博客
09-10 3913
首先进入书本的网站 http://algs4.cs.princeton.edu/home/ 因为BinarySearch.java是第一章的一个程序，所以进入第一章的网址 你首先需要准备一下： 1.
关于《算法（第四版 谢路云译）》标准库In、Out、StdOut和StdIn的正确配置和调用经验分享（以BinarySearch二分查找算法为例）
ys875038467的博客
12-27 9889
本人初学《算法（第四版 谢路云译）》有一段时间了，对于初学者按书敲完第一个BinarySearch二分查找算法发现运行错误，我相信大家跟我一样内心是崩溃的。还好经过翻看多个相关论坛以及自己不断尝试最终调通了代码，在此我想把自己的经验分享给想学习算法和数据结构的大家，希望大家看完能有收货少走一些弯路。(第一次写博客，如有不详，见谅，请大牛们不要客气在评论区指正补充。)1.确保Java环境配置正确（适
揭开算法（第四版）BinarySearch神秘面纱
weixin_44967898的博客
10-25 286
揭开算法（第四版）BinarySearch神秘面纱 BinarySearch类的rank方法实现二分法查找，当我们在idea中编写它的main方法的时候发现In.readInts这里报错，那是因为我们缺少algs4.jar，下载地址如下： https://algs4.cs.princeton.edu/code/ 在jdk.1.8中，Arrays.binarySearch(数组名，key)，帮助我们实现了二分法查找功能。我们知道二分法查找，必须是有序的，所以我们在用BinarySearch的rank还是Arr
binarySearch
计算机系秃头少女的博客
11-23 117
版本A Rank mi = (lo + hi) >> 1; if (e < A[mi]) hi = mi; else if (A[mi] < e) lo = mi + 1; else return mi; 版本B while (1 < hi-lo){ Rank mi = (lo + hi) >> 1; (e < A[mi]) ? hi = mi : lo = mi;//深入[lo, mi) || [mi, hi
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 485
都是符合我们的预期的。
binary——seartch
05-17
二分查找（Binary Search）是一种常用的查找算法，也称折半查找。该算法针对有序数组，通过将数组不断分成左右两个子数组，并判断目标元素可能在哪个子数组中，从而快速定位目标元素的位置。 具体实现步骤如下： 1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值