主頁 > 後端開發 > 資料結構上機實驗（2）

資料結構上機實驗（2）

2020-09-13 12:22:30 後端開發

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=https://www.cnblogs.com/wangzheming35/p/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; idata=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(jnext;
    }
    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(jnext;
    }
    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(jnext;
    }
    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=https://www.cnblogs.com/wangzheming35/p/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(jnext;
    }
    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(jnext;
    }
    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(jnext;
    }
    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 = https://www.cnblogs.com/wangzheming35/p/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 = https://www.cnblogs.com/wangzheming35/p/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=https://www.cnblogs.com/wangzheming35/p/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->datanext;
            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=https://www.cnblogs.com/wangzheming35/p/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 = https://www.cnblogs.com/wangzheming35/p/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=https://www.cnblogs.com/wangzheming35/p/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=https://www.cnblogs.com/wangzheming35/p/(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;
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/24344.html

標籤：C

上一篇：手把手教系列之FIR濾波器設計

下一篇：實用演算法系列之RT-Thread鏈表堆管理器

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂