嵌入式学习-数据结构-Day3-单链表

Day3

思维导图

单链表操作

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include 
#include 
#include 
enum A 
{
	FALSE=-1,
	SUCCESS
};
typedef int datatype;
typedef struct Node
{
	datatype data;
	struct Node *next;
}*Linklist;

int null(Linklist p);
Linklist create_node();
Linklist insert_head(Linklist head,datatype element);
void output(Linklist head);
Linklist insert_tail(Linklist head,datatype element);
Linklist delete_head(Linklist head);
Linklist delete_tail(Linklist head);
int length(Linklist head);
Linklist insert_pos(Linklist head,int pos,datatype element);
Linklist delete_pos(Linklist head,int pos);
datatype find_pos(Linklist head,int pos);
void change_pos(Linklist head,int pos,datatype element);
void element_find(Linklist head,datatype element);
void element_change(Linklist head,datatype element,datatype new_element);
void element_delete(Linklist head,datatype element);
Linklist Unidirectional_list_inversion(Linklist head);
void Find_penultimate_nth(Linklist head,int n);
void single_list_sort(Linklist head);
Linklist free_space(Linklist head);
#endif

test.c

#include "head.h"

int null(Linklist p)
{
        return p==NULL?FALSE:SUCCESS;
}


Linklist create_node()
{
        Linklist p=(Linklist)malloc(sizeof(struct Node));
        if(null(p))
                return NULL;
        p->data=0;
        p->next=NULL;
        return p;
}

Linklist insert_head(Linklist head,datatype element)//头插
{
        Linklist s=create_node();
        if(null(s))
                return head;
        s->data=element;
        s->next=head;
        head=s;
        return head;
}

void output(Linklist head)//输出
{
        if(null(head))
                return;
        Linklist p=head;
        while(p!=NULL)
        {
                printf("%d\t",p->data);
                p=p->next;
        }
        puts("");
}

Linklist insert_tail(Linklist head,datatype element)//尾插
{
        Linklist s=create_node();
        if(null(s))
                return head;
        s->data=element;
        if(null(head))
                head=s;
        else
        {
                Linklist p=head;
                while(p->next!=NULL)
                {
                        p=p->next;
                }
                p->next=s;
        }
        return head;

}

Linklist delete_head(Linklist head)//头删
{
        if(null(head))
                return head;
        Linklist del=head;
        head=head->next;
        free(del);
        del=NULL;
        return head;
}

Linklist delete_tail(Linklist head)//尾删
{
        if(null(head))
                return head;
        else if(head->next==NULL)
        {
                free(head);
        }
        else
        {
                Linklist p=head;
                while(p->next->next!=NULL)
                {
                        p=p->next;
                }
                free(p->next);
                p->next=NULL;
        }
        return head;
}

int length(Linklist head)//长度
{
        Linklist p=head;
        int flag=0;
        while(p!=NULL)
        {
                p=p->next;
                flag++;
        }
        return flag;
}

Linklist insert_pos(Linklist head,int pos,datatype element)//任意位置插入
{
        //判断位置是否合法
        if(pos<1||pos>length(head))
                return head;
        //
        if(pos==1)
        {
                head=insert_head(head,element);
                return head;
        }
        //
        Linklist p=head;
        for(int i=1;i<pos-1;i++)
        {
                p=p->next;
        }
        //
        Linklist s=create_node();
        if(null(s))
                return head;
        s->data=element;
        //
        s->next=p->next;
        p->next=s;
        return head;
}

Linklist delete_pos(Linklist head,int pos)//任意位置删除
{
        if(null(head))
                return head;
        if(pos<1||pos>length(head))
                return head;
        if(pos==1)
        {
                head=delete_head(head);
                return head;
        }
        Linklist p=head;
        for(int i=1;i<pos-1;i++)
        {
                p=p->next;
        }
        Linklist s=p->next;
        p->next=s->next;
        free(s);
        s->next=NULL;
        return head;
}

datatype find_pos(Linklist head,int pos)//任意位置查找
{
        if(null(head))
                return FALSE;
        if(pos<1||pos>length(head))
                return FALSE;
        Linklist p=head;
        for(int i=1;i<pos;i++)
        {
                p=p->next;
        }
        return p->data;
}

void change_pos(Linklist head,int pos,datatype element)//任意位置修改
{
        if(null(head))
                return;
        if(pos<1||pos>length(head))
                return;
        Linklist p=head;
        for(int i=1;i<pos;i++)
        {
                p=p->next;
        }
        p->data=element;

}

void element_find(Linklist head,datatype element)//单向链表任意元素查找
{
        if(null(head))
                return;
        int arr[100];
        int flag=0;
        Linklist p=head;
        for(int i=1;i<=length(head);i++)
        {
                if(p->data==element)
                {
                        arr[flag]=i;
                        flag+=1;
                }
                p=p->next;
        }
        if(flag==0)
        {
                puts("error element!");
        }
                else
        {
                for(int i=0;i<flag;i++)
                        printf("pos is:%d\n",arr[i]);
        }
}

void element_change(Linklist head,datatype element,datatype new_element)//单向链表任意元素修改
{
        if(null(head))
                return;
        int arr[100];
        int flag=0;
        Linklist p=head;
        for(int i=1;i<=length(head);i++)
        {
                if(p->data==element)
                {
                        p->data=new_element;
                        arr[flag]=i;
                        flag+=1;
                }
                p=p->next;
        }
        if(flag==0)
        {
                puts("error element!");
        }
}

Linklist element_delete(Linklist head,datatype element)//单向链表任意元素删除
{
        if(null(head))
                return head;
        int arr[100];
        int flag=0;
        Linklist p=head;
        for(int i=1;i<=length(head);i++)
        {
                if(p->data==element)
                {
                        arr[flag]=i;
                        flag+=1;
                }
                p=p->next;
        }
        if(flag==0)
        {
                puts("error element!");
                return head;
        }
        else
        {
                if(arr[0]==1)
                {
                        head=delete_head(head);
                        for(int i=1;i<flag;i++)
                        {
                                delete_pos(head,arr[i]-1);
                                arr[i+1]-=1;
                        }
                }
                else
                {
                        for(int i=0;i<flag;i++)
                        {
                                delete_pos(head,arr[i]);
                                arr[i+1]-=1;
                        }
                }
        }
        return head;
}


Linklist Unidirectional_list_inversion(Linklist head)//单向链表逆置
{
        if(null(head))
                return head;
        if(length(head)==1)
                return head;
        Linklist p=head;
        p=head->next;
        head->next=NULL;
        while(p!=NULL)
        {
                Linklist t=p;
                p=p->next;
                t->next=head;
                head=t;
        }
        return head;
}

void Find_penultimate_nth(Linklist head,int n)//单向链表查找倒数第n个节点
{
        if(null(head))
                return;
        if(length(head)<n)
                return;
        Linklist p=head;
        Linklist q=head;
        for(int i=0;i<n;i++)
        {
                p=p->next;
        }
        while(p!=NULL)
        {
                p=p->next;
                q=q->next;
        }
        printf("The penultimate %dTH node is:%d\n",n,q->data);
}

void single_list_sort(Linklist head)//单向链表排序-冒泡
{
        if(null(head)||length(head)==1)
                return;
        int len=length(head);
        Linklist p=head;
        for(int i=1;i<len;i++)
        {
                p=head;
                for(int j=0;j<len-i;j++)
                {
                        if(p->data < p->next->data)
                        {
                                datatype t=p->data;
                                p->data=p->next->data;
                                p->next->data=t;
                        }
                        p=p->next;
                }
        }
}

Linklist free_space(Linklist head)//释放内存
{
        if(null(head))
                return NULL;
        for(int i=0;i<length(head);i++)
        {
                head=delete_tail(head);
        }
        free(head);
        head=NULL;
        return head;
}

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
        Linklist head=NULL;

        //头插和尾插
        int n;
        datatype element;
        printf("please enter n:");
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
                printf("please enter %d element:",i+1);
                scanf("%d",&element);
        //      head=insert_head(head,element);//头插
                head=insert_tail(head,element);//尾插
        }

        output(head);

        //头删
//      head=delete_head(head);
//      output(head);

        //尾删
//      head=delete_tail(head);
//      output(head);

        //按位置插入
/*      int pos;
        printf("enter the insert_pos:");
        scanf("%d",&pos);
        printf("enter the element:");
        scanf("%d",&element);
        head=insert_pos(head,pos,element);
        output(head);
*/

        //按位置删除
/*      int pos;
        printf("enter the delete_pos:");
        scanf("%d",&pos);
        head=delete_pos(head,pos);
        output(head);
*/

        //按位置查找
/*      int pos;
        printf("enter the find_pos:");
        scanf("%d",&pos);
        datatype find_pos_data=find_pos(head,pos);
        printf("the data is:%d\n",find_pos_data);
*/

        //按位置修改
/*      int pos;
        printf("enter the change__pos:");
        scanf("%d",&pos);
        printf("enter the element:");
        scanf("%d",&element);
        change_pos(head,pos,element);
        output(head);
*/

        //单链表按任意元素查找
/*      printf("enter the find_element:");
        scanf("%d",&element);
        element_find(head,element);
*/

        //按元素修改
/*      printf("enter the element:");
        scanf("%d",&element);
        datatype new_element;
        printf("enter the new_element:");
        scanf("%d",&new_element);
        element_change(head,element,new_element);
        output(head);
*/

        //按元素删除
/*      printf("enter the element:");
        scanf("%d",&element);
        head=element_delete(head,element);
        output(head);

*/

        //逆置
/*      head=Unidirectional_list_inversion(head);
        output(head);
*/

        //查找倒数第n个节点
/*      printf("enter The penultimate NTH node's pos is:");
        scanf("%d",&n);
        Find_penultimate_nth(head,n);
*/

        //单链表排序-冒泡
        single_list_sort(head);
        output(head);


        free_space(head);

        return 0;
}

实现结果

头插

尾插

头删

尾删

按位置查找

按位置插入

按位置删除

按位置修改

按元素查找

按元素修改

按元素删除

查找倒数第n个节点

逆置

排序