數據結構上機實驗（2）

来源:https://www.cnblogs.com/wangzheming35/archive/2020/05/23/12944595.html
-Advertisement-
Play Games

實操才能去感受自己的缺陷所在，雖然在演算法這一塊很弱勢，但不斷堅持，改變自己。 ...


1、順序表的各種基本運算操作

#include <stdio.h>
#include<stdlib.h>
#define MaxSize 50

typedef char ElemType;
typedef struct 
{
ElemType elem[MaxSize];
   int length;
} SqList;

//初始化 O(1)
void InitList(SqList *&L)
{
L=(SqList *)malloc(sizeof(SqList));
L->length=0;
}
//銷毀 O(1)
void DestroyList(SqList *L)
{
free(L);
}
//判斷是否為空 O(1)
int ListEmpty(SqList *L)
{
return(L->length==0);
}
//求長度 O(1)
int ListLength(SqList *L)
{
return(L->length);
}
//輸出順序表 O(n)
void DispList(SqList *L)
{
int i;
if (ListEmpty(L)) return;
for (i=0;i<L->length;i++)
   printf("%c",L->elem[i]);
printf("\n");
}
//獲取第i個位置上的元素返回給e O(1)
int GetElem(SqList *L,int i,ElemType &e)
{
if (i<1 || i>L->length)
   return 0;
e=L->elem[i-1];
return e;
}
//查找返回元素e的位置  O(n)
int LocateElem(SqList *L, ElemType e)
{
int i=0;
while (i<L->length && L->elem[i]!=e) i++;
if (i>=L->length)
   return 0;
else
   return i+1;
}
//把元素e插入到位置i O(n)
bool ListInsert(SqList *&L,int i,ElemType e)
{
int j;
if (i<1 || i>L->length+1)
   return false;
i--;        //將順序表位序轉化為elem下標
for (j=L->length;j>i;j--)   //將elem[i]及後面元素後移一個位置
   L->elem[j]=L->elem[j-1];
L->elem[i]=e;
L->length++;     
return true;
}
//刪除位置i上的元素 O(n)
bool ListDelete(SqList *&L,int i,ElemType &e)
{
int j;
if (i<1 || i>L->length)
   return false;
i--;        //將順序表位序轉化為elem下標
e=L->elem[i];
for (j=i;j<L->length-1;j++)   //將elem[i]及後面元素前移一個位置
   L->elem[j]=L->elem[j+1];
L->length--;
return true;
}

int main()
{
SqList *L;
ElemType e;
printf("(1)初始化順序表L\n");
InitList(L);
printf("(2)依次採用尾插法插入a,b,c,d,e元素\n");
ListInsert(L,1,'a');
ListInsert(L,2,'b');
ListInsert(L,3,'c');
ListInsert(L,4,'d');
ListInsert(L,5,'e');
printf("(3)輸出順序表L:");
DispList(L);
printf("(4)順序表L長度=%d\n",ListLength(L));
printf("(5)順序表L為%s\n",(ListEmpty(L)?"空":"非空"));
GetElem(L,4,e);
printf("(6)順序表L的第4個元素=%c\n",e);
printf("(7)元素a的位置=%d\n",LocateElem(L,'a'));
printf("(8)在第3個元素位置上插入f元素\n");
ListInsert(L,3,'f');
printf("(9)輸出順序表L:");
DispList(L);
printf("(10)刪除L的第4個元素\n");
    ListDelete(L,4,e);
printf("(11)輸出順序表L:");
DispList(L);
printf("(12)釋放順序表L\n");
DestroyList(L);
}

2、單鏈表的各種基本運算演算法

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

typedef char ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LinkList;

//兩種插入學習
//使用頭插法
void CreateListF(LinkList *&L,ElemType a[],int n)
{
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
    for(i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        s->next=L->next;
        L->next=s;
    }
}
//使用尾插法
void CreateListR(LinkList *&L,ElemType a[],int n)
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    for(i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//初始化線性表 O(1)
void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}
//銷毀線性表 O(n)
void DestroyList(LinkList *&L)
{
    LinkList *pre=L,*p=L->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
//判斷線性表是否為空表 O(1)
bool ListEmpty(LinkList *L)
{
    return (L->next==NULL);
}
//求線性表的長度 O(n)
int ListLength(LinkList *L)
{
    int n=0;
    LinkList *p=L;
    while(p->next!=NULL)
    {
        n++;
        p=p->next;
    }
    return (n);
}
//輸出線性表 O(n)
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
}
//求線性表中某個數據元素值  O(n)
int GetElem(LinkList *L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L;
    while(j<i&&p!=NULL) //題目中i預設大於0
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return 0;
    else
    {
        e=p->data;
        return e;
    }
}
//按元素值查找 O(n)
int LocateElem(LinkList *L,ElemType e)
{
    int i=1;
    LinkList *p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        p=p->next;
        i++;
    }
    if(p==NULL)
        return 0;
    else
        return i;
}
//插入數據元素 O(n)
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
 
}
//刪除數據元素 O(n)
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        q=p->next;
        if(q==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
    }
}
 
int main()
{
    LinkList *L;
    char s[5]= {'a','b','c','d','e'};
    char e;
    int i,j;
    printf("(1)初始化單鏈表L\n");
    InitList(L);
    printf("(2)採用尾插法插入a,b,c,d,e元素");
    CreateListR(L,s,5);
    printf("\n");
    printf("(3)輸出單鏈表L:");
    DispList(L);
    printf("(4)單鏈表L長度=%d\n",ListLength(L));
    i=ListEmpty(L);
    if(i==0)
    {
        printf("(5)該單鏈表L非空\n");
    }
    else
    {
        printf("(5)該單鏈表L為空\n");
    }
    e=GetElem(L,3,e);
    printf("(6)第三個元素為：%c\n",e);
    j=LocateElem(L,'a');
    printf("(7)元素a為第%d個元素\n",j);
    printf("(8)在第4個元素位置上插入f元素\n");
    ListInsert(L,4,'f');
    printf("(9)輸出單鏈表L:");
    DispList(L);
    printf("(10)刪除L的第3個元素\n");
    ListDelete(L,3,e);
    printf("(11)輸出單鏈表L:");
    DispList(L);
    printf("(12)釋放單鏈表L\n");
    DestroyList(L);
}

3、雙鏈表的各種基本運算演算法

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

typedef char ElemType;
typedef struct DNode
{
    ElemType data;
    struct DNode *prior;   //指向前驅結點
    struct DNode *next;   //指向後繼結點
}DLinkNode;//聲明雙鏈表結點類型;

//尾插法建立雙鏈表
void CreateListR(DLinkNode *&L,ElemType a[],int n)
{
    DLinkNode *s,*r;
    //創建頭結點
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->prior=L->next=NULL;
    r=L;   //r始終指向終端結點,開始時指向頭結點
    for (int i = 0; i < n; i++)
    {
        //創建新結點
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        //數據域
        s->data=a[i];
        //將節點s插入到節點r之後
        r->next=s;
        s->prior=r;
        r=s;
    }
    r->next=NULL;   //尾結點next域置空
}

//初始化雙鏈表
void InitList(DLinkNode *&L)
{
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->prior=L->next=NULL;
}
//銷毀雙鏈表
void DestroyList(DLinkNode *&L)
{
    DLinkNode *pre=L, *p=pre->next;
    while(p!=NULL)
    {
        free(pre);
        //pre,p同步後移一個節點
        pre=p;
        p=pre->next;
    }
    free(p);
}
//判斷是否為空
bool ListEmpty(DLinkNode *L)
{
    return(L->next==NULL);
}
//求長度
int ListLength(DLinkNode *L)
{
    DLinkNode *p=L;
    int i=0;   //p指向頭結點 i設置為0
    while(p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return i;
}
//輸出線性表
void DispList(DLinkNode *L)
{
    DLinkNode *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
     printf("\n");
}
//求線性表中第i個元素值
int GetElem(DLinkNode *L,int i,ElemType &e)
{
    int j=0;
    DLinkNode *p=L;
    //查找第i個結點p
    while(j<i&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)
        return 0;
    else   //找到了
    {
        e=p->data;
        return e;
    }
}
//按元素值查找
int LocateElem(DLinkNode *L,ElemType e)
{
    int i=1;
    DLinkNode *p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        i++;   //i對應結點p的序號
        p=p->next;
    }
    if (p==NULL)
        return 0;
    else
        return i;
}
//插入數據元素
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
    int j=0;
    DLinkNode *p=L,*s;    // p指向頭結點,j設置為0
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)
        return false;
    else   //找到第i-1個結點p
    {
        //創建新結點s
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        s->data=e;
        //將節點s插入到節點p之後
        s->next=p->next;
        if(p->next!=NULL)
            p->next->prior=s;
        s->prior=p;
        p->next=s;
        return true;
    }
}
//刪除數據元素 
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
    int j=0;
    DLinkNode *p=L,*q;    //p指向頭結點,j設置為0
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else   //找到第i-1個結點p
    {
        q=p->next;   //q指向第i個結點
        //當不存在第i個結點時返回false
        if(q==NULL)
            return false;
        e=q->data;
        //從雙鏈表中刪除結點q
        p->next=q->next;
        //若p結點存在後繼結點,修改其前驅指針
        if(p->next != NULL)
            p->next->prior = p;
        //釋放q結點
        free(q);
        return true;
    }
}

int main()
{
    DLinkNode *h;
    ElemType e;

    printf("(1)初始化雙鏈表h\n");
    InitList(h);
    printf("(2)依次採用尾插法插入a,b,c,d,e元素\n");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)輸出雙鏈表h:");
    DispList(h);
    printf("(4)雙鏈表h長度:%d\n", ListLength(h));
    printf("(5)雙鏈表h為%s\n", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)雙鏈表h的第3個元素:%c\n", e);
    printf("(7)元素e的位置:%d\n", LocateElem(h, 'e'));
    printf("(8)在第4個元素位置上插入f元素\n");
    ListInsert(h, 4, 'f');
    printf("(9)輸出雙鏈表h:");
    DispList(h);
    printf("(10)刪除h的第3個元素\n");
    ListDelete(h, 3, e);
    printf("(11)輸出雙鏈表h:");
    DispList(h);
    printf("(12)釋放雙鏈表h\n");
    DestroyList(h);
}

4、迴圈單鏈表的各種基本運算操作

#include <stdio.h>
#include <malloc.h>

//學習自CSDN作者-靜能生悟，迴圈單鏈表主要看插入和刪除操作的代碼實現即可

typedef char ElemType;
typedef struct LNode   // 定義迴圈單鏈表結點類型
{
    ElemType data;   // 數據域
    struct LNode *next;   // 指針域
}CLinkList;

//初始化
void InitList(CLinkList *&L)   // 指針的引用
{
    L = (CLinkList *)malloc(sizeof(CLinkList));   //創建頭結點
    L->next = L;
}

//銷毀迴圈單鏈表L
void DestroyList(CLinkList *&L)
{
    CLinkList *p = L;
    CLinkList *q = p->next;
    
    while(q != L)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//判斷是否為空表
int ListEmpty(CLinkList *L)
{
    return (L->next == L);            
}

//求長度
int ListLength(CLinkList *L)
{
    int i = 0;
    CLinkList *p = L;
    
    while(p->next != L)
    {
        i++;
        p = p->next;
    }
    
    return i;
}

//輸出迴圈單鏈表L
void DispList(CLinkList *L)
{
    CLinkList *p = L->next;
    
    while(p != L)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");
}

//獲取迴圈單鏈表L中的第i個元素
int GetElem(CLinkList *L, int i, ElemType &e)    
{
    int j = 0;
    CLinkList *p;
    
    if(L->next != L)   // 單鏈表為非空表時
    {
        if(i == 1)
        {
            e = L->next->data;   // 提取元素
            return 1;
        }
        else   // i不為1時
        {
            p = L->next;
            while((p != L) && (j < i - 1))
            {
                j++;
                p = p->next;
            }
            if(p == L)
                return 0;
            else   // 找到第i個元素
            {
                e = p->data;    
                return e;
            }
        }
    }
    else                        // 單鏈表為空表時
        return 0;
}

//在迴圈單鏈表L中查找元素e
int LocateElem(CLinkList *L, ElemType e)
{
    int n = 1;
    CLinkList *p = L->next;
    
    while((p != L) && (p->data != e))
    {
        p = p->next;
        n++;
    }
    
    if(p == L)
        return 0;
    else
        return n;
}

//在迴圈單鏈表L中第i個位置上插入元素e
int ListInsert(CLinkList *&L, int i, ElemType e)
{
    int j = 0;
    CLinkList *p = L, *s;
    
    if((i == 1) || (p->next == L))                        // 原單鏈表為空表或i=1時
    {
        s = (CLinkList *)malloc(sizeof(CLinkList));        // 創建新結點s
        s->data = e;
        s->next = p ->next;                                // 將s插入到p之後
        p->next = s;
        return 1;
    }
    else
    {
        p = L->next;
        while((p != L) && (j < i - 2))                    // 查找第i-1個結點
        {
            j++;
            p = p->next;
        }
        
        if(p == L)                                        // 未找到第i-1個結點
            return 0;
        else                                            // 找到第i-1個結點
        {
            s = (CLinkList *)malloc(sizeof(CLinkList));    // 創建新結點s
            s->data = e;
            s->next = p->next;                            // 將s插入到p之後
            p->next = s;
            return 1;
        }
    }
}

//在迴圈單鏈表L中刪除第i個元素
int ListDelete(CLinkList *&L, int i, ElemType &e)
{
    int j = 0;
    CLinkList *p = L, *q;
    
    if(p->next != L)                                    // 原單鏈表不為空表時
    {
        if(i == 1)                                        // i=1時
        {
            q = L->next;                                // 刪除第1個結點
            e = q->data;
            L->next = q->next;
            free(q);
            return 1;
        }
        else                                            // i不為1時
        {
            p = L->next;
            while((p != L) && (j < i - 2))                // 查找第i-1個結點                    
            {
                j++;
                p = p->next;
            }
            if(p == L)                                    // 未查找到第i-1個結點    
                return 0;
            else                                        // 查找到第i-1個結點    
            {
                q = p->next;                            // q指向要刪除的結點
                e = q->data;                            // 提取元素
                p->next = q->next;                        // 從單鏈表中刪除q結點
                free(q);                                // 釋放q結點
            }
        }
    }
    else
        return 0;
}

int main()
{
    CLinkList *h;
    ElemType e;
    
    printf("(1)初始化迴圈單鏈表h\n");
    InitList(h);
    printf("(2)依次採用尾部插入法插入a,b,c,d,e元素\n");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)輸出迴圈單鏈表h:");
    DispList(h);
    printf("(4)迴圈單鏈表h長度=%d\n", ListLength(h));
    printf("(5)迴圈單鏈表h為%s\n", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)迴圈單鏈表h的第3個元素=%c\n", e);
    printf("(7)元素a的位置=%d\n", LocateElem(h, 'a'));
    printf("(8)在第4個元素位置上插入f元素\n");
    ListInsert(h, 4, 'f');
    printf("(9)輸出迴圈單鏈表h:");
    DispList(h);
    printf("(10)刪除h的第3個元素\n");
    ListDelete(h, 3, e);
    printf("(11)輸出迴圈單鏈表h:");
    DispList(h);
    printf("(12)釋放迴圈單鏈表h\n");
    DestroyList(h);
}

5、迴圈雙鏈表的各種基本運算操作

#include <stdio.h>
#include <malloc.h>

//學習自CSDN作者-靜能生悟，迴圈雙鏈表主要看插入和刪除操作的代碼實現即可

typedef char ElemType;
typedef struct DNode                        // 定義迴圈雙鏈表結點類型
{
    ElemType data;                            // 數據域
    struct DNode *prior;                    // 指向直接前驅結點
    struct DNode *next;                        // 指向直接後繼結點
}CDLinkList;


//初始化
void InitList(CDLinkList *&L)    // 指針的引用
{
    L = (CDLinkList *)malloc(sizeof(CDLinkList));            // 創建頭結點
    L->prior = L->next = L;
}

//銷毀迴圈雙鏈表L
void DestroyList(CDLinkList *&L)
{
    CDLinkList *p = L;
    CDLinkList *q = p->next;
    
    while(q != L)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//判斷迴圈雙鏈表L是否為空表
int ListEmpty(CDLinkList *L)
{
    return (L->next == L);
}

//求長度
int ListLength(CDLinkList *L)
{
    int i = 0;
    CDLinkList *p = L;
    
    while(p->next != L)
    {
        i++;
        p = p->next;
    }
    return i;
}

//輸出迴圈雙鏈表L
void DispList(CDLinkList *L)
{
    CDLinkList *p = L->next;
    
    while(p != L)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");
}

//獲取迴圈雙鏈表L中第i個元素
int GetElem(CDLinkList *L, int i, ElemType &e)
{
    int j = 0;
    CDLinkList *p;
    
    if(L->next != L)                                // 迴圈雙鏈表為非空表時
    {
        if(i == 1)
        {
            e = L->next->data;                        // 提取元素
            return 1;
        }
        else                                        // i不為1時
        {
            p = L->next;
            while((p != L) && (j < i - 1))            
            {
                j++;
                p = p->next;
            }
            if(p == L)
                return 0;
            else
            {
                e = p->data;
                return 1;
            }
        }
    }
    else                                            // 迴圈雙鏈表為空表時
        return 0;
}

//在迴圈雙鏈表L中查找元素e
int LocateElem(CDLinkList *L, ElemType e)
{
    int n = 1;
    CDLinkList *p = L->next;
    
    while((p != L) && (p->data != e))
    {
        n++;
        p = p->next;
    }
    if(p == NULL)
        return 0;
    else
        return n;
}

//在迴圈雙鏈表L中第i個位置上插入元素e
int ListInsert(CDLinkList *&L, int i, ElemType e)
{
    int j = 0;
    CDLinkList *p = L, *s;
    
    if(p->next == L)                                    // 原雙鏈表為空表時
    {
        s = (CDLinkList *)malloc(sizeof(CDLinkList));        // 創建新結點s
        s->data = e;
        p->next = s; s->next = p;
        p->prior = s; s->prior = p;
        return 1;
    }
    else if(i == 1)                                        // 原雙鏈表不為空表但i=1時
    {
        s = (CDLinkList *)malloc(sizeof(CDLinkList));        // 創建新結點s
        s->data = e;
        // 將s插入到結點p之後
        s->next = p->next;
        p->next = s;
        s->next->prior = s;
        s->prior = p;
        return 1;
    }
    else
    {
        p = L->next;
        while((p != L) && (j < i - 2))
        {
            j++;
            p = p->next;
        }
        if(p == L)                                        // 未找到第i-1個結點
            return 0;
        else                                            // 找到第i-1個結點p
        {
            s = (CDLinkList *)malloc(sizeof(CDLinkList));    // 創建新結點s
            s->data = e;
            // 將s插入到結點p之後
            s->next = p->next;
            if(p ->next != NULL)
                p->next->prior = s;
            s->prior = p;
            p->next = s;
            return 1;
        }
    }
}

//在迴圈雙鏈表L中刪除第i個元素e
int ListDelete(CDLinkList *&L, int i, ElemType &e)
{
    int j = 0;
    CDLinkList *p = L, *q;
    
    if(p->next != L)                                    // 原雙鏈表不為空表時
    {
        if(i == 1)                                        // i=1時
        {
            q = L->next;                                // 刪除第1個結點
            e = q->data;
            L->next = q->next;
            q->next->prior = L;
            free(q);
            return 1;
        }
        else                                            // i不為1時
        {
            p = L->next;
            while((p != NULL) && (j < i - 2))
            {
                j++;
                p = p->next;
            }
            if(p == NULL)                                // 未找到第i-1個結點
                return 0;
            else                                        // 找到第i-1個結點p
            {
                q = p->next;                            // q指向要刪除的結點
                if(q == NULL)                            // 不存在第i個結點
                    return 0;
                e = q->data;
                // 從鏈表中刪除q結點
                p->next = q->next;
                if(p->next != NULL)
                    p->next->prior = p;
                free(q);
                return 1;
            }
        }
    }
    else                                                // 原雙鏈表為空表時
        return 0;
}

int main()
{
    CDLinkList *h;
    ElemType e;
    
    printf("(1)初始化迴圈雙鏈表h\n");
    InitList(h);
    printf("(2)依次採用尾插入法插入a,b,c,d,e元素\n");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)輸出迴圈雙鏈表h:");
    DispList(h);
    printf("(4)迴圈雙鏈表h長度=%d\n", ListLength(h));
    printf("(5)迴圈雙鏈表h為%s\n", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)迴圈雙鏈表h的第3個元素=%c\n", e);
    printf("(7)元素a的位置=%d\n", LocateElem(h, 'a'));
    printf("(8)在第4個元素位置上插入f元素\n");
    ListInsert(h, 4, 'f');
    printf("(9)輸出迴圈雙鏈表h:");
    DispList(h);
    printf("(10)刪除h的第3個元素\n");
    ListDelete(h, 3, e);
    printf("(11)輸出迴圈雙鏈表h:");
    DispList(h);
    printf("(12)釋放迴圈雙鏈表h\n");
    DestroyList(h);
}

6、將單鏈表按基準劃分

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;   //數據域
    struct LNode *next;   //指向後繼結點
}LinkNode;   // 聲明單鏈表結點類型

//尾插法建立單鏈表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    int i;
    L=(LinkNode *)malloc(sizeof(LinkNode));   //創建頭結點
    r=L;   //r始終指向尾結點，開始時指向頭結點
    for (int i = 0; i < n; i++)
    {
        //創建新結點s
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        r->next=s;   //將s插入r之後
        r=s;
    }
    r->next=NULL;    //尾結點next域置為NULL
}
//輸出單鏈表
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;   //p指向首節點
    while(p!=NULL)
    {
        printf("%d",p->data );   // p不為NULL,輸出p結點的數據域
        p=p->next;    // p移向下一個結點
    }
    printf("\n");
}
//銷毀單鏈表
void DestroyList(LinkNode *L)
{
    LinkNode *pre=L,*p=L->next;    //pre指向頭結點，p指向首節點
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;   // pre、p同步後移一個結點
    }
    free(pre);    // 此時p為NULL,pre指向尾結點,釋放它
}
//將L中所有數據結點按e進行劃分 【本題核心代碼】
void split(LinkNode *&L,ElemType e)
{
    LinkNode *p=L->next,*q,*r;    //p指向首節點
    //L變為空表
    L->next=NULL;
    // r是新鏈表的尾結點指針
    r=L;

    while(p!=NULL)
    {
        if(p->data<e)   // 若p結點值小於e,將其插入到開頭
        {
            q=p->next;
            p->next=L->next;
            L->next=p;
            // 若p結點是第一個在開頭插入的結點,則它是尾結點
            if(p->next==NULL)
                r=p;
            p=q;
        }
        else    // 若p結點值大於或等於e,將其插入到末尾
        {
            r->next=p;
            r=p;
            p=p->next;
        }
    }
    r->next=NULL;
}

int main()
{
    LinkNode *L;
    //ElemType a[] = {1,2,3,5,6,7,8,9};
    ElemType a[] = {1,9,8,6,5,3,7,2};
    int n = 8;
    CreateListRear(L,a,n);
    printf("單鏈表L:");
    DispList(L);
    ElemType x = 4;
    printf("以%d進行劃分\n", x);
    split(L,x);
    printf("單鏈表L:");
    DispList(L);
    DestroyList(L);
}

7、將兩個單鏈表合併成一個單鏈表

//註意空間複雜度O(1) 即不能開闢新的輔助空間
#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;   //數據域
    struct LNode *next;   //指向後繼結點
}LinkNode;   // 聲明單鏈表結點類型

//尾插法建立單鏈表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    int i;
    L=(LinkNode *)malloc(sizeof(LinkNode));   //創建頭結點
    r=L;   //r始終指向尾結點，開始時指向頭結點
    for (int i = 0; i < n; i++)
    {
        //創建新結點s
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        r->next=s;   //將s插入r之後
        r=s;
    }
    r->next=NULL;    //尾結點next域置為NULL
}
//輸出單鏈表
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;   //p指向首節點
    while(p!=NULL)
    {
        printf("%d ",p->data );   // p不為NULL,輸出p結點的數據域
        p=p->next;    // p移向下一個結點
    }
    printf("\n");
}
//銷毀單鏈表
void DestroyList(LinkNode *L)
{
    LinkNode *pre=L,*p=L->next;    //pre指向頭結點，p指向首節點
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;   // pre、p同步後移一個結點
    }
    free(pre);    // 此時p為NULL,pre指向尾結點,釋放它
}
//合併
void MergeList(LinkNode *L1,LinkNode *L2,LinkNode *&L3)
{
    LinkNode *p = L1->next;
    LinkNode *q = L2->next;
    LinkNode *r;

    L3=L1;
    // r指向新建單鏈表L3的尾結點
    r=L3;
    //釋放L2頭結點
    free(L2);
    while(p!=NULL&&q!=NULL)
    {
        r->next=p;
        r=p;
        p=p->next;

        r->next=q;
        r=q;
        q=q->next;
    }
    r->next=NULL;
    if(q!=NULL)
        p=q;
    r->next=p;
}

int main()
{
    LinkNode *L1, *L2, *L3;
    ElemType a[] = {1,2,3,4,5,6,7,8};
    int n = 8;

    CreateListRear(L1,a,n);
    printf("單鏈表L1:");
    DispList(L1);
	
	ElemType b[] = {20,19,18,17};
    n = 4;
    CreateListRear(L2,b,n);
    printf("單鏈表L2:");
    DispList(L2);
    printf("L1和L2合併產生L3\n");
    MergeList(L1,L2,L3);
    printf("單鏈表L3:");
    DispList(L3);
    DestroyList(L3);
}

8、求集合（用單鏈表表示）的並集、交集、差集運算

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

//重點題型，掌握並集、交集、差集的實現

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkList;


/* 單鏈表的初始化 */
void InitList(LinkList *&L)
{
    L = (LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}

//向單鏈表中插入數據元素
bool ListInsert(LinkList *&L,int x,char e)
{
    int j = 0;
    LinkList *p = L, *s;
    while(p!=NULL && j<x-1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        s = (LinkList *)malloc(sizeof(LinkList));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}

//輸出單鏈表
void DispList(LinkList *L)
{
    LinkList *p = L->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
}

// 求單鏈表的長度
int ListLength(LinkList *L)
{
    LinkList *p = L->next;
    int i = 0;
    while(p!=NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}

// 查看單鏈表是否為空
bool ListEmpty(LinkList *L)
{
    return L->next==NULL;
}

//求單鏈表中某個數據元素值
bool GetElem(LinkList *L,int i, ElemType &e)
{
    LinkList *p = L;
    int j = 0;
    while(p!=NULL && j < i)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        e = p->data;
        return true;
    }
}

// 在單鏈表中查找元素
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p = L;
    int i = 0;
    while(p!=NULL && p->data!=e)
    {
        p = p->next;
        i++;
    }
    if(p==NULL)
    {
        return 0;
    }
    else
    {
        return i;
    }
}

//刪除單鏈表中第 i 個元素
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j = 0;
    LinkList *p = L, *q;
    while(p!=NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
        return false;
    else
    {
        q = p->next;
        if(q==NULL)
            return false;
        e = q->data;
        p->next = q->next;
        free(q);
        return true;
    }
}

//銷毀單鏈表
void DestroyList(LinkList *&L)
{
    LinkList *p = L;
    LinkList *q = p->next;
    while(q!=NULL)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//將集合 a 和 b 中的元素添加到順序表 ha 和 hb 中
void CreateListR(LinkList *&L,ElemType e[],int n)
{
    InitList(L);
    int i;
    for(i = 0;i < n; ++i)
    {
        if(!LocateElem(L,e[i]))
            ListInsert(L,i+1,e[i]);
    }
}

//選擇排序
void sort(LinkList *&L)
{
    LinkList *p , *pre, *q, *k;
    InitList(p);
    int i = 0;
    int c;
    while(!ListEmpty(L))
    {
        pre = L ->next;
        c = pre->data;
        while(pre!=NULL)
        {
            if(c>=pre->data)
                c = pre->data;
            pre = pre->next;
        }
        ListInsert(p,++i,c);
        int tag = LocateElem(L,c);
        ListDelete(L,tag,c);
    }
    L = p;
}

//並集 
void Union(LinkList *a,LinkList *b,LinkList *&c)
{
    InitList(c);
    LinkList *p = a->next;
    LinkList *q = b->next;
    int k = 0;
    while(p!=NULL && q!=NULL)
    {
        if(p->data < q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            k++;
        }
        else if(p->data == q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            q = q->next;
            k++;
        }
        else
        {
            ListInsert(c,k+1,q->data);
            q = q->next;
            k++;
        }
    }
    while(p!=NULL)
    {
        ListInsert(c,k+1,p->data);
        p = p->next;
        k++;
    }
    while(q!=NULL)
    {
        ListInsert(c,k+1,q->data);
        q  = q->next;
        k++;
    }
}

//交集 a中元素一個個取出，通過LocateElem函數看b中是否出現，出現則copy至c
void InsterSect(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}

//差集 a中元素一個個取出，通過LocateElem函數看b中是否出現，不出現則copy至c
void Subs(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(!LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}


int main( )
{
    LinkList *ha, *hb, *hc;
    ElemType a[]={1,2,3,4};
    ElemType b[]={10,4,22,5,81,2};
    printf("集合的運算如下\n");
    CreateListR(ha,a,4);
    CreateListR(hb,b,6);
    printf("原 集 合 A: "); DispList(ha);
    printf("原 集 合 B: "); DispList(hb);
    sort(ha);
    sort(hb);
    printf("有序集合A："); DispList(ha);
    printf("有序集合B："); DispList(hb);
    Union(ha,hb,hc);
    printf("集合的並C："); DispList(hc);
    InsterSect(ha,hb,hc);
    printf("集合的交C："); DispList(hc);
    Subs(ha,hb,hc);
    printf("集合的差C："); DispList(hc);
    DestroyList(ha);
    DestroyList(hb);
    DestroyList(hc);
}

9、求兩個多項式的相加運算

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

//學習自CSDN作者-man_zuo

typedef struct 
{
    float coef;   //繫數
    int expn;   //指數   
}Term;
typedef struct Ploynomial
{
    Term term;
    Ploynomial *next;
}Ploynomial,*LinkList;

//初始化單鏈表
void InitList(LinkList &L)
{
    L= (Ploynomial*)malloc(sizeof(Ploynomial));//頭結點
    L->term.coef=0.0;
    L->term.expn=-1;
    L->next=NULL;
}
//比較結點的繫數大小函數
int cmp(Term a,Term b)
{
    if (a.expn>b.expn) return -1;
    else if(a.expn==b.expn) return 0;
    else return 1;
}
//將結點插入多項式鏈表的適當位置，可以同時起到創建鏈表和多項式相加的功能
void insertNode(LinkList &L,Term e)
{
    Ploynomial *q=L;
    while(q->next!=NULL)
    {   //如果當前結點q的下一個結點的指數 大於 要插入的結點的指數
        if (cmp(q->next->term,e)<0)
        {
           q=q->next; 
        }
        else break;   //此時， q.term.expn>e.expn >=q->next->term.expn
    }
    if (q->next!=NULL&&cmp(q->next->term,e)==0)
    {   //指數相同，繫數相加
        q->next->term.coef+=e.coef;
    }
    else
    {
        Ploynomial *node = (Ploynomial *)malloc(sizeof(Ploynomial));
        node->term.coef=e.coef;
        node->term.expn=e.expn;
        if(q->next==NULL)
            node->next=NULL;    //如果q結點為尾結點，則node的指針域設為NULL
        else
            node->next=q->next;     //否則node的指針域指向q的下一個結點
        q->next=node;//將node結點插入鏈表中
    }
}
//輸入m項的繫數和指數，建立表示一元多項式的有序鏈表L，演示功能，無需學習
void CreatePolyn(LinkList &L,int n)
{
    Term e;
    InitList(L);
    for (int i = 1; i <= n; i++)
    {
        printf("\n第%d項的繫數和指數：",i);
        scanf("%f%d",&e.coef,&e.expn);
        insertNode(L,e);    
    }
}
//用L返回L1+L2的結果
void addPolyn(LinkList &L,LinkList L1,LinkList L2)
{
    Ploynomial *q;
    for (q=L1->next; q!=NULL; q=q->next)
    {
        insertNode(L,q->term);   //將L1的每一項插入到L中
    }
    for (q=L2->next; q!=NULL; q=q->next)
    {
        insertNode(L,q->term);   //將L2的每一項插入到L中
    }
}

//以類數學表達式的形式列印輸出一元多項式L,演示功能，無需學習
void visitList(LinkList L)
{
    Ploynomial *q=L;
    int flag;
    while(q->next!=NULL)
    {
        q=q->next;
        flag=1;
        if(q->term.coef==0) continue;//繫數為0 不輸出
        if(q->term.expn==0&&flag==1) //指數為1
        {
            if(q->term.coef>0)
                printf("+%.2f",q->term.coef);
            else
                printf("%.2f",q->term.coef);
            flag=0;
        }
        if((q->term.coef==1||q->term.coef==-1)&&flag==1)//繫數為1
        {
            if(q->term.expn==1){
                if(q->term.coef==1)
                   printf("+X");
                else
                   printf("-X");
            }else{
                if(q->term.coef==1)
                    printf("+X^%d",q->term.expn);
                else
                    printf("-X^%d",q->term.expn);
            }
            flag=0;
        }
        if(flag==1)
        {
            if(q->term.coef>0)
                printf("+%.2fX^%d",q->term.coef,q->term.expn);
            else
                printf("%.2fX^%d",q->term.coef,q->term.expn);
        }

    }
    printf("\n");
}

int main()
{
    LinkList L1,L2;
    int n1,n2;
    printf("請輸入多項式L1的項數：");
    scanf("%d",&n1);
    CreatePolyn(L1,n1);
    printf("請輸入多項式L2的項數：");
    scanf("%d",&n2);
    CreatePolyn(L2,n2);
    printf("\n多項式L1:  ");
    visitList(L1);
    printf("\n多項式L2:  ");
    visitList(L2);
    LinkList add;
    InitList(add);
    addPolyn(add,L1,L2);
    printf("\nL1 + L2:   ");
    visitList(add);
}

10、求兩個多項式的相乘運算

//用L返回L1*L2的結果
//將該方法加入第九題中即可，書寫主方法即可
void multiplyPolyn(LinkList &L,LinkList L1,LinkList L2)
{
    Ploynomial *p,*q;
    Term term;
    term.coef=0.0;
    term.expn=0;
    for(q=L1->next; q!=NULL; q=q->next)
    {
        for(p=L2->next; p!=NULL; p=p->next)
        {
            term.coef=(q->term.coef)*(p->term.coef);//繫數相乘
            term.expn=(q->term.expn)+(p->term.expn);// 指數想加
            insertNode(L,term);
        }
    }
}

11、用單鏈表實現兩個大整數的相加運算

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MAX_SIZE 50

//學習於CSDN作者-靜能生悟，本題重點在於學習add操作，以及為什麼要reverse

typedef struct node
{
    int data;
    struct node *next;
}NodeType;

//創建整數單鏈表
void createList(NodeType *&h,char a[],int n)
{
    NodeType *p,*r;
    int i=0;
    //創建頭結點
    h=(NodeType *)malloc(sizeof(NodeType));
    r=h;   //r指向新創建的頭結點
    while(i<n)
    {
        //創建新結點p
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=a[n-i-1]-'0';
        //將p插入r之後
        r->next=p;
        //r指向新結點
        r=p;
        i++;
    }
    r->next=NULL;
}
//輸出單鏈表
void dispList(NodeType *h)
{
    NodeType *p = h->next; // p指向整數單鏈表的第一個數據結點

    while(p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}
//銷毀單鏈表
void destoryList(NodeType *&h)
{
    NodeType *pre=h;   // pre指向整數單鏈表的頭結點
    NodeType *p=pre->next;   // p指向整數單鏈表的第一個數據結點(首節點)
    while(p!=NULL)
    {
        free(pre);
        pre=p;   //pre,p同步後移一個結點
        p=p->next;
    }
    free(pre);
}
//兩整數單鏈表h1和h2相加得到h
void addList(NodeType *h1,NodeType *h2,NodeType *&h)
{
    NodeType *p1=h1->next;   //p1指向單鏈表h1中的第一個數據結點
    NodeType *p2=h2->next;   //p2指向單鏈表h2中的第一個數據結點
    NodeType *p,*r;
    int carry = 0;

    //創建頭結點
    h=(NodeType *)malloc(sizeof(NodeType));
    // r指向新創建頭結點
    r=h;
    while(p1!=NULL&&p2!=NULL)
    {
        //創建新結點p
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=(p1->data+p2->data+carry)%10;   // 求餘
        // 將新結點p插入到r指向的頭結點之後
        r->next=p;
        // r後移一個結點
        r=p;
        carry=(p1->data+p2->data+carry)/10;   //求商
        // p1和p2指向下一個結點
        p1 = p1->next;
        p2 = p2->next;
    }
    if(p1!=NULL)
        p1=p2;
    while(p1!=NULL)
    {
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=(p1->data+carry)%10;    // 數據域
        // 將新結點p插入到r指向的頭結點之後
        r->next=p;
        // r後移一個結點
        r=p;
        carry=(p1->data+carry)/10;
        p1=p1->next;
    }
    // 最後carry不為0時,創建一個結點存放它
    if(carry>0)
    {
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=carry;
        // 將新結點p插入到r指向的頭結點之後
        r->next = p;
        // r後移一個結點
        r = p;
    }
    r->next=NULL;
}
//逆置整數單鏈表h
void reverseList(NodeType *&h)
{
    NodeType *p=h->next,*q;
    h->next=NULL;
    while(p!=NULL)
    {
        q=p->next;
        p->next=h->next;
        h->next=p;
        p=q;
    }
}

//求整數單鏈表h的中間位
/**
*   演算法設計思路:
*   定義快指針quick和慢指針slow,初始時都指向頭結點,當快指針沒有
*   掃描完整數單鏈表h時,每次讓慢指針slow前進一個結點,快指針quick前進兩個
*   結點.當快指針到達鏈表尾時,慢指針slow指向的結點就是中間結點.
*/
int midList(NodeType *h)
{
    NodeType *slow=h;   //定義慢指針
    NodeType *quick=h;   //定義快指針
    while(quick!=NULL&&quick->next!=NULL)
    {
        slow=slow->next;   // 慢指針slow前進一個結點
        quick=quick->next->next;   // 快指針quick前進兩個結點
    }
    return slow->data;
}

int main(int argc, char const *argv[])
{
    NodeType *h1,*h2,*h;
    char s[MAX_SIZE],t[MAX_SIZE];
    printf("(1)輸入大整數a: ");
    scanf("%s", s);
    printf("(2)輸入大整數b: ");
    scanf("%s", t);
    createList(h1,s,strlen(s));
    createList(h2,t,strlen(t));
    printf("(3)整數單鏈表a: ");
    dispList(h1);
    printf("(4)整數單鏈表b: ");
    dispList(h2);
    addList(h1,h2,h);
    printf("(5)結果單鏈表c: ");
    dispList(h);
    reverseList(h);
    printf("(6)對應的整數c: ");
    dispList(h);
    printf("(7)中間位: %d", midList(h));
    destoryList(h);
    destoryList(h1);
    destoryList(h2);

    return 0;
}


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • numpy學習之思維導圖
    使用請註明出處 整理不易 ...
  • APM 上報信息分析與應用
    在入正題之前我們再回顧下它的架構圖： 本文章主要分析AMP各索引的作用，與及結合1.7環境上已接入的服務數據對比後，對索引中的主要欄位進行解析。文章分為四個小章節。 1、索引類型 apm索引分為四種類型： 系統指標索引(System status metrics)，索引名稱格式：apm-versio ...
  • Python--集合
    集合（set）是一個無序的不重覆元素序列。 可以使用大括弧 { } 或者 set() 函數創建集合，註意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。 創建格式：list_1 = {value01,value02,...} 或者 set(value) 集合作 ...
  • Python--文件操作（操作文件）
    文件的操作包含：讀、寫、修改 文件的多種操作： 1 # 讀取文件的所有內容 2 data = open("yesteday.txt", encoding="utf-8") .read() 3 print(data) 4 5 ''' f:文件句柄（包含這個文件的文件名，字元集，大小，在硬碟中的起始位置 ...
  • JAVA設計模式之原型模式（prototype）
    原型模式： 原型模式又叫克隆模式 Java自帶克隆模式 實現克隆模式必須實現Cloneable 介面，如果不實現會發生java.lang.CloneNotSupportedException異常 當某個類的屬性已經設定好需要創建很多相同屬性值的對象的時候使用clone模式非常方便 使用clone模式 ...
  • C++98/11/17表達式類別
    從C++98到C++17，表達式類別與時俱進地改變著。引用綁定、auto、decltype、拷貝省略等功能與表達式類別息息相關。 ...
  • Python 網路編程 netaddr
    1.安裝 netaddr 組件 pip install netaddr -i https://mirrors.aliyun.com/pypi/simple/ from netaddr import IPNetwork print('https://ipjisuanqi.com/#121.224.14 ...
  • 因為一個變數命名的關係中斷了一個while 迴圈
    因為一個變數命名的關係中斷了一個while 迴圈，有點意思，什麼原因？ IDE: Pycharm Community Edition 一、變數命名為 input , 中斷了while 迴圈，不能迴圈提示輸入： def isNum(x): if isinstance(x,int): return Tr ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類