數據結構上機實驗（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
  • GoF之工廠模式
    GoF之工廠模式 @目錄GoF之工廠模式每博一文案1. 簡單說明“23種設計模式”1.2 介紹工廠模式的三種形態1.3 簡單工廠模式（靜態工廠模式）1.3.1 簡單工廠模式的優缺點:1.4 工廠方法模式1.4.1 工廠方法模式的優缺點:1.5 抽象工廠模式1.6 抽象工廠模式的優缺點：2. 總結:3 ...
  • dotnet C# 簡單的追加文件夾到 ZipArchive 壓縮文件的方法
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • Elasticsearch 系列（六）- ES數據同步和ES集群
    本章將和大家分享ES的數據同步方案和ES集群相關知識。廢話不多說，下麵我們直接進入主題。 一、ES數據同步 1、數據同步問題 Elasticsearch中的酒店數據來自於mysql資料庫，因此mysql數據發生改變時，Elasticsearch也必須跟著改變，這個就是Elasticsearch與my ...
  • 自動化測試數據生成：Asp.Net Core單元測試利器AutoFixture詳解
    引言 在我們之前的文章中介紹過使用Bogus生成模擬測試數據，今天來講解一下功能更加強大自動生成測試數據的工具的庫"AutoFixture"。 什麼是AutoFixture? AutoFixture 是一個針對 .NET 的開源庫，旨在最大程度地減少單元測試中的“安排（Arrange）”階段，以提高 ...
  • .NET Emit 入門教程：第七部分：實戰項目1：將 DbDataReader 轉實體
    經過前面幾個部分學習，相信學過的同學已經能夠掌握 .NET Emit 這種中間語言，並能使得它來編寫一些應用，以提高程式的性能。隨著 IL 指令篇的結束，本系列也已經接近尾聲，在這接近結束的最後，會提供幾個可供直接使用的示例，以供大伙分析或使用在項目中。 ...
  • Windows下綁定線程到指定的CPU核心
    當從不同來源導入Excel數據時，可能存在重覆的記錄。為了確保數據的準確性，通常需要刪除這些重覆的行。手動查找並刪除可能會非常耗費時間，而通過編程腳本則可以實現在短時間內處理大量數據。本文將提供一個使用C# 快速查找並刪除Excel重覆項的免費解決方案。 以下是實現步驟： 1. 首先安裝免費.NET ...
  • mORMot 1.18 第07章 簡單的讀寫操作
    C++ 異常處理 C++ 異常處理機制允許程式在運行時處理錯誤或意外情況。它提供了捕獲和處理錯誤的一種結構化方式，使程式更加健壯和可靠。 異常處理的基本概念： 異常: 程式在運行時發生的錯誤或意外情況。 拋出異常: 使用 throw 關鍵字將異常傳遞給調用堆棧。 捕獲異常: 使用 try-catch ...
  • mORMot 1.18 第06章 概念
    優秀且經驗豐富的Java開發人員的特征之一是對API的廣泛瞭解，包括JDK和第三方庫。 我花了很多時間來學習API，尤其是在閱讀了Effective Java 3rd Edition之後 ，Joshua Bloch建議在Java 3rd Edition中使用現有的API進行開發，而不是為常見的東西編 ...
  • php 開發規範
    框架 · 使用laravel框架，原因：tp的框架路由和orm沒有laravel好用 · 使用強制路由，方便介面多時，分多版本，分文件夾等操作 介面 · 介面開發註意欄位類型，欄位是int，查詢成功失敗都要返回int（對接java等強類型語言方便） · 查詢介面用GET、其他用POST 代碼 · 所 ...
  • 2024 年 4 月 28 日 周日 晴 熱（1253 字）
    正文 下午找企業的人去鎮上做貸後。 車上聽同事跟那個司機對罵，火星子都快出來了。司機跟那同事更熟一些，連我在內一共就三個人，同事那一手指桑罵槐給我都聽愣了。司機也是老社會人了，馬上聽出來了，為那個無辜的企業經辦人辯護，實際上是為自己辯護。 “這個事情你不能怪企業。”“但他們總不能讓銀行的人全權負責， ...
所有分類