链表算法

1. 遍历

2. 查找

3. 清空

4. 销毁

5. 求长度

6. 排序

7. 删除节点

8. 插入节点

   //分配一个临时节点,不存放有效数据的头结点。pHead为指向头结点的指针变量（头指针）
       PNODE pHead = (PNODE)malloc(sizeof(NODE));//函数内的pHead为局部变量（临时存储）
       if(NULL == pHead)
       {
           printf("分配失败，程序终止！\n");
           exit(-1);
       }
   

   主程序

# include <stdio.h>
# include <malloc.h>

//数据类型
typedef struct Node
{
    int data;//数据域
    struct Node * pNext;//指针域
}NOTE, * PNOTE;//NOTE等价于struct Node, *PNOTE等价于struct Node *

//函数声明
PNOTE create_list(void);
void traverse_list(PNOTE pHeat);//遍历链表
bool is_empty(PNOTE pHead);
int length_list(PNOTE pHeat);
bool insert_list(PNOTE, int , int);
bool delete_list(PNODE, int, int *);//int *返回删除的值的地址，用于释放内存
void soert_list(PNODE);

int main(void)
{
    PNOTE pHeat = NULL;//等价于struct Node * pHeat = NULL;
    pHeat = create_list();//create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给pHeat
    traverse_list(pHead);
    //在链表位置pos前插入数值val
    //inset_list(pHeat, 4, 33);
    if(delete_list(pHead, 4, &val))
    {
        printf("删除成功，您删除的元素是：%d\n",val);
    }
    else
    {
        print("删除失败，您删除的元素不存在！\n");
    }
    //链表是否为空
    if(is_empty(pHeat))
        printf("链表为空！\n");
    else
        printf("链表为不空！\n");
    return 0;
    //链表长度
    len = int length_list(PNOTE pHeat);
    printf("链表长度是%d\n", len);
}


//创建链表
PNOTE create_list(void)
{
    int len;//存放有效节点的个数
    int i;
    int val;//临时存放用户输入的节点的值
    
    //分配一个临时节点,不存放有效数据的头结点。pHead为指向头结点的指针变量（头指针）
    PNODE pHead = (PNODE)malloc(sizeof(NODE));//函数内的pHead为局部变量（临时存储）
    if(NULL == pHead)
    {
        printf("分配失败，程序终止！\n");
        exit(-1);
    }
    PNOTE pTail = pHead;
    pTail->pNext = NULL;//指向新节点的指针赋值给pTail，保证pTail永远指向最后一个节点
    
    printf("请输入您需要生成链表节点的个数：len =");
    scanf("%d",&len);
    for(i=0; i<len; ++i)
    {
        printf("请输入第%d个节点的值"， i+1);
        scanf("%d", &val);
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if(NULL == pNew)
        {
             printf("分配失败，程序终止！\n");
             exit(-1);
        }
        pNew->data = val;
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;
    }
    return pHead;
}
//遍历链表
void traverse_list(PNOTE pHead)//用while循环方便些
{
    PNOTE p = pHeat->pNext;
    while (NULL != P)
    {
        printf("%d", p->data);
        p = p->pNext;//指针移动
    }
    printf("\n");
}
//判断链表是否为空
bool is_empty(PNOTE pHead)
{
    if(NULL == pHeat->pNext)
        reture true;
    else
        reture false;
}
//判断链表长度
int length_list(PNOTE pHeat)
{
    int len=0;
    PNOTE p = pHeat->pNext;
    while(NULL!=p)
    {
        ++len;
    }
    reture len;
}
//排序（知识点串讲）
void sort_list(PNOTE pHead)
{
    PNOTE p,q;
    int t;
    for(p=pHead; p->pHead != NULL; p=p->pHead)
    {
       for(q=p->pHead;  q->pHead != NULL; q=q->pHead)
       {
           if(p->date>q->q->date)
           {
               t = p->date;
               p->date = q->q->date;
               q->q->date = p->date;
           }
       }
    }
    return ;   
}
//在pHead所指向的链表的第pos个节点的前面插入一个新节点。该节点的值是val,并且pos从1开始
bool insert_list(PNOTE pHead, int pos, int val)
{
    //找pos-1的地址
    int i = 0;
    PNODE p = pHead;
    while(NULL!=p && i<pos-1)//判断插入的位置合理
    {
        p = p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL==p)
        return false;
    //新成立一个节点
    PNOTE pNew = (PNOTE)malloc(sizeof(NOTE));
    if(NULL == pNew)
    {
        print("动态分配内存失败！\n");
        exit(-1);
    }
    pNew->data = val;//赋予新节点值
    PNODE q = p->pNext;//取出插入节点位置的下一节点地址
    p->pNext = pNew;//赋予新节点地址
    pNew->pNext = q;//新节点连接下一插入位置的下一节点
}
//删除节点
bool delete_list(PNODE, int pos, int * pVal);
{
    //找到位置
   int i = 0;
    PNODE p = pHead;
    while(NULL!=p && i<pos-1)//判断插入的位置合理
    {
        p = p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL==p)
        return false; 
    //实现p节点后一节点删除
    PNOTE q = p->pNext;//取出删除节点地址
    *pVal = q->data;//取出删除节点值
    p->pNext = p->pNext->pNext;//删除节点的下个节点地址p->pNext->pNext直接赋值给前个节点的p->pNext
    free(q);//释放被删除节点内存
    q = NULL;
    return ture;
}

pHeat->pNext = pNew;
pNew->pNext = NULL;//将临时节点指针域清空给下个节点用

普通数组中的冒泡排序

void sort_arr(int * a, int len)
{
    int i,j,t;
    for(i=0; i<len-1; ++i)
    {
        for(j=i+1; j<len; ++j)
        {
            if(a[i]>a[j])
            {
                t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }
    return ;
}

结构体数组

# include <stdio.h>

//定义一个数据类型，名为struct Arr含有3个成员
struct Arr
{
    int * pBase;//存储的是数组第一个元素的地址
    int len;    //数组所能容纳的最大元素的个数
    int cnt;    //当前数组有效元素的个数
    //int increament;//自动增长因子
}；
void sort_arr(struct Arr * p)
{
    int i,j,t;
    for(i=0; i<p->cnt-1; ++i)
    {
        for(j=i+1; j<p->cnt; ++j)
        {
            if(p->pBase[i]>p->pBase[j])
            {
                t = p->pBase[i];
                p->pBase[i] = p->pBase[j];
                p->pBase[j] = t;
            }
        }
    }
    return ;
}

算法（核心）：

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

• 广义的算法是与数组的存储放式无关

泛型（核心）：

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

算法学习心得

• 记流程
• 每个语句功能
• 试数和测试
• 反复的敲写直到熟悉（学习清华高一凡一样）