2.20作业-CSDN博客

本文链接：https://blog.csdn.net/YzHoney/article/details/136197683

3.1 创建空的单链表

3.2 头尾操作

1）头插法

2）遍历链表

3）尾插法

4）判断链表是否为空

4）头删法

5）尾删法

3.3 按位置操作

例如输入1，则操作第1个有效数据结点的位置。输入2，则操作第2个有效数据结点的位置

1）按位置插入数据

2）按位置删除数据

3）按位置查找数据

4）直接插入排序

main：

#include <stdio.h>
#include "./01link.h"


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

	head_insert_linklist(head,4);
	head_insert_linklist(head,3);
	head_insert_linklist(head,2);
	head_insert_linklist(head,1);
	show_linklist(head);

	tail_insert_linklist(head,5);
	tail_insert_linklist(head,6);
	tail_insert_linklist(head,7);
	tail_insert_linklist(head,8);

	show_linklist(head);

    datatype i,position,num;
    printf("请输入要插入的位置:");
    scanf("%d",&position);
    printf("请输入要插入的数:");
    scanf("%d",&num);              
	insert_by_position(head,position,num);
	show_linklist(head);

/*
	head_delete_linklist(head);
	show_linklist(head);
	
	tail_delete_linklist(head);
	show_linklist(head);
*/

    printf("请输入要删除的位置:");
    datatype position2;
    scanf("%d",&position2);                 
	delete_by_position(head,position2);
	show_linklist(head);

    printf("请输入要查找的位置:");
    datatype position3;
    scanf("%d",&position3);
	find_by_position(head,position3);


/* === 将 链表翻转  === */
	reverse_linklist(head);
	
	/*
	Direct_insert_sort(head,50);
	Direct_insert_sort(head,3);
	Direct_insert_sort(head,9);
	Direct_insert_sort(head,20);	
	show_linklist(head);
*/
	return 0;
}

func:

#include <stdio.h>
#include <stdlib.h>
#include "./01link.h"

linkList* creat_linkList()
{
	linkList* head = (linkList*)malloc(sizeof(linkList));

	if(head == NULL)
	{
		printf("头结点申请失败!单链表创建失败\n");
		return NULL;
	}
	else
	{
		head->text.len = 0;   //初始 化头结点 中链表长度为0
		head->next = NULL;    //初始 化头结点 中指针域为 null	
		return head;
	}
}

//头插法
void head_insert_linklist(linkList* head,datatype num)
{
	// 将 新链表 temp 头插法 插入 原有的 head 链表中

	//创建一个新的结点
	linkList* temp = (linkList*)malloc(sizeof(linkList));

	if( temp == NULL)
	{
		printf("结点申请失败,头插失败!\n");
		return ;
	}
	else
	{
		temp->text.data = num;
		temp->next = NULL;
	}
	
	// 头插法插入数据
	temp->next = head->next;  //让temp的指针域 存储 当前要插入的链表的 头结点的 下一个结点的地址
	head->next = temp;        //让 头结点 指针域 中存储 temp 结点的地址 ;  

	//更新头结点中记录的 链表的长度
	head->text.len++;

	return ;
}

void show_linklist(linkList* head)
{
	linkList*p = head;
	while(p->next != NULL)
	{
		p = p->next;
		printf("%d ",p->text.data);
	}
	putchar(10);
	return ;
}

//尾插法
void tail_insert_linklist(linkList* head,datatype num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("结点申请失败,尾插失败!\n");
		return ;
	}
	else
	{
		temp->text.data = num;
		temp->next = NULL;
	}
	linkList* p=head;
	//找到链表的尾结点
	while(p->next != NULL)
	{
		p=p->next;
	}
	p->next = temp;
	temp->next = NULL;
	
	head->text.len++;

	return ;
	
}

int isEmpty_linklist(linkList* head)
{
	return head->next == NULL?1:0;
}

/*  =====  头删法  ====    */
datatype head_delete_linklist(linkList* head)
{
	if(isEmpty_linklist(head))
	{
		printf("链表为空,头删失败!\n");
		return 0;
	}
	linkList* temp = head->next;
	head->next = temp->next;
	
	datatype num = temp->text.data;
	free(temp);	temp=NULL;
	
	printf("删除%d成 功\n",num);
	head->text.len--;
	return num;
}

/* ====  尾删法  ====  */
datatype tail_delete_linklist(linkList* head)
{
	if(isEmpty_linklist(head))
	{
		printf("链表为空,尾删失败!\n");
		return 0;
	}
	linkList* p = head;
	while(p->next->next != NULL)
	{
		p=p->next;
	}
	linkList* temp = p->next;
	p->next = temp->next;

	datatype num = temp->text.data;
	free(temp); temp=NULL;
	printf("删除%d成功\n",num);

	head->text.len--;

	return num;
}



//按位置插入
void insert_by_position(linkList* head, int position, datatype num)
{
	if(position < 1 || position > head->text.len+1 )
	{
		printf("position=%d 插入非法位置,无法插入\n",position);
		return ;
	}
	linkList* p = head;
    datatype i;
//找到要插入的位置的前一位
    for(i=0; i<position-1; i++) 
    {
        p=p->next;
    }

    linkList* temp = (linkList*)malloc(sizeof(linkList));
    if(temp == NULL)                                     
    {                                                    
        printf("结点申请失败,尾插失败!\n");              
        return ;                                         
    }                                                    
    temp->text.data = num;                           
    temp->next = NULL;

	// 进行插入操作
	temp->next = p->next;
	p->next = temp;

	head->text.len++;
	return ;
}

/* === 按位置删除 === */
datatype delete_by_position(linkList* head,int position)
{
	if(isEmpty_linklist(head))
    {                                  
        printf("链表为空,按位置删失败!\n");
        return 0;                      
    }
	//判断删除位置是否合法
	if(position < 1 || position > head->text.len )
    {
        printf("position=%d 删除非法位置,无法删除\n",position);
        return 0;
    }

	linkList* p=head;
	datatype i;
	for(i=0; i<position-1; i++)
	{
		p=p->next;
	}
	// 进行删除操作
	linkList* temp = p->next;
	p->next = temp->next;

	// 将删除的数暂存
	datatype num = temp->text.data;
	free(temp); temp=NULL;
	printf("删除%d成功\n",num);

	head->text.len--;
	printf("链表长:%d\n",head->text.len);
	return num;
}


/* === 按位置查找 === */
void find_by_position(linkList* head,int position)
{
	if(isEmpty_linklist(head))             
	{                                      
		printf("链表为空,查找失败!\n");
		return ;                          
	}
	if(position < 1 || position > head->text.len )
    {
        printf("position=%d 查找非法位置,无法查找\n",position);
        return ;
    }                                                          
	linkList* p=head;
	datatype i;
	for(i=0; i<position; i++)                     
	{                                      
		p=p->next;                         
	}                                      
	printf("查找成功,第%d位是:%d\n",position,p->text.data);            
	return ;
}

/*  === 直接插入排序 ===  */
void Direct_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;
	while(p->next != NULL)
	{
		if(p->next->text.data > temp->text.data)
		{
			break;
		}
		else
		{
			p=p->next;
		}
	}

	temp->next = p->next;
	p->next = temp;

	head->text.len++;
	return ;
}

                                      
/* === 将 链表翻转  === */            
void reverse_linklist(linkList* head) 
{                                     
    linkList* p; 
	datatype i;
    for(i=0; i<(head->text.len); i++)    
    {                                 
        p=head_delete_linklist(head);    
       	head_insert_linklist(head,p); 
    }                                 
    show_linklist(head);              
    return ;                          
}

.h:

#ifndef __LINKLIST__
#define __LINKLIST__

typedef int datatype; 
                      
union msg             
{                     
    datatype data;    
    int len;          
};                    
                      
typedef struct node   
{                     
    union msg text;     // 数据域 头结点 用text.len, 不是头节点 用text.data 
    struct node* next;  // 指针域
                      
}linkList;            


linkList* creat_linkList();
void head_insert_linklist(linkList* head,datatype num); 
void show_linklist(linkList* head);
void tail_insert_linklist(linkList* head,datatype num);
datatype head_delete_linklist(linkList* head);
datatype tail_delete_linklist(linkList* head);

//按位置
void insert_by_position(linkList* head, int position, datatype num);
datatype delete_by_position(linkList* head, int position); 
void find_by_position(linkList* head, int position); 

void reverse_linklist(linkList* head); 

void Direct_insert_sort(linkList* head,datatype num);


#endif