using find command in linux for filenames generated from previous command

Here, it may be easier to get find to find every file and awk to select the ones with the names you want. For instance, assuming a awk that supports setting the record separator to NUL:

find . -print0 | awk '
  ! names_loaded {if (NR>1) names[$4]; next}
  $NF in names' FS='\t' file.txt names_loaded=1 FS=/ RS='\0' -

You have to separately add a bunch of options for each -name. Try this:

IFS='
'
set -o noglob
find . -false $(awk -F '\t' -v OFS='\n' '
    NR>1 && $4 != "" { print "-o", "-name", $4}' file.txt)

awk prints the arguments one per line and we use the split+glob operator ($(...) unquoted) in the shell, with the glob part disabled and the split part tuned to split on newline only to pass those as arguments to find.

This could fail if file.txt is large. Also beware names are treated as patterns. For instance, if there's a line containing [f]ile*, it will find all files whose name starts with file, not the file called [f]ile*.

The normal and safe arrangement would be to use xargs:

something something | xargs -r0 find . -false

but xargs could run find multiple times and split the argument list between an -o and a -name or between -name and the actual file name. We could avoid that by passing -n 150 or any number that is a multiple of 3 and is hoped to be small enough to fit in the limit of the size of arguments.

Putting -false first simplifies the rest of the processing because that way, we can make the output completely regular, with an -o before each -name.

If your find doesn't support that non-standard predicate, you could replace it with -links 0 or anything guaranteed to be false.

You could use zsh recursive globs here instead of find which make it easier:

filenames=( ${(f)"$(<file.txt tail -n +2 | cut -f 4)"} )
print -rC1 -- **/(${(~j[|])filenames})(ND)

Were we use the f parameter expansion flag to split the output of cut on line-feeds and use ~j[|] to join the array members with the | alternation glob operator, **/ for any number of subdirs, D for dotglob, N for nullglob.

Matches are printed raw on 1 Column.

If the names are meant to be interpreted as patterns instead of file names, you can change it to:

print -rC1 -- **/(${(j[|])~filenames})(ND)

Where ~ for globsubst here applies to the whole expansion, not just the | introduced by the join flag.

I would have find send its whole output to awk, and search for the required names using a hash table. Basically, like:

Awk='
#.. Extract required names from list.
FS == " " { if (FNR > 1) Name[$4]; next; }
#.. List paths for given names.
$(NF) in Name { print; }
'
find . -type f -print0 | awk "${Awk}" FS=' ' "file.txt" RS=$'\0' FS='/' - | sort

The sort gathers the output by name (there may be duplicates within the directory tree).

A refinement might be to count hits in the Name[] array, and list the names that had no hits in an END block.

Note that the find output is null-terminated (-print0 in find, RS as NUL in awk), and only files are referenced (having a directory accidentally match a supplied name is an issue with other solutions).