数据结构之单链表的实现

guguguhuha 2021-04-14 原文


数据结构之单链表的实现

数据结构之单链表的实现

 

　　在上一节 ：数据结构之顺序表

　　我们提到了顺序表的一些缺陷，那有没有什么数据结构可以减少这些问题呢？

　　答案自然就是今天我们所要说的链表。

 

本节大纲：

  • 链表的概念与结构
  • 单链表的实现
  • 完整代码展示

 

 

一.链表的概念与结构

 

  1.概念

　　链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

   2.结构及种类

　　链表有好多种：单双向链表，带头不带头链表，循环非循环链表 ；它们两两组合可以组成 8 种链表结构，如下图所示：

　　链表又包括 数据域 和 指针域。

 

 

 

 

 

 

　 虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

 

 

 　　1. 无头单向非循环链表：

　　　　结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。

　　　　另外这种结构在笔试面试中出现很多。

　　2. 带头双向循环链表：

　　　　结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。

　　　　另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

 

　　所以我们今天从 无头单向非循环链表 开始：

　　

三.单链表的实现

   1.自定义数据类型

　　首先我们肯定要先创建一个自定义数据类型：

//进行自定义类型，方便修改
typedef int DataType;

//进行自定义数据类型
typedef struct SLTNode
{
    DataType data;//存放数据
    struct SLTNode* next;//指向下一块空间
}SLTNode;

 

   2.打印函数

　　假设我们现在有一个数据完全的单链表，但是我们想在看到它的值，这时就需要一个打印函数了。

　　现在我们来想一想我们刚刚所提到的单链表结构，它是由数据域和指针域组合而成，而它中的指针指向的是下一块储存空间，如果该指针为NULL，就说明该链表已结束。

//单链表打印函数
void SLTPrint(SLTNode *p)
{
    if (p == NULL)//如果该链表为空
    {
        printf("该链表中并无值可供打印\n");
        return;//直接退出
    }
    //正常情况下
    
    //cur指向当前位置
    SLTNode *cur = p;
    while (cur)//如果cur是NULL，循环就停止
    {
        printf("%d -> ", cur->data);
        cur = cur->next;//cur指向下一块空间
    }
    printf("NULL\n");
}

　　在这会有一些人问 ：while 中的判断条件是否可以写为 cur->next ，我们来看一下:

 

 　　从上图中，我们可以明显看出：若循环条件为  cur->next ,这样循环到达最后一个节点就退出了，最后一个节点内的值并未打印，当然要是你在循环结束后，再加一句printf，那自然也没错

   

   3.创建节点函数：

　　因后面的头插、尾插、任意位置插入，都需要去创建节点，所以在这就把它单独列一个模块：

//创建节点函数
SLTNode *BuySLTNode(DataType data)
{
    //动态开辟一块空间
    SLTNode *new_node = (SLTNode *) malloc(sizeof(SLTNode));
    if (new_node == NULL)//如果未开辟成功
    {
        perror("BuyNode Error!");//打印错误信息
        exit(-1);
    }
    else
    {
        //新结点的值为传进来的值
        new_node->data = data;
        new_node->next = NULL;
    }
    //返回新建立的节点
    return new_node;
}

 

   4.单链表尾插

　　尾插，我们肯定要先找到该链表的尾，然后将尾的next指向我们新建立的结点，将新节点的next指向NULL；

//单链表尾插函数
void SLTPushBack(SLTNode *p, DataType InsertData)
{
    //创建一个新节点
    SLTNode *new_node = BuySLTNode(InsertData);
    if (p == NULL)//说明该链表为空
    {
        p = new_node;
    }
    else//非空就找尾
    {
        SLTNode *cur = p;
        while (cur->next)//循环遍历找尾，注意在这，我们的循环条件为cur->next，而非cur
            // 因为我们要用最后一个节点的next
            // 否则，若是cur的话，就直接走到NULL了，我们无法给将一个节点加在它上面
        {
            cur = cur->next;//指向下一个
        }
        cur->next = new_node;//尾插
    }
}

　　可是，上面这段代码有没有问题呢？ 我们来运行一下：

void test1()
{
    SLTNode *p = NULL;
    SLTPushBack(p,0);
    SLTPushBack(p,1);
    SLTPushBack(p,2);
    SLTPushBack(p,3);
    SLTPrint(p);
}

测试代码

 

 　　我们明明尾插了4次，最后为什么还是无值可供打印呢？ 我们再来调试一下：

 

 　　我们发现，它在函数里都换过了，却出了函数又变为了NULL。我们思来想去总觉得这种情形好像在哪见过 — 哦，原来曾在这个例子中见过：

#include<stdio.h>

void swap(int a, int b)
{
    int c = a;
    a = b;
    b = c;
}

int main()
{
    int a = 2, b = 3;
    printf("before:\na=%d, b=%d\n", a, b);
    swap(a, b);
    printf("after:\na=%d, b=%d\n", a, b);
    return 0;
}

 

 　　当时，我们便已提到，改变其值时，要传值，但要改变其指向，要传址；

　　在举一个例子：

void change(char *p)
{
    p[0] = '!';
}

void change_2(char **p)
{
    static char *a = "12334";
    *p = a;
}

int main()
{
    char a[] = "dadasfsfa";
    char *p = a;

    //改变指针所指向的值
    change(p);
    printf("%s\n", p);//!adasfsfa

    //改变指针的指向
    change_2(&p);
    printf("%s\n", p);//12334
    return 0;
}

示例

　　所以正确的尾插怎么写呢:

　　　　1.函数参数为STLNode** ,即改为址传递，因为当 p为空的时候，我们需要改变其指向，指向我们新建的new_node

//单链表尾插函数
void SLTPushBack(SLTNode **p, DataType InsertData)
{
    //创建一个新节点
    SLTNode *new_node = BuySLTNode(InsertData);
    if (*p == NULL)//说明该链表为空
    {
        *p = new_node;//改变p的指向
    }
    else//非空就找尾
    {
        SLTNode *cur = *p;
        while (cur->next)//循环遍历找尾，注意在这，我们的循环条件为cur->next，而非cur
            // 因为我们要用最后一个节点的next
            // 否则，若是cur的话，就直接走到NULL了，我们无法给将一个节点加在它上面
        {
            cur = cur->next;//指向下一个
        }
        cur->next = new_node;//尾插
    }
}

    5.单链表头插

　　现在有了之前的错误经验，是不是一下就知道这个肯定是传址啊：

//单链表头插函数
void SLTPushFront(SLTNode **p, DataType InsertData)
{
    SLTNode *new_node = BuySLTNode(InsertData);//创建新节点

    //在头插中，并不关心*p为不为空，反正最后它们的处理都是一样的

    //将原链表内容连接在new_node上
    new_node->next = *p;
    //改变指向
    *p = new_node;
}

   6.单链表尾删

　　循环遍历找尾，释放，置NULL

//单链表尾删函数
void SLTPopBack(SLTNode **p)
{
    if (*p == NULL)//表示该链表为空
    {
        printf("该链表中并无值可供删除！\n");
        return;
    }
    else if ((*p)->next == NULL)//表示该链表中只有一个值，删除之后就为空
    {
        free(*p);//释放空间
        *p = NULL;//置为NULL；
    }
    else
    {
        //循环遍历找尾
        SLTNode *cur = *p;//指向当前位置
        SLTNode *prev = NULL;//指向前一个位置
        while (cur->next)
        {
            prev = cur;
            cur = cur->next;
        }
        free(cur);//释放空间
        cur = NULL;//及时置NULL
        //删除之后prev便是最后一个节点了
        prev->next = NULL;
    }
}

   7.单链表头删

　　释放改指向

//单链表头删函数
void SLTPopFront(SLTNode **p)
{
    if (*p == NULL)//表示该链表为空
    {
        printf("该链表中并无值可供删除！\n");
        return;
    }
    else
    {
        SLTNode* pop_node=*p;//指向头节点
        *p=(*p)->next;//指向下一个元素
        free(pop_node);//释放空间
        pop_node=NULL;//及时置NULL
    }
}

   8.单链表查找函数

　　循环遍历

//单链表查找函数
SLTNode *SLTFindNode(SLTNode *p, DataType FindData)
{
    assert(p);//确保传进来的指针不为空
    SLTNode *cur = p;
    while (cur)
    {
        if (cur->data == FindData)
        {
            return cur;//找到就返回该节点的地址
        }
        cur = cur->next;//循环遍历
    }
    return NULL;//找不到就返回NULL
}

   9.单链表修改函数

//单链表修改函数
void SLTModify(SLTNode *pos, DataType ModifyData)
{
    assert(pos);//确保pos不为空
    pos->data = ModifyData;//修改
}

   10.任意位置插入

　　1.单链表在pos位置之后插入insertdata

//单链表在pos位置之后插入InsertData
void SLTInsertAfter(SLTNode* pos,DataType InsertData)
{
    assert(pos);//保证pos不为NULL
    SLTNode* new_node=BuySLTNode(InsertData);//创建一个新节点
    //该节点的下一个指向原本该位置的下一个
    new_node->next=pos->next;
    //该位置的下一个就是new_node
    pos->next=new_node;
}

　　2.单链表在pos位置之前插入insertdata

　　　　这时就要考虑到若位置是第一个位置时，那就相当于头插了

　　　　此外，我们还得找到它的前一个位置

 

//单链表在pos位置之前插入InsertData
void SLTInsertBefore(SLTNode **p, SLTNode *pos, DataType InsertData)
{
    assert(pos);
    SLTNode *new_node = BuySLTNode(InsertData);
    if (pos == *p)//这就说明是第一个位置前插入
    {
        //头插
        new_node->next = *p;
        *p = new_node;
    }
    else
    {
        SLTNode *cur = *p;
        SLTNode *prev = NULL;
        //新节点的下一个指向这个位置
        new_node->next = pos;
        //循环遍历找到它的前一个位置
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        //前一个位置指向新节点
        prev->next = new_node;
    }
}

　　　　除此之外，还有哦另外一种方法，可以不用去知道它链表的第一个位置

　　　　我们在传过去的那个位置，来进行一个后插，再交换这两个节点的数据 ，这也是一种方法：

//单链表在pos位置之前插入InsertData
void SLTInsertBefore_2(SLTNode *pos, DataType InsertData)
{
    assert(pos);

    SLTNode *new_node = BuySLTNode(InsertData);
    new_node->next = pos->next;
    pos->next = new_node;
    //进行了一个后插

    //交换这两个变量的值
    DataType tmp = pos->data;
    pos->data = new_node->data;
    new_node->data = tmp;
}

　　如图：

 

    11.任意位置删除

　　　1.删除pos位后的数据

//删除pos位后的数据
void SLTEraseAfter(SLTNode *pos)
{
    assert(pos);
    if (pos->next == NULL)
    {
        //说明后面并没有元素了
        printf("该位置后无数据可以删除\n");
    }
    else
    {
        //创建一个指针指向下一个位置
        SLTNode *next = pos->next;
        //原位置的下一个位置，指向 下一个位置 的下一个位置
        pos->next = next->next;
        //释放内存
        free(next);
        next = NULL;
    }
}

　　　　2.删除pos位的数据 — 这就包含了头删

//删除pos位的数据 --- 含有头删
void SLTEraseCur(SLTNode **p, SLTNode *pos)
{
    assert(pos);
    if (*p == pos)
    {
        //说明是头删
        *p = pos->next;
        free(pos);
        pos = NULL;
    }
    else
    {
        //普通位置
        SLTNode *prev = *p;
        SLTNode *cur = *p;
        //找到头一个位置
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        //头一个位置指向下下个位置
        prev->next = pos->next;
        free(pos);
        pos = NULL;
    }
}

　　　　3.同样可以用之前所提到的方法进行带有头删的任意位置删除

　　　　　　1.把该位置 后一个节点的数据存下；

　　　　　　2.删除该位置后的节点

　　　　　　3.将头节点的值改为之前存下的数据

　　

　　 单链表的实现到这便就结束了

 

三.完整代码展示

//确保头文件只包含一次
#ifndef FINASLT_SLT_H
#define FINASLT_SLT_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>


//进行自定义类型，方便修改
typedef int DataType;

//进行自定义数据类型
typedef struct SLTNode
{
    DataType data;//存放数据
    struct SLTNode *next;//指向下一块空间
} SLTNode;

//单链表打印函数
void SLTPrint(SLTNode *p);

//创建节点函数
SLTNode *BuySLTNode(DataType data);

//单链表尾插函数
void SLTPushBack(SLTNode **p, DataType InsertData);

//单链表头插函数
void SLTPushFront(SLTNode **p, DataType InsertData);

//单链表尾删函数
void SLTPopBack(SLTNode **p);

//单链表头删函数
void SLTPopFront(SLTNode **p);

//单链表查找函数
SLTNode *SLTFindNode(SLTNode *p, DataType FindData);

//单链表修改函数
void SLTModify(SLTNode *pos, DataType ModifyData);

//单链表在pos位置之后插入InsertData
void SLTInsertAfter(SLTNode *pos, DataType InsertData);

//单链表在pos位置之前插入InsertData
void SLTInsertBefore(SLTNode **p, SLTNode *pos, DataType InsertData);


//单链表在pos位置之前插入InsertData
void SLTInsertBefore_2( SLTNode *pos, DataType InsertData);

//删除pos位后的数据
void SLTEraseAfter(SLTNode *pos);

//删除pos位的数据 --- 含有头删
void SLTEraseCur(SLTNode **p, SLTNode *pos);

#endif //FINASLT_SLT_H

SLT.h 

#include "SLT.h"

//单链表打印函数
void SLTPrint(SLTNode *p)
{
    if (p == NULL)//如果该链表为空
    {
        printf("该链表中并无值可供打印\n");
        return;//直接退出
    }
    //正常情况下

    //cur指向当前位置
    SLTNode *cur = p;
    while (cur)//如果cur是NULL，循环就停止
    {
        printf("%d -> ", cur->data);
        cur = cur->next;//cur指向下一块空间
    }
    printf("NULL\n");
}

//创建节点函数
SLTNode *BuySLTNode(DataType data)
{
    //动态开辟一块空间
    SLTNode *new_node = (SLTNode *) malloc(sizeof(SLTNode));
    if (new_node == NULL)//如果未开辟成功
    {
        perror("BuyNode Error!");//打印错误信息
        exit(-1);
    }
    else
    {
        //新结点的值为传进来的值
        new_node->data = data;
        new_node->next = NULL;
    }
    //返回新建立的节点
    return new_node;
}

////单链表尾插函数
//void SLTPushBack(SLTNode *p, DataType InsertData)
//{
//    //创建一个新节点
//    SLTNode *new_node = BuySLTNode(InsertData);
//    if (p == NULL)//说明该链表为空
//    {
//        p = new_node;
//    }
//    else//非空就找尾
//    {
//        SLTNode *cur = p;
//        while (cur->next)//循环遍历找尾，注意在这，我们的循环条件为cur->next，而非cur
//            // 因为我们要用最后一个节点的next
//            // 否则，若是cur的话，就直接走到NULL了，我们无法给将一个节点加在它上面
//        {
//            cur = cur->next;//指向下一个
//        }
//        cur->next = new_node;//尾插
//    }
//}

//单链表尾插函数
void SLTPushBack(SLTNode **p, DataType InsertData)
{
    //创建一个新节点
    SLTNode *new_node = BuySLTNode(InsertData);
    if (*p == NULL)//说明该链表为空
    {
        *p = new_node;//改变p的指向
    }
    else//非空就找尾
    {
        SLTNode *cur = *p;
        while (cur->next)//循环遍历找尾，注意在这，我们的循环条件为cur->next，而非cur
            // 因为我们要用最后一个节点的next
            // 否则，若是cur的话，就直接走到NULL了，我们无法给将一个节点加在它上面
        {
            cur = cur->next;//指向下一个
        }
        cur->next = new_node;//尾插
    }
}

//单链表头插函数
void SLTPushFront(SLTNode **p, DataType InsertData)
{
    SLTNode *new_node = BuySLTNode(InsertData);//创建新节点

    //在头插中，并不关心*p为不为空，反正最后它们的处理都是一样的

    //将原链表内容连接在new_node上
    new_node->next = *p;
    //改变指向
    *p = new_node;
}

//单链表尾删函数
void SLTPopBack(SLTNode **p)
{
    if (*p == NULL)//表示该链表为空
    {
        printf("该链表中并无值可供删除！\n");
        return;
    }
    else if ((*p)->next == NULL)//表示该链表中只有一个值，删除之后就为空
    {
        free(*p);//释放空间
        *p = NULL;//置为NULL；
    }
    else
    {
        //循环遍历找尾
        SLTNode *cur = *p;//指向当前位置
        SLTNode *prev = NULL;//指向前一个位置
        while (cur->next)
        {
            prev = cur;
            cur = cur->next;
        }
        free(cur);//释放空间
        cur = NULL;//及时置NULL
        //删除之后prev便是最后一个节点了
        prev->next = NULL;
    }
}

//单链表头删函数
void SLTPopFront(SLTNode **p)
{
    if (*p == NULL)//表示该链表为空
    {
        printf("该链表中并无值可供删除！\n");
        return;
    }
    else
    {
        SLTNode *pop_node = *p;//指向头节点
        *p = (*p)->next;//指向下一个元素
        free(pop_node);//释放空间
        pop_node = NULL;//及时置NULL
    }
}

//单链表查找函数
SLTNode *SLTFindNode(SLTNode *p, DataType FindData)
{
    assert(p);//确保传进来的指针不为空
    SLTNode *cur = p;
    while (cur)
    {
        if (cur->data == FindData)
        {
            return cur;//找到就返回该节点的地址
        }
        cur = cur->next;//循环遍历
    }
    return NULL;//找不到就返回NULL
}

//单链表修改函数
void SLTModify(SLTNode *pos, DataType ModifyData)
{
    assert(pos);//确保pos不为空
    pos->data = ModifyData;//修改
}

//单链表在pos位置之后插入InsertData
void SLTInsertAfter(SLTNode *pos, DataType InsertData)
{
    assert(pos);//保证pos不为NULL
    SLTNode *new_node = BuySLTNode(InsertData);//创建一个新节点
    //该节点的下一个指向原本该位置的下一个
    new_node->next = pos->next;
    //该位置的下一个就是new_node
    pos->next = new_node;
}

//单链表在pos位置之前插入InsertData
void SLTInsertBefore(SLTNode **p, SLTNode *pos, DataType InsertData)
{
    assert(pos);
    SLTNode *new_node = BuySLTNode(InsertData);
    if (pos == *p)//这就说明是第一个位置前插入
    {
        //头插
        new_node->next = *p;
        *p = new_node;
    }
    else
    {
        SLTNode *cur = *p;
        SLTNode *prev = NULL;
        //新节点的下一个指向这个位置
        new_node->next = pos;
        //循环遍历找到它的前一个位置
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        //前一个位置指向新节点
        prev->next = new_node;
    }
}

//单链表在pos位置之前插入InsertData
void SLTInsertBefore_2(SLTNode *pos, DataType InsertData)
{
    assert(pos);

    SLTNode *new_node = BuySLTNode(InsertData);
    new_node->next = pos->next;
    pos->next = new_node;
    //进行了一个后插

    //交换这两个变量的值
    DataType tmp = pos->data;
    pos->data = new_node->data;
    new_node->data = tmp;
}

//删除pos位后的数据
void SLTEraseAfter(SLTNode *pos)
{
    assert(pos);
    if (pos->next == NULL)
    {
        //说明后面并没有元素了
        printf("该位置后无数据可以删除\n");
    }
    else
    {
        //创建一个指针指向下一个位置
        SLTNode *next = pos->next;
        //原位置的下一个位置，指向 下一个位置 的下一个位置
        pos->next = next->next;
        //释放内存
        free(next);
        next = NULL;
    }
}

//删除pos位的数据 --- 含有头删
void SLTEraseCur(SLTNode **p, SLTNode *pos)
{
    assert(pos);
    if (*p == pos)
    {
        //说明是头删
        *p = pos->next;
        free(pos);
        pos = NULL;
    }
    else
    {
        //普通位置
        SLTNode *prev = *p;
        SLTNode *cur = *p;
        //找到头一个位置
        while (cur != pos)
        {
            prev = cur;
            cur = cur->next;
        }
        //头一个位置指向下下个位置
        prev->next = pos->next;
        free(pos);
        pos = NULL;
    }

}

SLT.c 

#include "SLT.h"

void test1()
{
    SLTNode *p = NULL;
    SLTPushBack(&p, 0);
    SLTPushBack(&p, 1);
    SLTPushBack(&p, 2);
    SLTPrint(p);

    SLTPushFront(&p, 0);
    SLTPushFront(&p, 1);
    SLTPushFront(&p, 2);
    SLTPrint(p);

    SLTPopBack(&p);
    SLTPrint(p);

    SLTPopFront(&p);
    SLTPrint(p);

    SLTNode *pos = SLTFindNode(p, 1);
    if (pos == NULL)
    {
        printf("该链表中无所查找的值！\n");
    }
    else
    {
        SLTModify(pos,123);
    }
    SLTPrint(p);

    SLTInsertAfter(pos,321);
    SLTPrint(p);

    SLTInsertBefore(&p,pos,000);
    SLTPrint(p);

    SLTInsertBefore_2(SLTFindNode(p,1),666);

    SLTPrint(p);

    SLTEraseAfter(SLTFindNode(p,1));
    SLTEraseAfter(SLTFindNode(p,666));
    SLTEraseCur(&p,SLTFindNode(p,0));
    SLTEraseCur(&p,SLTFindNode(p,123));
    SLTEraseCur(&p,SLTFindNode(p,321));
    SLTEraseCur(&p,SLTFindNode(p,0));
    SLTEraseCur(&p,SLTFindNode(p,0));
    SLTEraseCur(&p,SLTFindNode(p,666));
    SLTPrint(p);

}

int main()
{
    setbuf(stdout, NULL);
    test1();
    return 0;
}

main.c

 

 

 

|——————————————————–

关于单链表的知识到这便结束了

因笔者水平有限，若有错误，还望指正！

 

发表于
2021-04-14 17:45 
guguguhuha 
阅读(6) 
评论(0) 
编辑 
收藏

 

版权声明：本文为guguguhuha原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/guguguhuha/p/14655234.html

数据结构之单链表的实现的更多相关文章

  1. ACM金牌选手讲解LeetCode算法《栈和队列的高级应用》

    面试高频考点: 单调栈、滑动窗口…. 大家好，我是编程熊，双非逆袭选手，字节跳动、旷视科技前员工， […]...

  2. 冰与火之歌：「时间」与「空间」复杂度

    算法（Algorithm）是指用来操作数据、解决程序问题的一组方法。对于同一个问题，使用不同的算法，也许最终得 […]...

  3. 红黑树其实很简单

    通过文字和图片详细解析为什么要使用红黑树，以及如何使用红黑树。本文中红黑树的代码示例有java和C两个版本，并 […]...

  4. PYTHON 学习笔记3 数据结构

    前言 在上一节的学习中。学习了基本的流程控制语句，if-elif-else for while 等，本节将拓展 […]...

  5. 最短路径(Floyd算法）

    声明：图片及内容基于https://www.bilibili.com/video/BV1oa4y1e7Qt?f […]...

  6. 循序渐进学习数据结构之线性表

    一、思维导图 二、线性表的基本概念 1.名词解释： 线性表：由n个数据特性相同的元素构成的有限序列，有顺序存储 […]...

  7. 线性表

    1，线性表是数据结构的线性表现 2，线性表的两种表现方式：顺序表，链表 3，顺序表：开辟连续的空间，顺序存储 […]...

  8. 利用Kruskal算法求最小生成树解决聪明的猴子问题 — 数据结构

    题目：聪明的猴子 链接：https://ac.nowcoder.com/acm/problem/19964 在 […]...

随机推荐

  1. 170706组-小组贡献分计算的原则-11.24

    170706组-小组贡献分计算的原则-11.24 1. 小组计分的原则 任务 完成 未完成  汇报每日进度（晚 […]...

  2. 阿里矢量库（各种图标搜索功能） – lihfei89

    阿里矢量库（各种图标搜索功能） 图标矢量库 今天发现一个比较好的图标集合地址：http://www.iconf […]...

  3. javascript基础

    javascript基础 JavaScript简介   JavaScript起源 早年间，人们上网都是使用速度 […]...

  4. 获取当前日期算前一年、前一月、前一天Calendar – 梁DH

    获取当前日期算前一年、前一月、前一天Calendar 问题的本身没有什么难度，但是要想一下子找到一个现成的方法 […]...

  5. 图解DTS和PTS

    由于把视频编码成I,B,P等帧，如下图   假设现在有I,B,P帧，那么要传输和显示呢??   如果按照显示顺 […]...

  6. 码农-如果当初学习编程时能有人给我这些忠告该多好

    在你学习编程之前思考一下你的目标 要知道编程大多时候就是在创造，当你有最终目标感时道路会更加的清晰。如果你的目 […]...

  7. 全国交通咨询系统 by C++ on Linux

    信息存储   　　利用邻接表存储城市信息与线路信息，比邻接矩阵更加高效。   主要数据结构   　　I）Tim […]...

  8. java中的引用类型：强软弱虚

    java中的引用类型共4种：强软弱虚，具体每种类型的特点和应用场景。记录下。本文是看了马士兵老师的视频后记录整 […]...

热门专题

超高性能解析IP数据库
从Netty
白话分布式存储测试（一）明确测试目标
GPU和CPU的区别
开发问题记录(这部分还是比较零碎)
策略者模式
将联系人导入到iPhone模拟器
Incaseformat病毒致大批用户被格盘，附防护措施。
多线程（Thread
filter
拖拽功能的冲突问题及解决方法
Spring杂谈
的连接型智能表格:「vika
无线输电离我们还有多远？
Win10开始菜单中的天气不更新问题的解决方法润之
Git常用命令总结
关于mysql的access
RC充电时间计算
标准SQL的update语句三种用法
i_bugs
Android音频底层调试-基于tinyalsa
展开目录

目录导航