在 C 中，如何删除 char 数组中相同且连续的行？

Question

我正在寻找有关创建函数的帮助。

函数 deleteIdents() 将删除 char 数组中的相同行，因为它们是连续的。它将保留相同的行之一。

我不需要检查整行是否相同。对于这种情况，只有前 79 个字符 MAXCHARS 就可以了。

所以，例如，如果我的数组包含

Hello World
Hi World
Hello World
Hello World
Hello World
Hi there

会改成

Hello World
Hi World
Hello World
Hi there

在我的脑海中，函数看起来类似于：

int deleteIdents(char *a)
{
    int i;
    for (i=0; i<=MAXCHARS; i++) {
        if (a[i] != '\n')
            /* copy into new array */
        }
    }
}

但我不确定。如果您有解决方案，我会很高兴并感谢您：)

Answer 1

读第一行而不是第二行，比较它们是否相等进入循环，直到它们不相等。所以这里是代码：

char *first_line = malloc(MAXLINE);
char *second_line = malloc(MAXLINE);

getline(first_line);

do {
   getline(second_line);
} while (strcmp (first_line, second_line));

对于getline() 实现搜索，有很多示例。或者here你有我的。

Answer 2

另一个如何实现它的例子。想法是保留 2 个指针，只有在条目不同时才增加第一个指针。还分配了一些额外的存储空间，以避免已被覆盖的条目的内存泄漏。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int unique(char **strings, int size) {
    if (!strings) {
        return -1;
    }
    int head = 0, newHead = 0, duplicatedElementsHead = 0;
    //Save duplicates to avoid memory leaks
    char** duplicatedEntries = malloc(size*sizeof(char*));

    while (head < size) {
        //String are the same
        if (!strcmp(strings[head], strings[newHead])) {
            if (head != newHead) {
                duplicatedEntries[duplicatedElementsHead++] = strings[newHead];
            }
            ++head;
        } else {
            strings[++newHead] = strings[head++];
        }
    }

    //Put duplicated entries after new end
    int idx = 0, tmpHead = newHead + 1;
    for (; idx < duplicatedElementsHead; ++idx) {
        strings[tmpHead++] = duplicatedEntries[idx];
    }

    free(duplicatedEntries);
    return newHead;
}

int main() {
    char **strings = malloc(8*sizeof(char*));
    strings[0] = "Hello World";
    strings[1] = "Hi World";
    strings[2] = "Hi World";
    strings[3] = "Hello World";
    strings[4] = "Hello World";
    strings[5] = "Hi there";
    strings[6] = "Hia";
    strings[7] = "Hi";
    int newEnd = unique(strings, 8);
    for (int i=0; i < newEnd; ++i) {
        printf("%s\n", strings[i]);
    }
    free(strings);
}

Answer 3

您实际上是在编写 unix/linux 实用程序“uniq”的核心功能。

cat filename | sort | uniq > newfile
#or skip sort, since you didn't mention
cat filename | uniq > newfile

你可以只使用 popen 和 uniq （类似这样的......）

FILE *uniqfh;
uniqfh = popen("cat file1 | uniq" , "r");
if (uniqfh == NULL) { //handle error
}
while( fgets(uniqfh, buffer, buffersize) ) printf("%s\n",buffer);

但是说真的，你可以写 uniq() 的核心，

static long MAXUNIQ=79; //or whatever you want
char*
isdup(char* prev, char* next, long len)
{
    //if( !prev || !next) error
    long n = len<=0 ? MAXUNIQ : len;
    for(  ; *prev==*next && n --> 0; ) { //down-to operator (sic)
        ; //clearly nothing happening here!
    }
    return( (n<1) || !(*p+*n) );
}
/yeah, this is actually strncmp, but hey

您需要一个“字符串”数组（char* 或 char[]），让我们阅读它们，

char* ray[ARRAYMAX]; //define how many elements of your arRay
//could use, char** ray; and malloc(ARRAYMAX*sizeof(char*))

long
read_array(FILE* fh, char* ray[])
{
    char buffer[MAXLINE+1];
    long count=0;
    while( fgets(buffer,sizeof(buffer),fh) ) {
        //you could eat dups here, or in separate function below
        //if( (count<1) && !isdup(ray[count-1],buffer,MAXUNIQ) )
        ray[count++] = strdup(buffer);
    }
    //ray[0] through ray[count-1] contain char*
    //count contains number of strings read
    return count;
}
long
deleteIdents(long raysize, char* ray[]) //de-duplicate
{
    long kept, ndx;
    for( ndx=1, kept=0; ndx<raysize; ++ndx ) {
        if( !isdup(ray[kept],ray[ndx]) ) {
            ray[kept++] = ray[ndx];
        }
        else {
            free(ray[ndx]);
            ray[ndx] = NULL; //not entirely necessary, 
        }
    }
    return kept; //new ray size
}

你需要这个来调用它...

...
long raysize;
char* ray[ARRAYMAX] = {0}; //init to null pointers
raysize = read_array(fopen(filename,"r"),ray);
raysize = deleteIndents(raysize,ray);
...

稍后，您将需要释放 malloc 的字符串，

for( ; 0 <-- raysize; ) { free(ray[raysize]);  ray[raysize] = NULL; }

Answer 4

以下程序对字符串元素数组执行您需要的操作。我们使用两个指针导航数组，初始化为第一个和第二个元素。我们运行array_n - 1 比较一个元素与下一个元素的循环，比较两个字符串...如果它们不同，我们将*source_ptr 字符串指针复制到*target_ptr 位置。如果它们不同，我们只增加source_ptr，因此它指向下一个数组字符串，但是不复制它（这使我们有效地删除了指针）我们也在管理新数组（我们使用了相同的数组作为源和目标，因为我们只能删除数组元素，所以每次我们在两个指针之间都有一个更大的洞）

pru.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* array of strings */    
char *array[] = {
    "Hello World",
    "Hi World",
    "Hello World",
    "Hello World",
    "Hello World",
    "Hi there",
};

size_t array_n = sizeof array / sizeof *array;

int main()
{
    int i;

    char **target_ptr = array, **source_ptr = array + 1;
    size_t new_length = 1;

    for (i = 1; i < array_n; i++) {
        /* if strings pointed to by pointers are equal */
        if (strcmp(*target_ptr, *source_ptr) == 0) {
            /* go to the next, effectively discarding the second pointer */
            source_ptr++;
        } else {
            /* copy both pointers in place, to the destination array */
            *target_ptr++ = *source_ptr++;
            new_length++; /* increment array length */
        }
    }
    /* finally, we have in the array only the good pointers */

    /* print'em */
    for (i = 0; i < new_length; i++)
        printf("%s\n", array[i]);

    exit(0);
}

仅此而已。

样品运行：

$ pru
Hi World
Hello World
Hi there
Hello World
$ _