数据结构学习路线+笔记

在学校学习过后感觉数据结构学完之后还是迷迷糊糊的，而数据结构已经有很多位前辈说过其重要性，于是下决心再来一遍“复习”。代码会陆续贴上来，轻喷，都是些简单的基础知识。

————学习来源为郝斌老师的视频

数据结构：数据结构是研究数据存储的问题（狭义）数据结构既包含数据的存储，也包含对存储数据的操作即算法（广义）

数据存储包含两个方面： 个体的存储 + 个体关系的存储。

 

算法：

狭义的算法是与数据的存储方式密切相关的

广义的算法是与数据的存储方式无关，

泛型：利用某种技术达到的效果就是不同的存储方式执行操作是一样的。

 

数据的存储结构：线性和非线性

 

线性结构：任何一个节点只能对应一个节点，即所有节点都由一根“线”连接。

连续存储【数组】

优点：存取速度快，

缺点：必须先知道数组长度，插入删除元素操作速度慢，空间通常是有限制的，需要极大的连续内存块。

 

离散存储【链表】

定义：N个节点离散分配，彼此通过指针指向下一个节点，每个节点只有一个前驱节点和一个后继节点，首节点没有前驱，尾节点没有后继节点。

 

优点：插入删除速度快，空间没有限制（容量）

缺点：存取速度慢

 

专业术语：

首节点

尾节点

头节点：在首节点（有效节点）的前面添加的节点为头节点，其没有实际含义，没有有效数据，其存在的意义是简便对链表的操作（算法）。

头指针：指向头节点的指针变量，存放头节点的指针地址

尾指针：指向尾节点的指针

如果希望通过函数来对一个链表进行处理，我们至少需要接收一个参数：头指针，通过头指针可以推算出链表的所有信息

 

分类：

单链表：每个节点只有一个指针域，指向下一个节点

双链表：每一个节点有两个指针域，分别指向前驱和后继

循环链表：任何一个节点都可以找到其他所有节点，最后一个节点指向第一个指针域。

非循环链表

 

相关算法：

遍历：

查找：

清空：

销毁：

求长度：

排序：

删除节点：

插入节点：

 

#define _CRT_SECURE_NO_DEPRECATE
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>


typedef struct Node
{
    int data;
    struct Node * pNext;
}NODE, *PNODE;




PNODE create_list(void);//创建一个单链表
void traverse_list(PNODE pHead);//遍历一个链表
bool is_empty(PNODE pHead);
int getLength_lsit(PNODE pHead);
bool insert_list(PNODE pHead, int pos, int value);
bool delete_list(PNODE pHead, int pos, int *pValue);
void sort_list(PNODE pHead);


int main()
{
    PNODE pHead = NULL;
    pHead = create_list();
    getchar();
    traverse_list(pHead);
    int len = getLength_lsit(pHead);
    printf("长度:%d\n", len);


    sort_list(pHead);
    traverse_list(pHead);
    system("pause");
    return 0;
}


PNODE create_list(void)
{
    int len;//有效节点个数
    int i;
    int value;//临时数据


    //不存放有效数据的头节点
    PNODE pHead = (PNODE)malloc(sizeof(NODE)); //为生成的节点动态分配内存
    if (NULL == pHead)
    {
        printf("节点生成失败,程序终止！");
        exit(-1);
    }
    PNODE pTail = pHead;
    pTail->pNext = NULL;//清空，指向最后一个节点


    printf("输入有效节点个数len：");
    scanf("%d", &len);


    for (i = 0; i < len; i++)
    {
        printf("请输入第%d个几点值：",i+1);
        scanf("%d", &value);


        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if (NULL == pNew)
            {
                printf("节点生成失败,程序终止！");
                exit(-1);
            }
        pNew->data = value;
        pTail->pNext = pNew;
        pNew->pNext = NULL;//最后一个节点的指针域为空
        pTail = pNew;
    }
return pHead;

}


void traverse_list(PNODE pHead)
{

    PNODE p = pHead->pNext;
    while (NULL != p)
    {
        printf("%d ",p->data);
        p = p->pNext;
    }
    printf("\n");
    return;
}


bool is_empty(PNODE pHead)
{
    if (pHead->pNext == NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}


int getLength_lsit(PNODE pHead)
{
    int cnt = 0;
    PNODE p = pHead->pNext;
    while (NULL != p)
    {
        ++cnt;
        p = p->pNext;
    }
    return cnt;
}


void sort_list(PNODE pHead) //冒排
{
    int i, j, t;
    int len = getLength_lsit(pHead);
    PNODE p, q;
    for (i=0, p = pHead->pNext; i<len-1; i++,p = p->pNext)
    {
        for (j=i+1, q = p->pNext; j<len; j++,q=q->pNext)
        {
            if (p->data > q->data)
            {
                t = p->data;
                p->data = q->data;
                q->data = t;
            }
        }
    }
return;
}


//在pHead所指向链表的第pos节点的前面插入一个新节点，pos从1开始
bool insert_list(PNODE pHead, int pos, int value)
{
    int i = 0;
    PNODE p = pHead;


    while (NULL != p && i < pos - 1)
    {
        p = p->pNext;
        ++i;
    }


    if (i>pos - 1 || NULL == p )
    {
        return false;
    }


    PNODE pNew = (PNODE)malloc(sizeof(NODE));//开辟空间
    if (NULL == pNew)
    {
        printf("动态分配内存失败！");
        exit(-1);
    }
    pNew->data = value;
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;


    return true;
}


bool delete_list(PNODE pHead, int pos, int *pValue)
{
    int i = 0;
    PNODE p = pHead;


    while (NULL != p->pNext && i < pos - 1)
    {
        p = p->pNext;
        ++i;
    }


    if (i>pos - 1 || NULL == p->pNext)
    {
        return false;
    }




    PNODE q = p->pN