链表的操作

已于 2024-02-21 20:01:36 修改
阅读量422 收藏 5
点赞数 6
文章标签： 链表 数据结构
于 2024-02-20 19:31:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50951387/article/details/136197261
版权

单向链表

主函数

#include "./link.h"

int main(int argc, const char *argv[])
{
    linkList *list=create_linkList();
    /*delete_head_linkList(list);
    delete_tail_linkList(list);
    insert_head_linkList(list,50);
    printf("%d\n",list->text.len);
    insert_head_linkList(list,30);
    insert_head_linkList(list,40);
    insert_head_linkList(list,60);
    insert_head_linkList(list,10);
    show_linkList(list);
    insert_tail_linkList(list,12);
    insert_tail_linkList(list,15);
    show_linkList(list);
    delete_head_linkList(list);
    show_linkList(list);
    delete_tail_linkList(list);
    show_linkList(list);
    add_linkList(list,6,99);
    show_linkList(list);
    delete_linkList(list,1);
    show_linkList(list);*/
    insert_sort(list,15);
    insert_sort(list,19);
    insert_sort(list,10);
    insert_sort(list,21);
    insert_sort(list,18);
    insert_sort(list,1);
    show_linkList(list);
    return 0;
}

头文件

#ifndef __LINK_H__
#define __LINK_H__
#include <stdio.h>
#include <stdlib.h>
typedef int dataType;

union msg{
    dataType data;
    int len;
};

typedef struct node{
    union msg text;
    struct node *next;
}linkList;
linkList* create_linkList(void);
void insert_head_linkList(linkList* list,dataType num);
void show_linkList(linkList* head);
void insert_tail_linkList(linkList* list,dataType num);
void delete_head_linkList(linkList* head);
void delete_tail_linkList(linkList* tail);
void add_linkList(linkList* head,int place,dataType num);
void delete_linkList(linkList* head,int place);
void insert_sort(linkList* head,dataType num);
#endif

功能文件

#include "./link.h"

/*
 * function:    创建链表
 * @param [ in] 
 * @param [out] 
 * @return      
 */

linkList* create_linkList(void){
    linkList* head = (linkList*)malloc(sizeof(linkList));
    if(NULL==head){
        printf("头结点申请失败，创建单链表失败\n");
        return NULL;
    }
    head->text.len=0;
    head->next=NULL;
    return head;

}

/*
 * function:    从头插入数据
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void insert_head_linkList(linkList* list,dataType num){
    linkList *temp=(linkList*)malloc(sizeof(linkList));
    if(NULL==temp){
        printf("创建节点失败\n");
        return;
    }
    temp->next=list->next;
    temp->text.data=num;
    list->next=temp;
    list->text.len++;
    printf("插入成功\n");
    return;
}

/*
 * function:    遍历链表
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void show_linkList(linkList* head){
    linkList *p=head;
    while(p->next!=NULL){
        p=p->next;
        printf("%d ",p->text.data);
    }
    printf("\n");
    return ;
}
/*
 * function:    尾插法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
                                                                                         
void insert_tail_linkList(linkList* list,dataType num){
    linkList *p=list;
    linkList* temp=(linkList*)malloc(sizeof(linkList));
    if(NULL==temp){
        printf("节点申请失败\n");
        return;
    }

    while(p->next!=NULL){
        p=p->next;
    }
    p->next=temp;
    temp->text.data=num;
    temp->next=NULL;
    list->text.len++;
    printf("尾插成功\n");
    return ;
}
/*
 * function:    判断链表是否为空
 * @param [ in] 
 * @param [out] 
 * @return  空则返回0    
 */

int isEmpty_linkList(linkList* head){
    return head->next==NULL?0:1;
}
/*
 * function:    头部删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void delete_head_linkList(linkList* head){
    if(isEmpty_linkList(head)==0){
        printf("头删除失败\n");
        return;
    }
    linkList* temp=NULL;
    temp=head->next;
    head->next=temp->next;
    free(temp);
    temp=NULL;
    head->text.len--;
    return ;
}
/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return                                                            
 */

void delete_tail_linkList(linkList* tail){
    if(isEmpty_linkList(tail)==0){
        printf("尾删除失败\n");
        return;
    }
    linkList* p=tail;
    linkList* temp=NULL;
    while(p->next!=NULL){
        temp=p;
        p=p->next;
    }
    temp->next=NULL;
    free(p);
    p=NULL;
    tail->text.len--;
    return;
}

/*
 * function:    按位置操作——插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void add_linkList(linkList* head,int place,dataType num){
    if(place>0&&place<=head->text.len+1){
        linkList* p=head;
        linkList* pt=NULL;
        for(int i=0;i<place;i++){
            pt=p;
            p=p->next;
        }
        linkList* temp=(linkList*)malloc(sizeof(linkList));
        if(temp==NULL){
            printf("节点申请失败\n");
            return ;
        }
        pt->next=temp;
        temp->text.data=num;
        temp->next=p;
        head->text.len++;
    }
    else{
        printf("操作位置错误\n");
    }
    return;
}
/*
 * function:    按位置操作——删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */                                                                                            
void delete_linkList(linkList* head,int place){
    if(place>0&&place<=head->text.len){
        linkList* p=head;
        linkList* pt=NULL;
        if(isEmpty_linkList(head)==0){
            printf("链表为空，无法删除\n");
            return;
        }
        for(int i=0;i<place;i++){
            pt=p;
            p=p->next;
        }
        pt->next=p->next;
        free(p);
        p=NULL;
        head->text.len--;
    }
    else{
        printf("删除位置错误\n");
    }
    return ;
}

/*
 * function:    链表翻转
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void flip_linkList(linkList* head){
    if(isEmpty_linkList(head)==0){
        printf("链表为空，无法翻转");
        return ;
    }
    linkList* p=head;
    while(p->next->next!=NULL){
        p=p->next;
    }
    linkList* temp=p;
    for(int i=1;i<head->text.len;i++){
    }

}

/*
 * function:    直接插入排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void insert_sort(linkList* head,dataType num){

    linkList* temp=(linkList*)malloc((sizeof(linkList)));
    if(temp==NULL){
        printf("节点申请失败\n");
        return ;
    }

    temp->text.data=num;
    temp->next=NULL;
    linkList* p=head;
    if(head->next==NULL){
        head->next=temp;
        head->text.len++;
    }
    while(p->next!=NULL){
        if(num<p->next->text.data){
            break;
        }else
            p=p->next;
    }
    temp->next=p->next;
    p->next=temp;

    head->text.len++;
    return;

}

单向循环链表

头文件

#ifndef __LOOP_H__
#define __LOOP_H__
#include <stdio.h>
#include <stdlib.h>

typedef int dataType;
union msg{
    dataType data;
    int len;
};

typedef struct node{
    union msg text;
    struct node *next;
}LooplinkList;
LooplinkList* create_looplinkList(void);
void insertetail_loopLinkList(LooplinkList* head,dataType num);
void show_loopLinkList(LooplinkList* head);
void insertehead_loopLinkList(LooplinkList* head,dataType num);
void deletetail_looplinkList(LooplinkList* head);
void deletehead_looplinkList(LooplinkList* head);
void inserte_LooplinkList(LooplinkList* head,int loca,dataType num);
#endif

主函数 

#include "./loopLinkList.h"                       
/*                                                
 * function:    创建循环链表                      
 * @param [ in]                                   
 * @param [out]                                   
 * @return                                        
 */                                               
int main(int argc, const char *argv[])            
{                                                 
    LooplinkList* list=create_looplinkList();     
    insertetail_loopLinkList(list,11);            
    insertehead_loopLinkList(list,12);            
    insertehead_loopLinkList(list,13);            
    insertehead_loopLinkList(list,14);            
    insertetail_loopLinkList(list,15);            
    insertetail_loopLinkList(list,16);            
    show_loopLinkList(list);                      
    deletehead_looplinkList(list);                
    show_loopLinkList(list);                      
    deletetail_looplinkList(list);                
    show_loopLinkList(list);                      
    inserte_LooplinkList(list,5,99);              
    show_loopLinkList(list);                      
    return 0;                                     
}

 功能函数

1 #include "./loopLinkList.h"
2 
3 LooplinkList* create_looplinkList(void){
4     LooplinkList* head=(LooplinkList*)malloc(sizeof(LooplinkList));
5     if(head==NULL){
6         printf("创建循环链表失败!!\n");
7         return NULL;
8     }
9     head->next=head;
0     return head;
1 }
2 /*
3  * function:    头插法
4  * @param [ in] 
5  * @param [out] 
6  * @return      
7  */
8 
9 void insertehead_loopLinkList(LooplinkList* head,dataType num){
0     LooplinkList* temp=(LooplinkList* )malloc(sizeof(LooplinkList));
1     if(temp == NULL){
2         printf("申请节点失败\n");
3         return;
4     }
5     temp->next=head->next;
6     temp->text.data=num;
7     head->next=temp;
8     head->text.len++;
9     return;
0 }
1 
2 /*
3  * function:    尾插法
4  * @param [ in] 
5  * @param [out] 
6  * @return      
7  */
8 
9 void insertetail_loopLinkList(LooplinkList* head,dataType num){
0     LooplinkList* temp=(LooplinkList*)malloc(sizeof(LooplinkList));
1     if(temp == NULL){
2         printf("申请节点失败\n");
3         return;
4     }
5     LooplinkList* p=NULL;
6     p=head->next;
7     while(p->next!=head){
8         p=p->next;                                                                                                                                                
9     }
0     temp->next=head;
1     temp->text.data=num;
2     p->next=temp;
3     head->text.len++;
4     return;
5 }
6 
7 /*
8  * function:    遍历
9  * @param [ in] 
0  * @param [out] 
1  * @return      
2  */
3 
4 void show_loopLinkList(LooplinkList* head){
5     LooplinkList* p=NULL;
6     p=head;
7     while(p->next!=head){
8         p=p->next;
9         printf("%d ",p->text.data);
0     }
1     printf("\n");
2     return;
3 }
4 
5 /*
6  * function:    头删除法
7  * @param [ in] 
8  * @param [out] 
9  * @return      
0  */
1 
2 void deletehead_looplinkList(LooplinkList* head){
3     if(head->next==head){
4         printf("链表为空，无法删除\n");
5         return ;
6     
7     LooplinkList* p;
8     p=head->next;
9     head->next=p->next;
0     head->text.len--;
1     free(p);
2     p=NULL;
3     return;
4 }
5 
6 
7 /*
8  * function:    尾删除法
9  * @param [ in] 
0  * @param [out] 
1  * @return      
2  */
3 
4 void deletetail_looplinkList(LooplinkList* head){
5     if(head->next==head){
6         printf("链表为空，无法删除\n");
7         return ;
8     }
9     LooplinkList* p=head;
0 
1     while(p->next->next!=head){
2         p=p->next;
3     }
4     free(p->next);
5     p->next=head;
6     return;
7 }
8 
9 
0 /*
1  * function:    按位置插入
2  * @param [ in] 
3  * @param [out] 
4  * @return      
5  */
6 
7 void inserte_LooplinkList(LooplinkList* head,int loca,dataType num)
8 {
9     LooplinkList* temp=(LooplinkList*)malloc(sizeof(LooplinkList));
0     if(temp==NULL){
1         printf("申请节点失败\n");
2         return;
3     }
4     LooplinkList* p=head;
5     for(int i=0;i<loca-1;i++){
6         if(p->next==head){
7             p=p->next->next;
8         }
9         p=p->next;
0     }
1     temp->next=p->next;
2     temp->text.data=num;
3     p->next=temp;
4     head->text.len++;
5 
6     return;
7 }

双向链表

头文件

#ifndef __LINK_H__                                          
#define __LINK_H__                                          
                                                            
#include <stdio.h>                                          
#include <stdlib.h>                                         
typedef int dataType;                                       
                                                            
union msg{                                                  
    dataType data;                                          
    int len;                                                
};                                                          
                                                            
typedef struct node{                                        
    union msg text;                                         
    struct node *next;                                      
    struct node *prve;                                      
}doubleLink;                                                
                                                            
void insert_Bypos(doubleLink* head,int pos,dataType num);   
void delete_Head(doubleLink* head);                         
doubleLink* create_doublelink(void);                        
void instert_Head(doubleLink* head,dataType num);           
void show_doublelink(doubleLink* head);                     
void instert_Tail(doubleLink* head,dataType num);           
void delete_Tail(doubleLink* head);                         
void delete_Bypos(doubleLink* head,int pos);                
#endif

主函数

#include "./dooubleLink.h"                      
                                                
int main(int argc, const char *argv[])          
{                                               
    doubleLink* list = create_doublelink();     
    instert_Head(list,12);                      
    instert_Head(list,13);                      
    instert_Head(list,14);                      
    show_doublelink(list);                      
    instert_Tail(list,11);                      
    show_doublelink(list);                      
    insert_Bypos(list,2,66);                    
    insert_Bypos(list,99,1000);                 
    show_doublelink(list);                      
    delete_Head(list);                          
    show_doublelink(list);                      
    delete_Tail(list);                          
    show_doublelink(list);                      
    delete_Bypos(list,1);                       
    show_doublelink(list);                      
    delete_Bypos(list,2);                       
    show_doublelink(list);                      
    return 0;                                   
}

功能函数

  1 #include "./dooubleLink.h"
  2 
  3 /*
  4  * function:    创建双向链表
  5  * @param [ in] 
  6  * @param [out] 
  7  * @return      
  8  */
  9 
 10 doubleLink* create_doublelink(void){
 11     doubleLink* head=(doubleLink*)malloc(sizeof(doubleLink));
 12     if(head==NULL){
 13         printf("创建双向链表失败\n");
 14         return NULL;
 15     }
 16     head->next=NULL;
 17     head->prve=NULL;
 18     head->text.len=0;
 19     return head;
 20 }
 21 
 22 
 23 /*
 24  * function:    遍历
 25  * @param [ in] 
 26  * @param [out] 
 27  * @return      
 28  */
 29 void show_doublelink(doubleLink* head){
 30     doubleLink* p=head;
 31     while(p->next!=NULL){
 32         p=p->next;
 33         printf("%d ",p->text.data);
 34     }
 35     printf("\n");
 36     return;
 37 
 38 }
 39 
 40 /*
 41  * function:    头插法
 42  * @param [ in] 
 43  * @param [out] 
 44  * @return      
 45  */
 46 void instert_Head(doubleLink* head,dataType num){
 47     doubleLink* temp=(doubleLink*)malloc(sizeof(doubleLink));
 48     if(temp==NULL){
 49         printf("申请节点失败\n");
 50         return;
 51     }
 52 
 53     temp->next=NULL;
 54     temp->prve=NULL;
 55     temp->text.data=num;
 56     
 57     if(head->next==NULL){
 58         temp->next=head->next;
 59         head->next=temp;
 60         temp->prve=head;
 61     }
 62     else{
 63         temp->next=head->next;
 64         head->next=temp;
 65         temp->next->prve=temp;
 66         temp->prve=head;
 67     }
 68     head->text.len++;
 69     return ;
 70 }
 71 
 72 
 73 /*
 74  * function:    尾插法
 75  * @param [ in] 
 76  * @param [out] 
 77  * @return      
 78  */
 79 
 80 void instert_Tail(doubleLink* head,dataType num){
 81     doubleLink* temp=(doubleLink*)malloc(sizeof(doubleLink));
 82     if(temp==NULL){
 83         printf("申请节点失败\n");
 84         return;
 85     }
 86     temp->next=NULL;
 87     temp->prve=NULL;
 88     temp->text.data=num;
 89     doubleLink* p=head;
 90     while(p->next!=NULL){
 91         p=p->next;
 92     }
 93     temp->next=p->next;
 94     p->next=temp;
 95     temp->prve=p;
 96     head->text.len++;
 97     return;
 98 }
 99  /*
100   * function:    按位置插入
101   * @param [ in] 
102   * @param [out] 
103   * @return      
104   */
105 
106 void insert_Bypos(doubleLink* head,int pos,dataType num){
107     doubleLink* temp=(doubleLink*)malloc(sizeof(doubleLink));
108     if(temp==NULL){
109         printf("申请节点失败\n");
110         return;
111     }
112     temp->next=NULL;
113     temp->prve=NULL;
114     temp->text.data=num;
115     if(pos<1||pos>head->text.len){
116         printf("位置不合法\n");
117         return;
118     }
119     doubleLink* p=head;
120     for(int i=0;i<pos-1;i++){
121         p=p->next;
122     }
123     if(p->next!=NULL){
124         temp->next=p->next;
125         p->next=temp;
126         temp->next->prve=temp;
127         temp->prve=p;
128     }
129     else{
130         temp->next=p->next;
131         p->next=temp;
132         temp->prve=p;
133     }
134     head->text.len++;
135     return;
136 }
137 
138 
139 /*
140  * function:    头删除法
141  * @param [ in] 
142  * @param [out] 
143  * @return      
144  */
145 void delete_Head(doubleLink* head){
146     if(head->next==NULL){
147         printf("链表为空，不能删除\n");
148         return;                                                                                                                                                                              
149     }
150     doubleLink* p=head->next;
151     if(p->next==NULL){
152         p->next=NULL;
153     }
154     head->next=p->next;
155     p->next->prve=head;
156     
157     free(p);
158     p=NULL;
159     head->text.len--;
160     return;
161 }
162 
163 /*
164  * function:    尾删除
165  * @param [ in] 
166  * @param [out] 
167  * @return      
168  */
169 
170 void delete_Tail(doubleLink* head){
171     if(head->next==NULL){
172         printf("链表为空，不能删除\n");
173         return;
174     }
175     doubleLink* p=head->next;
176     if(p->next==NULL){
177         head->next=NULL;
178     }
179     while(p->next!=NULL){
180         p=p->next;
181     }
182     p->prve->next=NULL;
183     head->text.len--;
184     return;
185 }
186 /*
187  * function:    按位置删除
188  * @param [ in] 
189  * @param [out] 
190  * @return      
191  */
192 void delete_Bypos(doubleLink* head,int pos){
193     if(head->next==NULL){
194         printf("链表为空，不能删除\n");
195         return;
196     }
197     doubleLink* p=head->next;
198 
199     if(pos<1||pos>head->text.len){
200         printf("位置不合法\n");
201         return;
202     }
203     for(int i=1;i<pos;i++){
204         p=p->next;
205     }
206     if(p->next==NULL){
207         p->prve->next=p->next;
208     }
209     else{
210         p->prve->next=p->next;
211         p->next->prve=p->prve;
212     }
213     head->text.len--;
214     return;
215 }
216 
~                                                                                                                                                                                                
~                                                                                                                                                                                                
~                                                                                                                                                                                                
~                                                                                                                                                                                                
~                                                                                                                                                                                                
~                                                                                                                                                                                                
~

蜗牛神速
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
PHP链表操作简单示例
01-20
本文实例讲述了PHP链表操作。分享给大家供大家参考，具体如下： 在php中运行数据结构，基本都是用数组模拟的，只是用一直思想而已。 今天遇到的这个问题是，两个链表进行合并。 链表合并效果图 问题描述：A链表是...
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表操作基础（python）
beautiful77moon的博客
09-23 5828
链表创建、合并、节点删除、翻转、奇偶位置重排
双向循环链表操作的实现
m0_53676388的博客
01-24 2058
对双向循环列表进行如下操作： 1.建立一个空表。 2.在第i个位置插入新的元素x。 3.删除第i个位置上的元素。 4.取第i个位置上的元素。 5.返回元素x第一次出现在双向循环链表中的位置号。 6.求双向循环链表的长度，即元素个数。 7.输出双向循环链表中所有的元素值。 8.实现双向循环链表的就地逆置。
【Java】轻松掌握链表操作
叮当猫的博客
03-25 2232
基于节点的数据结构——链表1.1 什么是链表1.2 链表的读取与查找1.3 链表的插入1.4 链表的删除1.5 链表 vs 数组 1.1 什么是链表 在数组存储的过程中，数组的存储必须使用连续的内存空间，并且会预留一部分空间方便扩展。这样在内存中会大大降低内存的使用率，这种事情是不被接受的。所以出现了一种新的数据结构，叫作——链表 综上可知：链表的发明其实是对数组的一种补充。因此它的功能和数组非常类似，都是用于存储一系列相同类型的数组，并且都有增删改查等基本操作 用一句话来总结： 数组能做的所有事情，一般
【数据结构】C语言实现链表操作
Stafen_的博客
02-18 3628
链表：线性表的链式存储结构详细操作教程
带头结点的双向循环链表操作集 (25 分)
m0_63982781的博客
02-20 2507
本题要求实现一个带头结点的双向循环链表操作集。 函数接口定义： typedef int dataType; typedef struct _node { dataType data; struct _node *prev;//指向前驱的指针 struct _node *next;//指向后继的指针 }node; typedef node* List; List create_list();//创建一个空的循环链表，返回指向头节点的指针。 void insert(List
为什么链表对新链表操作会改变原链表
shuxin_yixin的博客
02-11 1433
为什么链表对新链表操作会改变原链表
链表的基本操作
小橘是橘子的博客
04-30 4727
单链表的简单介绍: 链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始； 链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的； 其中每个结点都有指针成员变量指向列表中的下一个结点； 链表是由结点构成，head指针指向第一个成为表头的结点，而终止于最后一个指向NULL的指针。一般使用时都要定义一个头结点，头结点不存放数据，只是为了方便查找。 一般的单链表的操作(增，删，改，查)如下代码： package com.mrz.test; public class Si
matlab实现链表操作
YDY5659150的专栏
11-01 3284
前奏 C语言中采用指针的方式操控链表，而matlab中没有指针的概念，处理某些算法时略有不便，于是在网上查询别人的代码，经过总结也可以实现。实现的过程中采用了面向对象的编程概念，类似于C++中的class操作，这是之前没有接触到的知识。matlab定义类使用关键字classdef，详细使用方法可以参考help帮助文档。 1.建立链表首先建立节点类node，以下代码来至互联网。 ``` class...
python如何对链表操作
12-16
3. **链表操作**： - **添加结点**：`add_node` 方法用于在链表的尾部添加新的结点。 - **查看链表**：`view` 方法遍历链表并打印所有结点的值，形成链表的表示形式。 - **计算长度**：`length` 方法通过遍历链表...
c语言链表操作示例分享
09-04
本示例介绍了一个简单的线性链表操作，包括链表的创建、插入节点和打印链表内容。下面将详细解释代码中的关键知识点。 首先，我们定义了链表节点的结构体`chaink`，它包含一个字符型数据`c`和一个指向下一个节点的...
C语言链表操作
10-10
C语言链表操作，新手强烈推荐必看内容，不看会后悔。。。
单链表-数据结构
qq_31804097的博客
08-07 152
【代码】单链表、双向带头循环链表-数据结构。
【数据结构-前缀哈希】力扣525. 连续数组
最新发布
sjsjs11的博客
08-07 147
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 326
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
从零开始学数据结构系列之第四章《迪杰斯特拉算法了解》
铁匠匠匠的博客
08-04 1126
1、先选定一个根结点，并选定一个数组，先确定未遍历前的初始距离，把距离最短的邻接结点选定为中间结点，并标记访问过，开始往下遍历，挨个访问那个中间结点的邻接结点。计算出根结点到中间结点+中间结点到新邻接结点的距离，作为新距离，对比新距离和旧距离，如果新距离大，则把新距离替换掉旧距离，否则不变。算法的基本思想是：从源点出发，每次选择离源点最近的一个顶点前进，然后以该顶点为中心进行扩展，最终得到源点到其余所有点的最短路径。2、一轮访问结束后，从未标记的结点中选定距离最短的，把它作为中间结点，继续往下访问。
数据结构第十讲：二叉树OJ题
2301_79761834的博客
08-04 711
数据结构第十讲：二叉树OJ题
C++实现链表操作详解
创建链表是链表操作的基础，这涉及到在内存中动态分配空间并初始化结点。在C++中，可以使用new运算符来动态分配内存。检索操作则是根据特定的索引或条件寻找链表中的结点。由于链表不是顺序存储，所以检索可能需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值