精华内容
下载资源
问答
  • linklist.h#pragma once #include<stdio.h> #include<stdlib.h> typedef int datatype; typedef struct LinkNode { datatype data;...node *addback(node *phead, da...

    linklist.h

    #pragma once
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef int datatype;
    typedef struct LinkNode
    {
    	datatype data;
    	struct LinkNode *pNext;
    
    }node;
    
    node *addback(node *phead, datatype data);//尾部添加节点
    void addhead(node **pphead, datatype data);//头插
    
    void showall(node *phead);//显示
    void revshowall(node *phead);
    
    node *searchfirst(node *phead, datatype data);
    node *changefirst(node *phead, datatype data, datatype newdata);
    
    node *deletefirst(node *phead, datatype data);//删除
    node *insertfirst(node *phead, datatype data, datatype newdata);
    node *insertback(node *phead, datatype data, datatype newdata);
    
    void selectsort(node *phead);
    
    void myquicksort(node *phead, node *pback);
    
    int getnum(node *phead);
    
    node *revlist(node *phead);
    node *getmin(node *phead);//获取中间值
    node *revlistdigui(node *phead);
    
    node *addlinklist(node *list1, node *list2);
    


    linklist.c

    #include"linklist.h"
    void addhead(node **pphead, datatype data)//头插
    {
    	node *pnew = malloc(sizeof(node));
    	pnew->data = data;
    	pnew->pNext = NULL;
    
    	if (*pphead==NULL)
    	{
    		*pphead = pnew;
    
    	}
    	else
    	{
    		pnew->pNext = *pphead;
    		*pphead = pnew;
    	}
    
    
    }
    //尾插,改变一个指针,需要指针的地址,或者用返回值给指针赋值
    node *addback(node *phead, datatype data)//尾部添加节点
    {
    	node *pnew = malloc(sizeof(node));
    	pnew->data = data;
    	pnew->pNext = NULL;
    	
    	if (phead==NULL)
    	{
    		phead = pnew;
    
    	}
    	else
    	{
    		node *ptemp = phead;  //备份头结点
    		while (ptemp->pNext!=NULL)
    		{
    			ptemp = ptemp->pNext;
    
    		}
    		ptemp->pNext = pnew;
    	}
    	return phead;
    	
    
    
    }
    
    void showall(node *phead)//显示
    {
    	if (phead==NULL)
    	{
    		return;
    
    	}
    	else
    	{
    		printf("%d %p %p\n", phead->data, phead, phead->pNext);
    		showall(phead->pNext);
    	}
    
    
    
    }
    void revshowall(node *phead)//反转显示
    {
    	if (phead == NULL)
    	{
    		return;
    
    	}
    	else
    	{
    		
    		revshowall(phead->pNext);
    		printf("%d %p %p\n", phead->data, phead, phead->pNext);
    	}
    
    
    
    }
    
    node *searchfirst(node *phead, datatype data)
    {
    	for (node *p=phead;p!=NULL ;p=p->pNext)
    	{
    		if (p->data==data)
    		{
    			return p;
    
    		}
    
    	}
    	return NULL;
    
    
    }
    
    node *changefirst(node *phead, datatype data,datatype newdata)
    {
    	for (node *p = phead; p != NULL; p = p->pNext)
    	{
    		if (p->data == data)
    		{
    			p->data = newdata;
    
    			return phead;
    		}
    
    	}
    	return NULL;
    	
    
    
    }
    
    node *deletefirst(node *phead, datatype data)
    {
    	node *p1, *p2=NULL;
    	p1 = phead;
    	while (p1!=NULL)
    	{
    		if (p1->data!=data)
    		{
    			p2 = p1;
    			p1 = p1->pNext;
    		}
    		else
    		{
    			break;
    		}
    		
    		
    	}
    	if (p1==phead)
    	{
    		phead = phead->pNext;
    		free(p1);
    	}
    	else
    	{
    		p2->pNext = p1->pNext;
    		free(p1);
    	}
    
    	return phead;
    }
    
    node *insertfirst(node *phead, datatype data, datatype newdata)
    {
    	node *p1, *p2 = NULL;
    	p1 = phead;
    	while (p1!=NULL)
    	{
    		if (p1->data==data)
    		{
    			break;
    
    		}
    		else
    		{
    			p2 = p1;
    			p1 = p1->pNext;
    		}
    
    	}
    	
    	node *pnew = malloc(sizeof(node));
    	pnew->data = newdata;
    	pnew->pNext = NULL;
    	
    	if (p1==phead)
    	{
    		pnew->pNext = phead;
    		phead = pnew;
    	}
    	else
    	{
    		p2->pNext = pnew;
    		pnew->pNext = p1;
    	}
    
    
    
    }
    
    node *insertback(node *phead, datatype data, datatype newdata)
    {
    	node *p1;
    	p1 = phead;
    	while (p1!=NULL)
    	{
    		if (p1->data==data)
    		{
    			break;
    
    		}
    		else
    		{
    			
    			p1 = p1->pNext;
    			
    		}
    	}
    
    	node *pnew = malloc(sizeof(node));
    	pnew->data = newdata;
    	pnew->pNext = p1->pNext;
    	p1->pNext = pnew;
    	
    	return phead;
    
    
    }
    
    
    void selectsort(node *phead)
    {
    	for (node *p1=phead; p1!=NULL; p1=p1->pNext)
    	{
    		for (node *p2 = phead; p2!=NULL  ; p2=p2->pNext)
    		{
    			if (p1->data<p2->data)
    			{
    				datatype temp;
    				temp = p1->data;
    				p1->data = p2->data;
    				p2->data = temp;
    				
    			}
    
    		}
    	}
    	return phead;
    
    
    }
    
    
    void myquicksort(node *phead, node *pback) //快速排序法
    {
    	if (phead==pback)
    	{
    		return;
    
    	}
    	else
    	{
    		int key = phead->data;//获取第一个值,分界线
    		node *p1 = phead;
    		for (node *p2 = phead->pNext; p2!=pback; p2=p2->pNext)
    		{
    			if (p2->data<key)
    			{
    				p1 = p1->pNext;
    
    				datatype temp = p1->data;
    				p1->data = p2->data;
    				p2->data = temp;
    
    			}
    		}
    		datatype temp2 = p1->data;
    		p1->data = phead->data;
    		phead->data = temp2;
    
    		myquicksort(phead, p1);
    		myquicksort(p1->pNext, pback);
    	}
    
    	
    }
    
    int getnum(node *phead)
    {
    	int i = 0;
    	for (; phead != NULL; i++, phead = phead->pNext);
    	return i;
    	
    
    }
    
    //翻转
    node *revlist(node *phead)
    {
    	if (phead==NULL||phead->pNext==NULL)
    	{
    		return NULL;
    
    	}
    	else
    	{
    		node *pre = NULL;
    		node *pcur = NULL;
    		node *pnext = NULL;
    
    		pre = phead; //第一个节点
    		pcur = phead->pNext;
    		
    
    		while (pcur!=NULL)
    		{
    			pnext = pcur->pNext; //下一个节点,备份下一个节点
    			pcur->pNext = pre;	//指针翻转
    			
    			pre = pcur;//前进
    			pcur = pnext;
    		}
    		phead->pNext = NULL;
    		phead = pre;
    		return phead;
    	}
    
    }
    
    node *revlistdigui(node *phead)
    {
    	if (phead==NULL||phead->pNext==NULL)
    	{
    		return phead;
    
    	}
    	else
    	{
    		node *pnext = phead->pNext;
    		node *head=revlistdigui(pnext);	//递归调用 
    		
    		pnext->pNext = phead;
    		phead->pNext = NULL;
    
    		return head;
    	}
    
    
    }
    
    node *getmin(node *phead)
    {
    	if (phead==NULL||phead->pNext==NULL)
    	{
    		return phead;
    
    
    	}
    	else
    	{
    		node *p1=phead;
    		node *p2=phead;
    		while (p2->pNext!=NULL)
    		{
    			p1 = p1->pNext;	 
    			p2 = p2->pNext;
    			if (p2->pNext!=NULL)
    			{
    				p2 = p2->pNext;
    			}
    
    			
    
    		}
    		return p1;
    	}
    
    
    }
    
    node *addlinklist(node *list1, node *list2)
    {
    	node *temp = list1;
    	while (temp->pNext!=NULL)
    	{
    		temp = temp->pNext;
    
    	}
    	temp->pNext = list2;
    	return list1;
    
    }
    
    
    
    
    
    
    
    
    
    

    main.c

    #include"linklist.h"
    
    void main()
    {
    	node *phead=NULL;
    	
    	phead = addback(phead, 11);
    	phead = addback(phead, 12);
    	phead = addback(phead, 13);
    	phead = addback(phead, 14);
    	phead = addback(phead, 15);
    	phead = addback(phead, 16);
    	addhead(&phead, 20);
    	addhead(&phead, 21);
    	addhead(&phead, 22);
    	addhead(&phead, 23);
    	addhead(&phead, 24);
    	//node *pfind = searchfirst(phead, 21);
    	//printf("%d %p\n", pfind->data, pfind);
    	insertback(phead, 16, 459);
    	addback(phead, 555);
    	//selectsort(phead);
    	//myquicksort(phead, NULL);
    	//showall(phead);
    	//phead=revlistdigui(phead);
    
    	node *phead2 = NULL;
    	phead2 = addback(phead2, 999);
    	phead2 = addback(phead2, 888);
    	phead2 = addback(phead2, 777);
    
    	phead=addlinklist(phead, phead2);
    	phead=revlist(phead);
    	selectsort(phead);
    	showall(phead);
    
    	//node *ptemp = getmin(phead);
    	//printf("\n%d %p", ptemp->data,ptemp);
    	system("pause");
    
    }



    展开全文
  • myarray.h#pragma once #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt;...typedef int datatype;...struct Res//创建一个新的结构体用来存储二级指针(用来存储返回查找到的重复元...

    myarray.h

    #pragma once
    #include<stdlib.h>
    #include<stdio.h>
    typedef int datatype;
    typedef struct myarray
    {
    	datatype *data;
    	int length;
    }array;
    
    struct Res//创建一个新的结构体用来存储二级指针(用来存储返回查找到的重复元素)
    {
    	datatype **ppstart;//创建指针数组
    	int n;
    
    };
    
    struct Res findall(array *pstart, datatype data);
    
    
    void init(array *pstart);
    void initwithdata(array *pstart, datatype data);
    void initwitharray(array *pstart, datatype *data, int datalength);
    void show(array *pstart);
    void addwithdata(array *pstart, datatype data);
    void addwitharray(array *pstart, datatype *data, int datalength);
    datatype *findfirst(array *pstart, datatype data);
    void deletedata(array *pstart, datatype data);
    void deletealldata(array *pstart, datatype data);
    void changedata(array *pstart, datatype data, datatype newdata);
    void changealldata(array *pstart, datatype data, datatype newdata);
    void insertdata(array *pstart, datatype data,datatype newdata);
    void insertarray(array *pstart, datatype data, datatype *newdata, int insertlength);
    
    

    myarray.c

    #include "myarray.h"
    
    
    struct Res findall(array *pstart, datatype data)
    {	
    	struct Res res;
    	res.n = 0;
    	for (int i = 0; i < pstart->length; i++)
    	{
    		if (pstart->data[i]==data)
    		{
    			res.n++;
    		}
    
    	}
    	res.ppstart = malloc(sizeof(datatype *)*res.n);
    	int j = 0;
    	for (int i = 0; i < pstart->length; i++)
    	{
    		if (pstart->data[i]==data)
    		{
    			res.ppstart[j++] = pstart->data + i;
    
    		}
    
    	}
    	return res;
    
    
    }
    void init(array *pstart)
    {
    	if (pstart!=NULL)
    	{
    		pstart->data = NULL;
    		pstart->length = 0;
    		
    
    	}
    	else
    	{
    		printf("init error");
    	}
    	
    
    }
    void initwithdata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data==NULL||pstart->length==0&&data!=NULL)
    		{
    			pstart->data = malloc(sizeof(datatype));
    			*(pstart->data) = data;
    			pstart->length++;
    
    
    		}
    		else
    		{
    			printf("initwithdata error\n");
    		}
    
    	}
    	else
    	{
    		printf("initwithdata error\n");
    	}
    
    }
    void initwitharray(array *pstart, datatype *data, int datalength)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data==NULL||pstart->length==0&&data!=NULL)
    		{
    			pstart->data = malloc(sizeof(datatype)*datalength);
    			for (int i = 0; i < datalength; i++)
    			{
    				pstart->data[i] = data[i];
    			}
    
    			pstart->length += datalength;
    
    		}
    		else
    		{
    			printf("initwitharray error\n");
    		}
    
    	}
    	else
    	{
    		printf("initwitharray error\n");
    	}
    
    }
    
    void show(array *pstart)
    {	
    	printf("数组内情况:");
    	if (pstart!=NULL)
    	{
    		for (int i = 0; i < pstart->length; i++)
    		{
    			printf("%4d", pstart->data[i]);
    		}
    		printf("\n");
    
    	}
    	else
    	{
    		printf("没有数据\n");
    	}
    
    }
    
    void addwithdata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data!=NULL||pstart->length!=0)
    		{
    			pstart->data = realloc(pstart->data, (pstart->length + 1) * sizeof(datatype));
    			(pstart->data)[pstart->length] = data;
    			pstart->length++;
    
    		}
    		else
    		{
    			init(pstart);
    			initwithdata(pstart, data);
    		}
    
    	}
    	else
    	{
    		printf("addwithdata error");
    	}
    
    }
    void addwitharray(array *pstart, datatype *data, int datalength)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data!=NULL||pstart->length!=0)
    		{
    			pstart->data = realloc(pstart->data, (pstart->length + datalength) * sizeof(datatype));
    			datatype *temp=(pstart->data) + (pstart->length);
    			for (size_t i = 0; i < datalength; i++)
    			{
    				*(temp + i) = data[i];
    
    			}
    			pstart->length += datalength;
    
    		}
    		else
    		{
    			init(pstart);
    			initwitharray(pstart, data, datalength);
    		}
    
    
    	}
    	else
    	{
    		printf("addwitharray error");
    	}
    
    }
    void changealldata(array *pstart, datatype data, datatype newdata)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没有数据改什么该");
    
    		}
    		else
    		{
    			for (datatype *p=pfind; p!=NULL;p=findfirst(pstart,data))
    			{
    				changedata(pstart, data,newdata);
    			}
    		}
    
    	}
    	else
    	{
    		printf("changealldata error");
    	}
    
    
    
    }
    
    void changedata(array *pstart, datatype data,datatype newdata)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没有找到要更改的数据");
    
    		}
    		else
    		{
    			int curr = pfind - pstart->data;
    			pstart->data[curr] = newdata;
    			
    		}
    
    	}
    	else
    	{
    		printf("changedata error");
    	}
    
    
    
    }
    
    void deletedata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没找到,怎么删除");
    		}
    		else
    		{
    			int curr = pfind - (pstart->data); //地址(指针)相减等于下标
    
    
    			for (int i = curr; i < pstart->length - 1; i++)
    			{
    				pstart->data[i] = pstart->data[i + 1];
    			}
    			pstart->length-=1;
    			pstart->data = realloc(pstart->data, (pstart->length) * sizeof(datatype));
    
    
    		}
    		
    		
    		
    
    	}
    	else
    	{
    		printf("deletedata error");
    	}
    
    }
    
    void deletealldata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没有数据删除个鬼");
    			
    
    		}
    		else
    		{
    			for (datatype *p=pfind; p!=NULL; p=findfirst(pstart,data))
    			{
    				deletedata(pstart, data);
    			}
    		}
    	}
    	else
    	{
    		printf("deletealldata errors");
    	}
    
    }
    
    datatype *findfirst(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data!=NULL||pstart->length!=0)
    		{
    			for (int i = 0; i < pstart->length; i++)
    			{
    				if (pstart->data[i]==data)
    				{
    					return pstart->data + i;
    
    				}
    
    			}
    			return NULL;
    
    		}
    		else
    		{
    			return NULL;
    		}
    
    	}
    	else
    	{
    		return NULL;
    	}
    
    
    }
    
    void insertarray(array *pstart, datatype data, datatype *newdata, int insertlength)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("找不到怎么插入");
    
    		}
    		else
    		{
    			int curr = pfind - pstart->data;
    			pstart->data = realloc(pstart->data, sizeof(datatype)*(pstart->length + insertlength));
    			for (int i = pstart->length; i >curr; i--)
    			{
    				pstart->data[i + insertlength - 1] = pstart->data[i - 1];
    
    			}
    			for (int i = 0; i < insertlength; i++)
    			{
    				pstart->data[i + curr] = newdata[i];
    			}
    			pstart->length += insertlength;
    		}
    
    	}
    	else
    	{
    		printf("insertarray error");
    	}
    
    
    }
    void insertdata(array *pstart, datatype data, datatype newdata)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没找到怎么插入??");
    
    		}
    		else
    		{
    			int curr = pfind - pstart->data;
    			pstart->data = realloc(pstart->data, (pstart->length + 1) * sizeof(datatype)); //注意这里是给pstart->data重新分配内存而不是给整个结构体
    			for (int i = pstart->length; i >curr ; i--)
    			{
    				pstart->data[i] = pstart->data[i - 1];
    			}
    			pstart->data[curr] = newdata;
    			pstart->length++;
    		}
    
    	}
    	else
    	{
    		printf("insertdata error");
    	}
    
    }
    main.c
    #include"myarray.h"
    
    void main()
    {
    	int data = 5;
    	int date[3] = { 5,2,3 };
    	int a[4] = { 5,6,7,8 };
    	int c[4] = { 9,10,11,12 };
    	array Myarray;
    	init(&Myarray);	//必须先初始化
    
    	initwitharray(&Myarray, date, 3);
    	addwithdata(&Myarray, data);
    	addwitharray(&Myarray, a, 4);
    	//deletealldata(&Myarray, 5);  
    	//changealldata(&Myarray, 5, 4);
    	//insertdata(&Myarray, 6, 9);
    	//insertarray(&Myarray, 6, c, 4);
    	struct Res res=findall(&Myarray, 5);
    	for (int i = 0; i < res.n; i++)
    	{
    		printf("%p %d\n", res.ppstart[i], *res.ppstart[i]);
    
    	}
    	show(&Myarray);
    
    
    
    
    	system("pause");
    }

    展开全文
  • 环形链表.h#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct Linknode ...//node结构体变量,PNODE代表一个指针指向结构体 PNODE addback(PNODE phead, int dat...

    环形链表.h

    #include<stdio.h>
    #include<stdlib.h>
    
    
    
    
    typedef struct Linknode
    {
    	int data;
    	struct Linknode *pNext;
    
    }node, *PNODE;//node结构体变量,PNODE代表一个指针指向结构体
    
    PNODE addback(PNODE phead, int data);//尾部插入
    PNODE addfront(PNODE phead, int data);
    PNODE changedata(PNODE phead, int data, int newdata);
    PNODE deletedata(PNODE phead, int data);//删除
    PNODE insertback(PNODE phead, int data, int newdata);
    PNODE inserthead(PNODE phead, int data, int newdata);
    
    PNODE findfirst(PNODE phead, int data);//查找的数据
    
    void showall(PNODE phead);

    环形链表.c

    #include"环形链表.h"
    
    PNODE addback(PNODE phead, int data)//尾部插入
    {
    	PNODE pnew = malloc(sizeof(node));
    	pnew->data = data;//分配空间
    	if (phead==NULL)
    	{
    		phead = pnew;
    		pnew->pNext = phead;//一个节点的环
    
    	}
    	else
    	{
    		//循环到尾部
    		PNODE p = phead;
    		while (p->pNext!=phead)
    		{
    			p = p->pNext;
    
    		}
    		p->pNext = pnew;//连接上新的
    		pnew->pNext = phead;//链道开头
    	}
    	return phead;
    
    }
    PNODE addfront(PNODE phead, int data) //头部插入
    {
    	PNODE pnew = malloc(sizeof(node));
    	pnew->data = data;
    	if (phead==NULL)
    	{
    		phead = pnew;
    		pnew->pNext = phead;
    
    	}
    	else
    	{
    		PNODE p = phead;
    		while (p->pNext!=phead)
    		{
    			p = p->pNext;
    
    		}
    		p->pNext = pnew;
    		pnew->pNext = phead;
    		phead = pnew;
    	}
    	return phead;
    	
    
    
    
    }
    
    void showall(PNODE phead) //展示
    {
    	if (phead==NULL)
    	{
    		return;
    
    	}
    	else if (phead->pNext==phead)
    	{
    		printf("%d %p %p\n", phead->data, phead, phead->pNext);//打印一个节点的情况
    	}
    	else
    	{
    		PNODE p = phead;
    		while (p->pNext!=phead)
    		{
    
    			printf("%d %p %p\n", p->data, p, p->pNext);
    			p = p->pNext;//循环
    
    		}
    		printf("%d %p %p\n", p->data, p, p->pNext);
    	}
    	
    
    }
    
    PNODE findfirst(PNODE phead, int data)//查找
    {
    	if (phead==NULL)
    	{
    		return NULL;
    
    	}
    	else if(phead->pNext==phead)
    	{
    		if (phead->data==data)
    		{
    			return phead;
    		}
    		else
    		{
    			return NULL;
    		}
    
    	}
    	else
    	{
    		PNODE p = phead;
    		while (p->pNext!=phead)
    		{
    			if (p->data==data)
    			{
    				return p;
    			}
    			p = p->pNext;//循环
    
    		}
    		if (p->data==data)
    		{
    			return p;
    		}
    		return NULL;
    	}
    
    
    
    
    }
    
    PNODE deletedata(PNODE phead, int data)//删除
    {
    
    	PNODE p1 = NULL;
    	PNODE p2 = NULL;
    	p1 = phead;
    	if (p1->data==data)
    	{
    		 p2 = phead;
    		while (p1->pNext!=phead)
    		{
    			p1 = p1->pNext;
    		}
    		p1->pNext = phead->pNext;
    		free(p2);
    		phead = p1->pNext;
    		return phead;
    	}
    	else
    	{
    		while (p1->pNext!=phead)
    		{
    			if (p1->data==data)
    			{
    				p2->pNext = p1->pNext;
    				free(p1);
    				return phead;
    
    			}
    			else
    			{
    				p2 = p1;
    				p1 = p1->pNext;
    			}
    
    		}
    		if (p1->data==data)
    		{
    			p2->pNext = p1->pNext;
    			free(p1);
    			return phead;
    		}
    	}
    	
    
    
    
    }
    
    PNODE changedata(PNODE phead, int data,int newdata)	//修改
    {
    	if (phead==NULL)
    	{
    		printf("changedata error");
    
    	}
    	else if (phead->pNext == phead)
    	{
    		if (phead->data==data)
    		{
    			phead->data = newdata;
    		}
    		else
    		{
    			printf("changedata error");
    		}
    			
    	}
    	else
    	{
    		PNODE p = phead;
    		while (p->pNext!=phead)
    		{
    			if (p->data==data)
    			{
    				p->data = newdata;
    				
    			}
    			p = p->pNext;
    
    		}
    		if (p->data == data)
    		{
    			p->data = newdata;
    			
    		}
    		
    
    	}
    
    	return phead;
    }
    
    PNODE insertback(PNODE phead, int data,int newdata)	//后插
    {
    	PNODE pnew = malloc(sizeof(node));
    	pnew->data = newdata;
    	if (phead->pNext==phead)
    	{
    		if (phead->data==data)
    		{
    			phead->pNext = pnew;
    			pnew->pNext = phead;
    			return phead;
    
    		}
    
    	}
    	else
    	{
    		PNODE p = phead;
    		while (p->pNext!=phead)
    		{
    			if (p->data==data)
    			{
    				pnew->pNext = p->pNext;
    				p->pNext = pnew;
    				return phead;
    
    			}
    			else
    			{
    				p = p->pNext;
    			}
    
    		}
    		if (p->data == data)
    		{
    			pnew->pNext = p->pNext;
    			p->pNext = pnew;
    			return phead;
    
    		}
    	}
    	
    
    
    }
    
    PNODE inserthead(PNODE phead, int data, int newdata)//前插
    {
    	PNODE pnew = malloc(sizeof(node));
    	pnew->data = newdata;
    	if (phead->pNext==phead)
    	{
    		if (phead->data==data)
    		{
    			pnew->pNext = phead;
    			phead->pNext = pnew;
    			phead = pnew;
    			return phead;
    
    		}
    		
    
    	}
    	else
    	{
    		PNODE p = phead;
    		if (p->data==data)
    		{
    			while (p->pNext!=phead)
    			{
    				p = p->pNext;
    			}
    			p->pNext = pnew;
    			pnew->pNext = phead;
    			phead = pnew;
    			return phead;
    
    		}
    		else
    		{
    			PNODE p1=phead,p2 = NULL;
    			while (p1->pNext != phead)
    			{
    				if (p1->data == data)
    				{
    					pnew->pNext = p1;
    					p2->pNext = pnew;
    					return phead;
    
    				}
    				else
    				{
    					p2 = p1;
    					p1 = p1->pNext;
    				}
    
    			}
    			if (p1->data == data)
    			{
    				pnew->pNext = p1;
    				p2->pNext = pnew;
    				return phead;
    
    			}
    
    		}
    		
    	
    	}
    
    
    
    
    }
    

    main.c

    #include"环形链表.h"
    
    void main()
    {
    	//printf("%d,%d", sizeof(node), sizeof(PNODE));
    	PNODE phead = NULL;//头结点
    
    	for (int i = 0; i < 10; i++)
    	{
    		phead = addback(phead, i);//插入数据
    	}
    	phead = addfront(phead, 11);
    	phead= changedata(phead, 8,12);
    	phead = deletedata(phead, 12);
    	phead = insertback(phead, 7,12);
    	phead = inserthead(phead, 11, 99);
    	phead = inserthead(phead, 99, 100);
    	phead = inserthead(phead, 9, 101);
    	showall(phead);
    
    
    	system("pause");
    
    }

    展开全文
  • 欢迎交流与讨论。 #include "stdlib.h" ... //定义一个结构体(Node)类型的指针变量,用于指向结构体节点 }Node; //链表创建函数,用于链接节点并创建链表,n为节点长度 Node* CreatLinkList(int n) {

    欢迎交流与讨论。

    #include "stdlib.h"
    #include "stdio.h"
    #include "time.h"
    
    //初始化结构体
    typedef struct Node{
        int data_1;
        int data_2;
        struct Node *next;
        //定义一个结构体(Node)类型的指针变量,用于指向结构体节点
    }Node;
    
    //链表创建函数,用于链接节点并创建链表,n为节点长度
    Node* CreatLinkList(int n)
    {
        //定义头,尾,链表,临时节点。
        Node *head, *tail, *L,*temp = NULL;
        //给头节点分配空间
        head = (Node*)malloc(sizeof(Node));
        //tail = head用于保存头节点信息,用于头插法清空尾节点的next
        tail = head;
        //随机数种子
        srand(time(0));
        for(int i = 0;i < n; i++)
        {
            if(i == 1)
            temp = head;//头插法去掉空节点
            L = (Node*)malloc(sizeof(Node));
            L->data_1 = rand()%10 + 1;
            L->data_2 = rand()%10 + 2;
            //tail->next = L;尾插法
            //tail = L;
            L->next = head;//头插法
            head = L;
        }
        //head = head->next;//尾插法去掉空节点
        temp->next = NULL;//头插法去掉空节点
        tail->next = NULL;
        //返回头节点
        return head;
    }
    
    //链表遍历函数,用于打印节点信息
    void LinkListPrint(Node *L)
    {
        //当L != 0的时候循环继续
        while(L)
        {
            printf("L->data_1 = %d\nL->data_2 = %d\n",L->data_1,L->data_2);
            L = L->next;
        }
    }
    
    //建立插入节点
    Node* SetNode()
    {
        Node* new = (Node*)malloc(sizeof(Node));
        new->data_1 = 11;
        new->data_2 = 11;
        //new->data_1 = rand()%10+10;
        //new->data_2 = rand()%10+20;
        //返回新生成的节点
        return new;
    }
    
    //插入节点函数
    //L为被插入链表,n为插入位置,new为插入节点
    void InsertNode(Node* L, int n, Node *new)
    {
        //用于临时存放被插入节点后一节点的节点指针
        Node *temp;
        for(int i = 0;i < n;i++)
        {
            //遍历链表
            L = L->next;
            //遍历从0开始,n-2是new节点插入后位置为n,n-1为插入节点new为n
            if(i == n-2)
            {
                //临时保存new节点后一节点地址信息
                temp = L->next;
                //new节点插入链表L
                L->next = new;
                //new节点接上后面的链表
                new->next = temp;
            }
        }
    }
    
    //修改节点信息函数
    void ModifyNodeData(Node *L, int n)
    {
        for (int i = 0;i < n; i++)
        {
            L = L->next;
            if (i == n-2)
            {
                //可以加入修改函数修改
                L->data_1 = 0;
                L->data_2 = 0;
            }
        }
    }
    
    //节点删除函数,L为被操作链表,n为被删除节点
    void DeleteNode(Node *L,int n)
    {
        Node *temp;
        for(int i = 0;i < n;i++)
        {
            if(i == n-1)
            {
                //获取下一节点信息
                temp = L->next;
                //L->next = L->next->next;
                L->next = temp->next;
                //free(temp);
            }
            L = L->next;
        }
    }
    
    //合并链表,将链表new合并到链表L
    void LinkList(Node *L,Node *new)
    {
        //临时结构体指针变量
        Node *temp = NULL;
        //L != 0(NULL)时循环继续
        while (L)
        {
            //如果L遍历到了表尾
            if(L->next == NULL)
                //取出表尾
                temp = L;
            L = L->next;
        }
        //表尾连上新链表
        temp->next = new;
    }
    
    //翻转链表函数
    Node* TurnLink(Node* L)
    {
        //定义节点当前,上一个,临时
        Node *now,*previous,*temp;
        //上一个节点 = L
        previous = L;
        //当前节点 = L->next
        now = L->next;
        //前一节点指向当前节点
        previous->next = NULL;
        //当前节点为空时结束循环
        while (now != NULL) {
            //temp暂存下一节点
            temp = now->next;
            //下一节点变为前一节点
            now->next = previous;
            //前一节点变为单曲节点
            previous = now;
            //下一节点变为当前节点
            now = temp;
        }
        //返回前一节点
        return previous;
    }
    
    int main()
    {
        Node *L,*new;
        Node *NewLink = (Node*)malloc(sizeof(Node));
        NewLink->data_1 = 88;
        NewLink->data_2 = 88;
        NewLink->next = NULL;
        L = CreatLinkList(5);
        printf("创建\n");
        LinkListPrint(L);
        new = SetNode();
        printf("插入\n");
        InsertNode(L, 3, new);
        LinkListPrint(L);
        printf("删除\n");
        DeleteNode(L,4);
        LinkListPrint(L);
        printf("修改\n");
        ModifyNodeData(L, 3);
        LinkListPrint(L);
        printf("链接\n");
        LinkList(L, NewLink);
        LinkListPrint(L);
        printf("翻转\n");
        LinkListPrint(TurnLink(L));
        return 0;
    }
    
    
    展开全文
  • 链表的运用非常广泛,而对于一个链表的创建,常见的方法有头插法和尾插法,而对于链表的增删改查的函数又可以以直接接受数据为主和接受节点指针为主,上一篇文章中我就接受数据为主做了一个尾插法的链表完整源代码,这次...
  • 常见最为典型的就是数组了,在数组里完成增删查改 顺序表主要分为两类 静态顺序表:使用定长数组存储数据 动态顺序表:动态开辟存储空间存储 顺序表结构定义: 顺序表结构采用C语言结构体定义,为实现动态顺序表...
  • .h文件(声明函数、引用头文件、结构体)、.c文件(函数的是实现、主函数) .h文件 #ifndef __CONTACT_H__ #define __CONTACT_H__ #include <stdio.h> #include <stdlib.h> #include <assert.h>...
  • 实现基本的、查、改、排序、打印、清空基本功能。 思路分析: 首先我们可以分三个模块来解决这个问题,第一个模块我们需要一个头文件,这个头文件里可以包含一些相应信息,当实现文件和测试文件包含自己...
  • 顺序表的一些基本操作算法(copy可以直接运行),附上代码: ...//定义结构体顺序表 typedef struct Seq { ElementType data[MaxSize]; int length; }Seq; //顺序表初始化 void init(Seq* L) { L
  • 目录链表的结构体以及函数声明链表初始化创建节点查找节点插入节点删除节点 链表的结构体以及函数声明 typedef int LTDataType; typedef struct ListNode { LTDataType data; struct ListNode* prev; struct ...
  • C语言结构体能够帮我们实现一些程序的增删查改操作,能够让我们更轻易的实现一些操作,在结构体中,一定要注意传参和类型的定义,而且一个小小的建议就是在写程序时可以写一点测一点,这样容易排查错误,最好不要...
  • //链表的使用 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<...//定义链表结构体 struct LinkCode{ int num; char sname[50]; struct ...
  • c语言学生管理系统

    2012-08-02 18:52:16
    学生管理系统,对学生成绩的增删查改,运用到结构体、链表等知识
  • c语言 初级链表

    多人点赞 热门讨论 2021-04-17 14:00:26
    单向不带头非循环链表什么是链表最简单链表的增删查改 什么是链表 链表: 通过指针将一系列离散的数据关联起来的数据整体叫链表 链表逻辑关系图示: 插入一点题外话: 这个链表就像楼房一样 数据就是每一层的房间,...
  • C语言关于顺序表的整理一、结构体的创建二、顺序表初始化函数三、顺序表增删查改功能函数的实现1、元素逐个增加2、指定位置插入元素3、删除全部元素4、删除指定位置元素5、检查顺序表是否为空6、修改指定位置的值7、...
  • C语言实现静态顺序表

    2018-11-17 15:22:41
    3.增删查改; 4.顺序表的逆置等。 #define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType data[MAX_SIZE]; DataType length; }SeqList; //顺序表的初始化就是...
  • 数据结构——C语言实现顺序表

    千次阅读 2019-09-11 23:03:34
    在数组上完成数据的增删查改,而结构体中包含了存储数据的数组、所存储数据的实际长度以及顺序表的容量。 顺序表一般可分为: 1.静态顺序表:使用定长数组存储 #define N 100 typedef int SLDataType; typede.....
  • 带有IO操作,可以按照结构体里的变量在记事本里将内容写好,一个学生一行,每个字段用空格隔开,空格个数不限,然后改一下文件打开路径为你的记事本路径,就可以打开文件了,增删查改都可以。
  • 所谓数据结构顺序表和链表的基本操作,实际上就是实现对一个顺序表(链表)的增删查改及其其他接口的实现。 顺序表线性结构存储示意图 C语言顺序表的基本操作 定义顺序表结构体 由长度和数据数组组成: typedef int...
  • c语言仓库管理系统

    2020-12-27 11:06:12
    2、 链表的增删查改的完成 3、 菜单函数的完成 4、 文件的保存及查看 想要创建一个系统就应该先定义一个结构体并确定他的各个结点 下面是代码的实现 #include <stdio.h> #include <string.h> #include...
  • /*链表的增删查改*/ #include<stdio.h> #include<conio.h> #include<stdlib.h> //定义学生人数作为全局变量,方便后面的录入、遍历等 int n; //定义结构体变量 typedef struct PHT{ int data; ...
  • C语言】---模拟实现通讯录

    千次阅读 多人点赞 2019-10-28 23:38:56
    2.使用静态数组来对通讯录经行增删查改的系列操作。 实现的功能: 1.添加通讯录成员(add) 2.删除通讯录成员(del) 3.查找通讯录成员(search) 4.修改通讯录成员信息(modify) 5.显示通讯录成员信息(show) 6.清空所有...
  • 栈的实现 两种方法实现: ...基于顺序表的栈,也就是用数组的增删查改 我们看结构体和声明 typedef char SeqType; typedef struct SeqStack{ size_t size; SeqType data[MAXREPOSITORY]; }SeqStack; ...
  • 涉及到的:指针申请内存 结构体数据...设计:学生信息 学号 名字 年龄 成绩(结构体)1、数据 用数组存放学生信息 顺序表(数组+size+len实现) 链表(结构体指针实现)2、增删查改3、菜单 +提示 +界面 注册 -->...
  • 1.能够进行增删查改操作 2.能够将诗歌写入文件 3.用结构体和指针等相关知识实现 4.打印和查找诗歌 5.要有显示界面 6.用户输入信息须有相应的提示信息 模块设计 //向结构体数组中添加一个诗歌 void Add(Poem arr[],...
  • 数据操作有:创建链表,销毁链表,增删查改,求长 链表的计数还是从0开始,head节点影藏,不计入长度,下面这种图帮助理解 将head对用户不可见 I的值可取0至size 此中的size=5; j=0;i=3 操作插入一个
  • 至此,简单的增删查改功能全部实现。 代码没有用到链表(主要是刚学,还不熟QAQ),用的是结构体数组,下面直接给出实现功能的函数代码,纯手打: 首先四个函数声明: int add(FILE *fp,struct message me[20]); void...
  • 学生成绩管理系统需要维护一组学生成绩信息,实现增删查改统计排序以及读取保存,使用结构体数组。 文件的读写需要用到c语言的文件操作函数。 显示学生成绩信息功能分为三个小功能:根据目生成绩信息数量遍历学生...
  • 1、栈和队列 操作 增查改删重点 插入删除先进先出 -->队列先进后出 -->栈2、链表 写之前先画图存储数据的方式 通过指针将所有的数据链在一起数据结构的目的 管理存储数据 方便快速查找使用 链表定义 链式存储...

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

c语言结构体增删查改

c语言 订阅