Alternative Ways of Finding Vertices

I know one way of finding vertices that meet a certain criteria is to run a while loop through a mesh's vertices and use if statements to see which ones meet the criteria, but if there are extremely large amounts of vertices, this could be extremely taxing. For example, if I wanted to see whether certain vertices were within a certain distance from an object, or were within another object's bounds, I would have to do this:

 int i = 0;
 while(i < vertices.Length){
     if(otherCollider.bounds.Contains(vertices[i])){
          //blah blah
     }
 }

(Note: Yes I'm aware that that bit of code wouldn't actually work, but you get the idea)

And if the mesh had 4000 vertices, it would run pretty slow. So what else could I do to find these same vertices?

Edit:

Here's the code at hand if anyone would like to see it (refer to comment thread in one of the answers):

 public class TerrainEditorLayer {
 
     public string name = "New Layer";
     public string layerTag = "Layer Tag";
 
     public Transform terrainLayer;
 
     public float layerHeight = 0;
     public Vector2 terrainSize = new Vector2(10,10);
 
     public Texture baseTexture;
     public Texture paintTexture;
 }
 
 public class TerrainEditor : MonoBehaviour {
 
     public List<TerrainEditorLayer> layers;
 
     public Collider brush;
 
     public float brushSize = 100;
     public float opacity = 100;
 
     public bool continuous;
     public bool smooth;
     private bool digTool;
 
     public int terrainLayer;
     private int layerMask;
 
     private RaycastHit hit;
     private Collider[] sHit;
     private Collider other;
 
     private Transform finder;
     public Transform brushProjector;
 
     void Awake () {
 
         layerMask = 1 << terrainLayer;
         finder = transform;
     }
 
     void Start () {
 
         foreach(TerrainEditorLayer layer in layers){
             layer.terrainLayer.tag = layer.layerTag;
             layer.terrainLayer.position = new Vector3(0, layer.layerHeight, 0);
         }
     }
 
     void Update () {
 
         if(Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)){
             digTool = true;
         }else{
             digTool = false;
         }
 
         if(continuous){
             if(Input.GetButton("Fire1")){
                 if(Physics.Raycast(finder.position, finder.forward, out hit, 1000)){
                     foreach(TerrainEditorLayer layer in layers){
                         if(hit.collider.tag == layer.layerTag){
                             if(brush){
                                 brush.transform.position = hit.point;
                             }
                             Deform(layer, FindNextLayer(layer));
                         }
                     }
                 }
             }
         }else{
             if(Input.GetButtonDown("Fire1")){
                 if(Physics.Raycast(finder.position, finder.forward, out hit, 1000)){
                     foreach(TerrainEditorLayer layer in layers){
                         if(hit.collider.tag == layer.layerTag){
                             if(brush){
                                 brush.transform.position = hit.point;
                             }
                             Deform(layer, FindNextLayer(layer));
                         }
                     }
                 }
             }
         }
     }
 
     void Deform (TerrainEditorLayer currentLayer, TerrainEditorLayer nextLayer) {
 
         sHit = Physics.OverlapSphere(hit.point, (brushSize/100), layerMask);
         foreach(Collider terrain in sHit){
             if(terrain.GetComponent<MeshFilter>() && terrain.CompareTag(currentLayer.layerTag)){
                 Mesh mesh = terrain.GetComponent<MeshFilter>().mesh;
                 Vector3[] terrainVertices = mesh.vertices;
                 Vector3[] terrainNormals = mesh.normals;
 
                 Vector3 vertPoint = terrain.transform.InverseTransformPoint(hit.point);
 
                 int i = 0;
                 while(i < terrainVertices.Length){
                     if((terrainVertices[i] - vertPoint).magnitude < (brushSize/10)){
                         Vector3 digDir = new Vector3(0,0,0);
                         if(digTool){
                             digDir = terrain.transform.TransformDirection(Vector3.up);
                         }else{
                             digDir = terrain.transform.TransformDirection(-Vector3.up);
                         }
                         Vector3 vertMove = new Vector3(0,0,0); 
                         if(smooth){
                             if(digTool){
                                 digDir = terrain.transform.TransformDirection(Vector3.up);
                                 vertMove = digDir * ((opacity/100) * Time.deltaTime) + (terrainNormals[i]/-100);
                             }else{
                                 digDir = terrain.transform.TransformDirection(-Vector3.up);
                                 vertMove = digDir * ((opacity/100) * Time.deltaTime) + (terrainNormals[i]/100);
                             }
                             terrainVertices[i] += vertMove;
                         }else{
                             if(digTool){
                                 digDir = terrain.transform.TransformDirection(Vector3.up);
                                 vertMove = digDir * ((opacity/100) * Time.deltaTime);
                             }else{
                                 digDir = terrain.transform.TransformDirection(-Vector3.up);
                                 vertMove = digDir * ((opacity/100) * Time.deltaTime);
                             }
                             terrainVertices[i] += vertMove;
                         }
                     }
                     i++;
                 }
 
                 mesh.vertices = terrainVertices;
                 mesh.RecalculateBounds();
                 mesh.RecalculateNormals();
                 terrain.transform.GetComponent<MeshCollider>().enabled = false;
                 terrain.transform.GetComponent<MeshCollider>().sharedMesh = mesh;
                 terrain.transform.GetComponent<MeshCollider>().enabled = true;
             }
         }
     }
 
     TerrainEditorLayer FindNextLayer (TerrainEditorLayer currentLayer) { 
 
         float closestDepth = Mathf.Infinity;
         TerrainEditorLayer closestLayer = new TerrainEditorLayer();
 
         foreach(TerrainEditorLayer layer in layers){
             if((currentLayer.layerHeight - layer.layerHeight) > (currentLayer.layerHeight - closestDepth)){
                 closestDepth = layer.layerHeight;
                 closestLayer = layer;
             }
         }
 
         return closestLayer;
     }