欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

C語言實現(xiàn)通用數(shù)據(jù)結(jié)構(gòu)之通用鏈表

 更新時間：2021年11月26日 10:38:19   作者：swwlqw  
這篇文章主要為大家詳細(xì)介紹了c語言實現(xiàn)通用數(shù)據(jù)結(jié)構(gòu)之通用鏈表，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下

本文實例為大家分享了c語言實現(xiàn)通用數(shù)據(jù)結(jié)構(gòu)之通用鏈表的具體代碼，供大家參考，具體內(nèi)容如下

忽然想起來，大概在兩年之前學(xué)習(xí)C語言的時候，曾經(jīng)用C語言寫過一些通用的數(shù)據(jù)結(jié)構(gòu)。主要也就實現(xiàn)了鏈表、隊列、椎、HashSet，還有HashMap。當(dāng)時只是知道標(biāo)準(zhǔn)的C語言中沒有這方面的類庫，后來才知道有很多第三方的類似這樣的類庫。廢話不多說，先把代碼粘過來。

下面實現(xiàn)的是通用鏈表，注意鏈表中只存儲了指針，沒有儲存實際的數(shù)據(jù)。

頭文件

/*************************
*** File myList.h
**************************/
 
#ifndef MYLIST_H_INCLUDED
#define MYLIST_H_INCLUDED
#include <stdio.h>
 
 
typedef struct myNode
{
    void * data;
    struct myNode *next;
} MyNode;
 
typedef struct myList
{
    MyNode * first;
    MyNode * last;
    int count;
    int (*equal)(void * a, void * b);
} MyList;
 
typedef struct myListIterator
{
    MyNode * p;
    int count;
    int allSize;
} MyListIterator;
 
//創(chuàng)建鏈表
MyList * createMyList();
 
//創(chuàng)建鏈表，帶有相等參數(shù)，用于查找
MyList * createMySearchList(int(*equal)(void * a, void * b));
 
//釋放鏈表
void freeMyList(MyList * list);
 
//插入在尾部
void myListInsertDataAtLast(MyList* const list, void* const data);
 
//插入在首部
void myListInsertDataAtFirst(MyList * const list, void* const data);
 
//插入
void myListInsertDataAt(MyList * const list, void* const data, int index);
 
//刪除在尾部
void* myListRemoveDataAtLast(MyList* const list);
 
//刪除在首部
void* myListRemoveDataAtFirst(MyList * const list);
 
//刪除
void* myListRemoveDataAt(MyList* const list, int index);
 
//刪除對象,返回是否刪除成功
int myListRemoveDataObject(MyList* const list, void * data);
 
//長度
int myListGetSize(const MyList * const list);
 
//打印
void myListOutput(const MyList * const list, void(*pt)(const void * const));
 
//取得數(shù)據(jù)
void* myListGetDataAt(const MyList * const list, int index);
 
//取得第一個數(shù)據(jù)
void* myListGetDataAtFirst(const MyList * const list);
 
//取得最后一個數(shù)據(jù)
void* myListGetDataAtLast(const MyList * const list);
 
//查找某個數(shù)據(jù)的位置,如果equal方法為空，比較地址，否則調(diào)用equal方法
//如果不存在返回-1，如果存在，返回出現(xiàn)的第一個位置
int myListFindDataIndex(const MyList * const list, void * data);
 
//創(chuàng)建遍歷器
MyListIterator* createMyListIterator(const MyList * const list);
 
//釋放遍歷器
void freeMyListIterator(MyListIterator* iterator);
 
//遍歷器是否有下一個元素
int myListIteratorHasNext(const MyListIterator* const iterator);
 
//返回遍歷器的下一個元素
void * myListIteratorNext(MyListIterator* const iterator);
 
#endif // MYLIST_H_INCLUDED

源文件

/*************************
*** File myList.c
**************************/
 
#include "myList.h"
#include <stdlib.h>
//創(chuàng)建鏈表
MyList * createMyList()
{
    MyList * re = (MyList *) malloc(sizeof(MyList));
    re->count = 0;
    re->first = NULL;
    re->last = NULL;
    re->equal = NULL;
    return re;
}
 
//釋放鏈表
void freeMyList(MyList * list)
{
    MyNode * p;
    while (list->first)
    {
        p = list->first->next;
        free(list->first);
        list->first = p;
    }
    free(list);
}
 
//插入在尾部
void myListInsertDataAtLast(MyList * const list, void* const data)
{
    MyNode * node = (MyNode *) malloc(sizeof(MyNode));
    node->data = data;
    node->next = NULL;
    if (list->count)
    {
        list->last->next = node;
        list->last = node;
    }
    else
    {
        list->first = node;
        list->last = node;
    }
    (list->count)++;
}
 
//插入在首部
void myListInsertDataAtFirst(MyList * const list, void* const data)
{
    MyNode * node = (MyNode *) malloc(sizeof(MyNode));
    node->data = data;
    node->next = NULL;
 
    if (list->count)
    {
        node->next = list->first;
        list->first = node;
    }
    else
    {
        list->first = node;
        list->last = node;
    }
    (list->count)++;
}
 
//長度
int myListGetSize(const MyList * const list)
{
    return list->count;
}
 
//打印
void myListOutput(const MyList * const list, void(*pt)(const void * const))
{
    MyNode * p = list->first;
    while (p)
    {
        (*pt)(p->data);
        p = p->next;
    }
}
 
//刪除在尾部
void* myListRemoveDataAtLast(MyList* const list)
{
    if (list->count == 1)
    {
        return myListRemoveDataAtFirst(list);
    }
    MyNode * p = list->first;
    while (p->next != list->last)
    {
        p = p->next;
    }
    void *re = list->last->data;
    free(list->last);
    p->next = NULL;
    list->last = p;
    (list->count)--;
    return re;
}
 
//刪除在首部
void* myListRemoveDataAtFirst(MyList * const list)
{
    MyNode *p = list->first;
    list->first = p->next;
    void * re = p->data;
    free(p);
    (list->count)--;
    if (list->count == 0)
    {
        list->last = NULL;
    }
    return re;
}
 
//插入
void myListInsertDataAt(MyList * const list, void* const data, int index)
{
    if (index == 0)
    {
        myListInsertDataAtFirst(list, data);
        return;
    }
    if (index == list->count)
    {
        myListInsertDataAtLast(list, data);
        return;
    }
    MyNode * node = (MyNode *) malloc(sizeof(MyNode));
    node->data = data;
    node->next = NULL;
 
    MyNode * p = list->first;
    for (int i = 0; i < index - 1; i++)
    {
        p = p->next;
    }
    node->next = p->next;
    p->next = node;
 
    (list->count)++;
}
 
//刪除
void* myListRemoveDataAt(MyList* const list, int index)
{
    if (index == 0)
    {
        return myListRemoveDataAtFirst(list);
    }
    if (index == list->count - 1)
    {
        return myListRemoveDataAtLast(list);
    }
 
    MyNode * p = list->first;
    for (int i = 0; i < index - 1; i++)
    {
        p = p->next;
    }
    MyNode *tp = p->next;
    p->next = p->next->next;
    void * re = tp->data;
    free(tp);
    (list->count)--;
    return re;
}
 
//取得數(shù)據(jù)
void* myListGetDataAt(const MyList * const list, int index)
{
    if (index == list->count - 1)
    {
        return myListGetDataAtLast(list);
    }
    MyNode * p = list->first;
    for (int i = 0; i < index; i++)
    {
        p = p->next;
    }
    return p->data;
}
 
//取得第一個數(shù)據(jù)
void* myListGetDataAtFirst(const MyList * const list)
{
    return list->first->data;
}
 
//取得最后一個數(shù)據(jù)
void* myListGetDataAtLast(const MyList * const list)
{
    return list->last->data;
}
 
//查找某個數(shù)據(jù)的位置,如果equal方法為空，比較地址，否則調(diào)用equal方法
//如果不存在返回-1，如果存在，返回出現(xiàn)的第一個位置
int myListFindDataIndex(const MyList * const list, void * data)
{
    MyNode * p = list->first;
    int re = 0;
    if (list->equal)
    {
        while (p)
        {
            if (p->data == data || (*(list->equal))(p->data, data))
            {
                return re;
            }
            re++;
            p = p->next;
        }
 
    }
    else
    {
        while (p)
        {
            if (p->data == data)
            {
                return re;
            }
            re++;
            p = p->next;
        }
    }
    return -1;
}
 
//創(chuàng)建鏈表，帶有相等參數(shù)，用于查找
MyList * createMySearchList(int(*equal)(void * a, void * b))
{
    MyList * re = createMyList();
    re->equal = equal;
    return re;
}
 
//創(chuàng)建遍歷器
MyListIterator* createMyListIterator(const MyList * const list)
{
    MyListIterator * re = (MyListIterator *) malloc(sizeof(MyListIterator));
    re->p = list->first;
    re->allSize = list->count;
    re->count = 0;
    return re;
}
 
//釋放遍歷器
void freeMyListIterator(MyListIterator* iterator)
{
    free(iterator);
}
 
//遍歷器是否有下一個元素
int myListIteratorHasNext(const MyListIterator* const iterator)
{
    return iterator->count < iterator->allSize;
}
 
//返回遍歷器的下一個元素
void * myListIteratorNext(MyListIterator* const iterator)
{
    void * re = iterator->p->data;
    iterator->p = iterator->p->next;
    (iterator->count)++;
    return re;
}
 
//刪除對象,返回是否刪除成功
int myListRemoveDataObject(MyList* const list, void * data)
{
    MyListIterator * it = createMyListIterator(list);
    int a = 0;
    while (myListIteratorHasNext(it))
    {
        void * ld = myListIteratorNext(it);
        if (data == ld || (list->equal != NULL && (*(list->equal))(ld, data)))
        {
            a = 1;
            break;
        }
    }
    if (a)
    {
        myListRemoveDataAt(list, it->count - 1);
    }
    return a;
}

測試文件

/*************************
*** File main.c
*** test for MyList
**************************/
#include <stdio.h>
#include <stdlib.h>
#include "myList.h"
 
typedef struct a
{
    int i;
    char c;
} A;
 
void ppt(const void* const p)
{
    A * pp= p;
    printf("%d(%c) ", pp->i, pp->c);
}
 
 
int main()
{
    const int S =10;
 
    //創(chuàng)建并初始化數(shù)據(jù)
    A * data= malloc(sizeof(A)*S);
    for (int i=0; i< S; i++)
    {
        data[i].i=i;
        data[i].c=(char)('A'+0);
    }
 
    //創(chuàng)建鏈表
    MyList * list= createMyList();
 
    //測試三種插入方法
    myListInsertDataAtLast( list, &data[0]);
    myListInsertDataAtFirst( list, &data[4]);
    myListInsertDataAt(list, &data[1], 1 );
 
 
    //測試查找
    int index = myListFindDataIndex(list, &data[2]);
    printf("%d\n", index);
    index = myListFindDataIndex(list, &data[4]);
    printf("%d\n", index);
 
    //輸出
    myListOutput(list, ppt );
    puts("");
 
    //測試使用迭代器輸出
    MyListIterator * it = createMyListIterator(list);
    while(myListIteratorHasNext(it))
    {
        A * pp = myListIteratorNext(it);
        printf("%d[%c] ", pp->i, pp->c);
    }
    puts("");
    //釋放迭代器
    freeMyListIterator(it);
 
    //釋放鏈表
    freeMyList(list);
 
    //釋放數(shù)據(jù)
    free(data);
    return 0;
}

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

相關(guān)文章

  • C++中stack、queue、vector的用法詳解

    C++中stack、queue、vector的用法詳解

    本文通過實例代碼給大家介紹了C++中stack、queue、vector的用法，需要的朋友參考下吧
    2017-08-08
  • 劍指offer之判斷鏈表是否包含環(huán)

    劍指offer之判斷鏈表是否包含環(huán)

    今天小編就為大家分享一篇關(guān)于劍指offer之判斷鏈表是否包含環(huán)，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧
    2019-02-02
  • C++ CopyFile,MoveFile用法案例詳解

    C++ CopyFile,MoveFile用法案例詳解

    這篇文章主要介紹了C++ CopyFile,MoveFile用法案例詳解,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細(xì)內(nèi)容,需要的朋友可以參考下
    2021-09-09
  • 在C語言中對utmp文件進行查找和寫入操作的函數(shù)小結(jié)

    在C語言中對utmp文件進行查找和寫入操作的函數(shù)小結(jié)

    這篇文章主要介紹了在C語言中對utmp文件進行查找和寫入操作的函數(shù)小結(jié),包括pututline()函數(shù)和getutline()函數(shù)以及getutid()函數(shù),需要的朋友可以參考下
    2015-08-08
  • C語言詳細(xì)分析宏定義與預(yù)處理命令的應(yīng)用

    C語言詳細(xì)分析宏定義與預(yù)處理命令的應(yīng)用

    宏定義是用宏名來表示一個字符串,在宏展開時又以該字符串取代宏名,這只是一種簡單的替換。字符串中可以含任何字符,可以是常數(shù),也可以是表達式,預(yù)處理程序?qū)λ蛔魅魏螜z查,如有錯誤,只能在編譯已被宏展開后的源程序時發(fā)現(xiàn)
    2022-07-07
  • C++算法與泛型算法（algorithm、numeric）

    C++算法與泛型算法（algorithm、numeric）

    這篇文章主要介紹了C++算法與泛型算法（algorithm、numeric）,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
    2020-02-02
  • C++實現(xiàn)簡單信息管理系統(tǒng)

    C++實現(xiàn)簡單信息管理系統(tǒng)

    這篇文章主要為大家詳細(xì)介紹了C++實現(xiàn)簡單信息管理系統(tǒng)，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下
    2022-03-03
  • C語言全面梳理文件操作方法

    C語言全面梳理文件操作方法

    這篇文章主要為大家詳細(xì)介紹了C語言的文件操作，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助
    2022-05-05
  • C語言實現(xiàn)變色進度條

    C語言實現(xiàn)變色進度條

    這篇文章主要為大家詳細(xì)介紹了C語言實現(xiàn)一個變色的進度條，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下
    2018-01-01
  • Opencv實現(xiàn)傅里葉變換

    Opencv實現(xiàn)傅里葉變換

    這篇文章主要為大家詳細(xì)介紹了Opencv實現(xiàn)傅里葉變換的相關(guān)資料，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下
    2018-04-04

最新評論