C 一种程序，它要求输入一个字符串并读取一个目录以查找所有以该字符串开头的文件
这是一个班级的项目。我和我的搭档已经为此工作了一段时间，似乎有点卡住了。任务要求我们完成以下工作：C 一种程序，它要求输入一个字符串并读取一个目录以查找所有以该字符串开头的文件,c,arrays,linked-list,directory,search-suggestion,C,Arrays,Linked List,Directory,Search Suggestion,这是一个班级的项目。我和我的搭档已经为此工作了一段时间，似乎有点卡住了。任务要求我们完成以下工作： 向用户询问目录名 要求用户输入表示文件名开头的一串字母 打开目录以查找以过程#2中要求的字符串开头的所有文件 将每个字符串存储到链接列表数组中。该数组将有26个元素，字母表中每个字母对应一个元素 在打印到输出之前，以适当的方式对列表进行排序 这是我们目前的代码。我知道我们需要处理struct node*数组，我们已经找到了一种更好的打开目录的方法。但除此之外，代码似乎失败了。任何关于我搞砸的地
- 向用户询问目录名
- 要求用户输入表示文件名开头的一串字母
- 打开目录以查找以过程#2中要求的字符串开头的所有文件
- 将每个字符串存储到链接列表数组中。该数组将有26个元素，字母表中每个字母对应一个元素
- 在打印到输出之前，以适当的方式对列表进行排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <dirent.h>
//THE LINKED LIST STRUCTURE.
struct node
{
char data[50]; //THE DATA.
int key; //THE KEY.
struct node *next; //POINT TO NEXT NODE.
};
struct node *head = NULL; //THE FIRST NODE.
struct node *current = NULL; //THE CURRENT NODE.
//PRINT EACH ITEM IN THE LIST.
void print_list()
{
//SET THE POINTER TO THE FIRST ELEMENT OF THE LIST.
struct node *pointer = head;
//WHILE THE POINTER IS NOT NULL, IE WHEN THE LIST IS NOT AT THE
//END....
while(pointer != NULL)
{
//PRINT THE DATA AT THE CURRENT POINTER.
//ADVANCE THE POINTER TO THE NEXT NODE.
printf("%s \n", pointer -> data);
pointer = pointer -> next;
}
}
//INSERT NODE AT HEAD.
void insert(int key, char data[])
{
//CREATE A LINK, ALLOCATE MEMORY EQUAL TO THE SIZE OF A NODE
//STRUCTURE.
//SET THE LINK KEY TO THE KEY PARAMETER.
//SET THE LINK DATA TO THE DATA PARAMETER.
//POINT TO PREVIOUS FIRST NODE.
//POINT TO NEW FIRST NODE.
struct node *link = (struct node*) malloc(sizeof(struct node));
link -> key = key;
link -> data = data[];
link -> next = head;
head = link;
}
//DELETE NODE AT HEAD.
struct node* delete()
{
//CREATE A POINTER AND SET IT TO THE FIRST NODE.
//POINT TO THE NEXT NODE AND SET IT AS THE HEAD.
//RETURN THE EMPTY NODE.
struct node *temp_link = head;
head = head -> next;
return temp_link;
}
//SORT LIST BY HEADER.
void sort_list()
{
int i, j, k; //LOOP COUNTERS.
int temp_key, temp_data; //TEMPORARY KEY AND DATA HOLDER
//VARIABLES.
struct node *current; //POINTER TO THE CURRENT NODE.
struct node *head; //POINTER TO THE FIRST NODE.
struct node *next; //POINTER TO THE NEXT NODE.
int size = length(); //SET SIZE TO LIST LENGTH.
k = size; //LOOP COUNTER K = LIST SIZE.
//FOR EVERY ITEM IN THE LIST....
for(int i = 0; i < size - 1; i++, k--)
{
//SET THE CURRENT POINTER TO THE HEAD.
//SET THE NEXT POINTER TO THE NEXT NODE.
//INCREMENT I.
//DECREMENT K.
current = head;
next = head -> next;
//FOR EVERY ITEM IN THE LIST....
for(j = 1; j < k; j++)
{
//IF THE CURRENT DATA > THE NEXT DATA
if(current -> data > next -> data)
{
//STORE THE CURRENT DATA IN TEMP.
//SET THE NEXT DATA TO CURRENT DATA.
//SET THE CURRENT DATA TO NEXT DATA.
temp_data = (int)current -> data;
current -> data = next -> data;
next -> data = temp_data;
//STORE THE CURRENT KEY IN TEMP.
//SET THE NEXT KEY TO CURRENT KEY.
//SET THE CURRENT KEY TO NEXT KEY.
temp_key = current -> key;
current -> key = next -> key;
next->key = temp_key;
}
//ADVANCE THE CURRENT POINTER.
//ADVANCE THE NEXT POINTER.
//INCREMENT J.
//TEST IF J < K.
current = current -> next;
next = next -> next;
}
}
}
//RETURN LENGTH OF THE LIST.
int length()
{
//INITIALIZE LENGTH TO 0.
//CREATE A POINTER TO THE CURRENT NODE.
int length = 0;
struct node *current;
//START AT THE HEAD. IF THE CURRENT POINTER IS POINTING TO
//SOMETHING....
for(current = head; current != NULL; current = current -> next)
{
//INCREMENT LENGTH.
//ADVANCE THE POINTER.
length++;
}
//RETURN THE LENGTH COUNT.
return length;
}
//DETERMINE IF LIST IS EMPTY.
bool empty()
{
//IF THE FIRST NODE POINTS TO NOTHING, LIST IS EMPTY.
return head == NULL;
}
//REVERSE THE LIST
void reverse(struct node** head_ref)
{
//POINTER TO THE PREVIOUS NODE.
//POINTER TO THE CURRENT NODE.
//POINTER TO THE NEXT NODE.
struct node* previous = NULL;
struct node* current = *head_ref;
struct node* next;
//WHILE THE CURRENT NODE POINTS TO SOMETHING....
while(current != NULL)
{
//SET THE NEXT NODE TO THE NEXT NODE.
//SET THE CURRENT NODE POINTER TO THE PREVIOUS NODE.
//SET THE PREVIOUS NODE TO THE CURRENT NODE.
//SET THE NEXT NODE TO THE PREVIOUS NODE.
next = current -> next;
current -> next = previous;
previous = current;
current = next;
}
//SET THE HEAD REFERENCE TO THE PREVIOUS NODE.
*head_ref = previous;
}
int main(int argc, char** argv)
{
//VARIABLE DECLARATION.
char folder[30]; //FOLDER NAME.
char file_name[20]; //THE ENTERED FILE NAME BEGINNING.
char buffer[50]; //FILE NAME BEGINNING COMPARATOR.
int sort[26]; //THE ARRAY OF FILE NAME HEADERS.
int count; //AN INTEGER TRACKER.
int temp_int; //ASCII VALUE OF ARRAY HEADER.
char temp; //TEMPORARY CHARACTER HOLDER.
//INITIALIZATION.
char working_directory[30] = "."; //SET THE DIRECTORY NAME.
DIR *directory_pointer = NULL; //POINTER TO A DIRECTORY.
struct dirent *pent = NULL; //DIRECTORY POINTER.
count = 0; //KEEPS TRACK OF CHARACTER INDEXES.
//PROMPT FOR THE FOLDER NAME.
//GET THE FOLDER NAME.
//FIND THE PATH OF THE FOLDER.
//SET THE DIRECTORY POINTER TO THE PATH
printf("Enter a folder name: ");
gets(folder);
strcat(working_directory, folder);
directory_pointer = opendir(folder);
//WHILE THE STRING LENGTH ISN'T 0....
do
{
//RESET COUNT.
//PROMPT FOR THE BEGINNING OF A FILE NAME.
//GET THE STRING FROM STANDARD INPUT.
count = 0;
printf("\nEnter the beginning of a filename: ");
gets(file_name);
//IF THE LENGTH OF THE ENTERED STRING IS NOT 0.
if(strlen(file_name) > 0)
{
//HOLD THE FIRST LETTER OF THE FILE NAME IN TEMP.
//LOWER CASE THAT LETTER.
//SET THE COMPARATOR TO A LINE IN THE DIRECTORY.
temp = file_name[0];
temp_int = tolower(temp);
buffer[0] = pent;
//OUTPUT HEADER.
printf("Files starting with ""%s"" in ""%s"":\n", file_name,
folder);
//WHILE THERE EXISTS FILES TO READ....
while(pent = readdir(directory_pointer))
{
//FOR EACH LETTER IN THE FILE NAME STRING....
for(int i = 0; i < strlen(file_name); i++)
{
//COMPARE FILE NAME WITH COMPARATOR.
if(file_name[i] == buffer[i])
{
//INCREMENT COUNT IF LETTERS MATCH
count++;
}
}
//IF THE FILE NAME AND COMPARATOR MATCH.
if(strlen(file_name) == count)
{
//INSERT THE LINE OF THE DIRECTORY IN THE APPROPRIATE ARRAY INDEX.
insert(temp_int, pent);
}
}
//SORT THE LIST.
//PRINT THE LIST.
sort_list();
print_list();
}
//IF STRING ENTERED IS EMPTY, CLOSE THE DIRECTORY AND QUIT THE
//PROGRAM SUCCESSFULLY!
else
printf("Successfully quit!\n");
closedir(working_directory);
return(EXIT_SUCCESS);
}while(strlen(file_name) > 0);
return (EXIT_SUCCESS);
}
#包括
#包括
#包括
#包括
#包括
//链表结构。
结构节点
{
字符数据[50]；//数据。
int key；//密钥。
struct node*next；//指向下一个节点。
};
结构节点*head=NULL//第一个节点。
结构节点*current=NULL//当前节点。
//打印列表中的每个项目。
作废打印列表（）
{
//设置指向列表第一个元素的指针。
结构节点*指针=头；
//指针不为空时，即列表不在
//结束。。。。
while（指针！=NULL）
{
//在当前指针处打印数据。
//将指针前进到下一个节点。
printf（“%s\n”，指针->数据）；
指针=指针->下一步；
}
}
//在头部插入节点。
无效插入（int键，字符数据[]）
{
//创建链接，分配与节点大小相等的内存
//结构。
//将链接键设置为键参数。
//将链接数据设置为数据参数。
//指向上一个第一个节点。
//指向新的第一个节点。
结构节点*链接=（结构节点*）malloc（sizeof（结构节点））；
链接->键=键；
链接->数据=数据[]；
链接->下一步=头部；
头=链接；
}
//删除头部的节点。
结构节点*delete（）
{
//创建一个指针并将其设置为第一个节点。
//指向下一个节点并将其设置为头部。
//返回空节点。
结构节点*temp_link=head；
头部=头部->下一步；
返回临时链接；
}
//按标题对列表进行排序。
无效排序列表（）
{
int i，j，k；//循环计数器。
int temp_key，temp_data；//临时密钥和数据持有者
//变量。
struct node*current；//指向当前节点的指针。
struct node*head；//指向第一个节点的指针。
struct node*next；//指向下一个节点的指针。
int size=length（）；//将size设置为LIST length。
k=大小；//循环计数器k=列表大小。
//对于列表中的每个项目。。。。
对于（int i=0；i下一步；
//对于列表中的每个项目。。。。
对于（j=1；j下一个数据
如果（当前->数据>下一步->数据）
{
//将当前数据存储在TEMP中。
//将下一个数据设置为当前数据。
//将当前数据设置为下一个数据。
温度数据=（int）当前->数据；
当前->数据=下一个->数据；
下一步->数据=临时数据；
//将当前密钥存储在TEMP中。
//将下一个关键点设置为当前关键点。
//将当前关键点设置为下一个关键点。
临时键=当前键->键；
当前->键=下一个->键；
下一步->键=临时键；
}
//前进当前指针。
//前进下一个指针。
//增量J。
//如果J下一步；
下一步=下一步->下一步；
}
}
}
//返回列表的长度。
int-length（）
{
//将长度初始化为0。
//创建指向当前节点的指针。
整数长度=0；
结构节点*当前；
//从头部开始。如果当前指针指向
//某物。。。。
对于（当前=头部；当前！=NULL；当前=当前->下一步）
{
//增量长度。
//前进指针。
长度++；
}
//返回长度计数。
返回长度；
}
//确定列表是否为空。
bool empty（）
{
//如果第一个节点未指向任何内容，则列表为空。
返回头==NULL；
}
//倒过来
无效反向（结构节点**头部参照）
{
//指向上一个节点的指针。
//指向当前节点的指针。
//指向下一个节点的指针。
结构节点*previous=NULL；
结构节点*current=*head\u ref；
结构节点*下一步；
//当当前节点指向某个对象时。。。。
while（当前！=NULL）
{
//将下一个节点设置为下一个节点。
//将当前节点指针设置为上一个节点。
//将上一个节点设置为当前节点。