单链表

最新推荐文章于 2019-06-28 17:01:43 发布
最新推荐文章于 2019-06-28 17:01:43 发布
阅读量135 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 单链表 静态链表 循环链表 不带头节点的单链表 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42476945/article/details/86104738
版权

链表特点:1.插入和删除快(尾巴操作慢,尾巴插入可以增加尾指针使其变为O(1))
缺点:
1. 查找不方便
2. 数据密度小
3. 内存碎片

带头节点的单链表

#pragma once

//带头结点单链表：最后一个节点的next为NULL；带头结点操作简单

typedef struct Node
{
	int data;//存放数据
	struct Node *next;//存放下一个节点的地址
}Node,*List;//List == Node *

//typedef Node * List;//List == Node *

//初始化
void InitList(List plist);

//头插
void Insert_head(List plist,int val);

//尾插
void Insert_tail(List plist,int val);

//查找
Node *Search(List plist,int key);

//删除
bool DeleteVal(List plist,int key);

//获取数据节点总数,不包含头
int GetLength(List plist);

//判空
bool IsEmpty(List plist);

//清空
void Clear(List plist);

//摧毁
void Destroy(List plist);

//输出
void Show(List plist);

void Reverse(List plist);

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "list.h"



void InitList(List plist)
{
	assert(plist!=NULL);

	if(plist==NULL)
	{
		return;
	}

	plist->next=NULL;
}


void Insert_head(List plist,int val)
{
	Node *p=(Node *)malloc(sizeof(Node));
	p->data=val;
	p->next=plist->next;
	plist->next=p;

	//Node newnode={val,NULL};//1
	//newnode.next=plist->next;//3
	//plist->next=&newnode;//2
}


void Insert_tail(List plist,int val)
{
	Node *p;
	for(p=plist;p->next!=NULL;p=p->next);

	Node *q=(Node *)malloc(sizeof(Node));

	q->data=val;
	q->next=p->next;
	p->next=q;
}


Node *Search(List plist,int key)
{
	for(Node *p=plist->next;p!=NULL;p=p->next)
	{
		if(p->data==key)
		{
			return p;
		}
	}
	return NULL;
}


bool DeleteVal(List plist,int key)
{
	Node *p=Search(plist,key);
	if(p==NULL)
	{
		return false;
	}
	Node *q=p->next;
	p->next=q->next;
	free(q);

	return true;
}


int GetLength(List plist)
{
	int count=0;
	for(Node *p=plist->next;p!=NULL;p=p->next)
	{
		count++;
	}
	return count;
}


bool IsEmpty(List plist)
{
	if(plist->next==NULL)
	{
		return true;
	}
	return false;
}


void Clear(List plist)
{
	Destroy(plist);
}


void Destroy(List plist)
{
	assert(plist!=NULL);
	if(plist==NULL)
	{
		return;
	}
	Node *p;
	while(plist->next!=NULL)
	{
		p=plist->next;
		plist->next=p->next;

		free(p);
	}
	/*
	if(plist==NULL||plist->next==NULL)
	{
		return;
	}
	Node *p=plist->next;
	Node *q;
	plist->next=NULL;
	while(p!=NULL)
	{
		q=p->next;
		free(p);
		p=q;
	}
	*/
}


void Show(List plist)
{
	for(Node *p=plist->next;p!=NULL;p=p->next)
	{
		printf("%d  ",p->data);
	}
	printf("\n");
}


//考的最多

void Reverse(List plist)
{
	//if(plist==NULL||plist->next->next==NULL||plist->next==NULL)//err
	if(plist==NULL||plist->next==NULL||plist->next->next==NULL)
	{
		return ;
	}
	Node *p=plist->next;
	Node *q;

	plist->next=NULL;
	while(p!=NULL)
	{
		q=p->next;
		p->next=plist->next;
		plist->next=p;

		p=q;
	}
}

#include <stdio.h>
#include "list.h"

int main()
{
	Node head;
	InitList(&head);
	          
	//for(int i=0;i<20;i++)
	//{
		//Insert_head(&head,i);
	//}
	//Show(&head);
	 

	for(int i=0;i<20;i++)
	{
		Insert_tail(&head,i);
	}
	Show(&head);

	printf("%d\n",Search(&head,3));
	printf("%d\n",Search(&head,0));
	printf("%d\n",Search(&head,30));

	printf("%d\n",GetLength(&head));

	DeleteVal(&head,3);
	Show(&head);

	DeleteVal(&head,25);
	Show(&head);
    DeleteVal(&head,18);
	Show(&head);

	Reverse(&head);
	Show(&head);

	Destroy(&head);
	Show(&head);

	Clear(&head);
	Show(&head);

	return 0;
}

不带头结点的单链表

#pragma once
//不带头结点的单链表

typedef struct NNode
{
	int data;
	struct NNode *next;
}NNode,*NList;

void InitList(NList *pplist);

bool Insert_head(NList *pplist,int val);

bool Insert_tail(NList *pplist,int val);

bool Delete(NList *pplist,int key);

void Destroy(NList *pplist);

void Show(NList plist);

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>


//将带头节点的单链表改成不带头节点的单链表，并实现插入，删除，查找，求链表长度，
//打印等函数。
typedef struct NNode 
{
	int data;
	struct NNode *next;
}NNode,*NList;


//初始化
void InitList(NList *pplist)
{
	assert(pplist!=NULL);
	if(pplist==NULL)
	{
		return ;
	}
	*pplist=NULL;
}

//头插
void Insert_head(NList *pplist,int val)
{
	NNode *p=(NNode *)malloc(sizeof(NNode));
	p->data=val;
	p->next=*pplist;
	*pplist=p;
}

//尾插
bool Insert_tail(NList *pplist,int val)
{
	NNode *p=(NNode *)malloc(sizeof(NNode));
	p->data=val;
	p->next=NULL;
	if(*pplist==NULL)
	{
		*pplist=p;
		return true;
	}
	NNode *q;
	for(q=*pplist;q->next!=NULL;q=q->next);
	p->next=q->next;
	q->next=p;
	return true;
}

//查找
NNode *Search(NList plist,int key)
{
	NNode *p;
	for(p=plist->next;p!=NULL;p=p->next)
	{
		if(p->data==key)
		{
			return p;
		}
	}
	return NULL;
}

//删除
bool DeleteVal(NList *pplist,int key)
{
	if(*pplist==NULL)
	{
		return false;
	}
	NNode *p=*pplist;
	if(p->data==key)
	{
		*pplist=p->next;
		free(p);
		return true;
	}
	
	for(p=*pplist;p->next!=NULL;p=p->next) 
	{
		if(p->next->data==key)  
		{ 
			NNode *q=p->next;   
			p->next=q->next;  
			free(q);   
			return true; 
		} 
	}
	return false;
}

//获取数据节点总数,不包含头
int GetLength(NList plist)
{
	int count=0;
	for(NNode *p=plist->next;p!=NULL;p=p->next)
	{
		count++;
	}
	return count;
}

//判空
bool IsEmpty(NList plist)
{
	return plist==NULL;
}

void Clear(NList *pplist)
{
	Destroy(pplist);
}

void Destroy(NList *pplist)
{
	NNode *p;
	while(*pplist!=NULL)
	{
		p=*pplist;
		*pplist=p->next;
		free(p);
	}
	*pplist=NULL;
}

//输出
void Show(NList plist)
{
	for(NNode *p=plist->next;p!=NULL;p=p->next)
	{
		printf("%d  ",p->data);
	}
	printf("\n");
}


#include <stdio.h>
#include "nlist.h"

int main()
{
	NList head;
	InitList(&head);
	
	
	for(int i=0;i<20;i++)
	{
		Insert_head(&head,i);
	}
	Show(head);
	

	for(int i=0;i<20;i++)
	{
		Insert_tail(&head,i);
	}
	Show(head);

	printf("%d\n",Search(head,3));
	printf("%d\n",Search(head,25));

	DeleteVal(&head,3);
	DeleteVal(&head,12);
	DeleteVal(&head,-2);
	Show(head);

	Destroy(&head);
	Show(head);

	return 0;
}

带头结点的双向链表

#pragma once
//带头结点的双向链表,不循环

typedef struct DNode
{
	int data;
	struct DNode *prio;//前驱指针
	struct DNode *next;//后继指针
}DNode,*DList;

//初始化
void InitList(DList plist);

//头插
void Insert_head(DList plist,int val);

//尾插
void Insert_tail(DList plist,int val);

//查找
DNode *Search(DList plist,int key);

//删除
bool DeleteVal(DList plist,int key);

//获取数据节点总数,不包含头
int GetLength(DList plist);

//判空
bool IsEmpty(DList plist);

//清空
void Clear(DList plist);

//摧毁
void Destroy(DList plist);

//输出
void Show(DList plist);


#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "dlist.h"

//初始化
void InitList(DList plist)
{
	assert(plist!=NULL);
	if(plist==NULL)
	{
		return ;
	}
	plist->next=NULL;
	plist->prio=NULL;

}

//头插
void Insert_head(DList plist,int val)
{
	DNode *p=(DNode *)malloc(sizeof(DNode));
	p->data=val;

	p->next=plist->next;
	plist->next=p;
	p->prio=plist;
	if(p->next!=NULL)
	{
		p->next->prio=p;
	}
}

//尾插
void Insert_tail(DList plist,int val)
{
	DNode *p;
	for(p=plist;p->next!=NULL;p=p->next);

	DNode *q=(DNode *)malloc(sizeof(DNode));
	q->data=val;
	q->next=p->next;
	p->next=q;
	q->prio=p;
	if(q->next!=NULL)
	{
    	q->next->prio=q;
	}
}

//查找
DNode *Search(DList plist,int key)
{
	for(DNode *p=plist->next;p!=NULL;p=p->next)
	{
		if(p->data==key)
		{
			return p;
		}
	}
	return NULL;
}

//删除
bool DeleteVal(DList plist,int key)
{
	DNode *p=Search(plist,key);
	if(p==NULL)
	{
		return false;
	}
	p->prio->next=p->next;
	if(p->next!=NULL)
	{
		p->next->prio=p->prio;
	}
	free(p);
	return true;
}

//获取数据节点总数,不包含头
int GetLength(DList plist)
{
	int count=0;
	DNode *p;
	for(p=plist->next;p!=NULL;p=p->next)
	{
		count++;
	}
	return count;
}
//判空
bool IsEmpty(DList plist)
{
	return plist->next==NULL;
}

//清空
void Clear(DList plist)
{
	Destroy(plist);
}

//摧毁
void Destroy(DList plist)
{
	DNode *p;
	while(plist->next!=NULL)
	{
		p=plist->next;
		plist->next=p->next;

		free(p);
	}
}

//输出
void Show(DList plist)
{
	DNode *p;
	for(p=plist->next;p!=NULL;p=p->next)
	{
		printf("%d  ",p->data);
	}
	printf("\n");
}

#include <stdio.h>
#include "dlist.h"

int main()
{
	DNode head;
	InitList(&head);
	
	
	for(int i=0;i<20;i++)
	{
		Insert_head(&head,i);
	}
	Show(&head);
	
	for(int i=0;i<20;i++)
	{
		Insert_tail(&head,i);
	}
	Show(&head);

    printf("%d\n",Search(&head,5));
    printf("%d\n",Search(&head,-1));
    printf("%d\n",Search(&head,25));


	DeleteVal(&head,3);
	Show(&head);

	printf("%d\n",GetLength(&head));


	return 0;
}

带头结点的循环链表

#pragma once

//带头结点的循环链表:尾节点的next指向头结点
typedef struct CNode
{
	int data;
	struct CNode *next;
}CNode,*CList;


//初始化
void InitList(CList plist);


//头插
void Insert_head(CList plist,int val);

//尾插
void Insert_tail(CList plist,int val);

//查找
CNode *Search(CList plist,int key);

//删除
bool DeleteVal(CList plist,int key);

//获取数据节点总数,不包含头
int GetLength(CList plist);

//判空
bool IsEmpty(CList plist);

//清空
void Clear(CList plist);

//摧毁
void Destroy(CList plist);

//输出
void Show(CList plist);

//逆置，******年年考
void Reverse(CList plist);


#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "clist.h"

//初始化
void InitList(CList plist)
{
	assert(plist!=NULL);
	if(plist==NULL)
	{
		return ;
	}
	plist->next=plist;
}

//头插
void Insert_head(CList plist,int val)
{
	CNode *p=(CNode *)malloc(sizeof(CNode));

	p->data=val;
	p->next=plist->next;
	plist->next=p;
}

//尾插
void Insert_tail(CList plist,int val)
{
	CNode *p;
	for(p=plist;p->next!=plist;p=p->next);
	CNode *q=(CNode *)malloc(sizeof(CNode));
	q->data=val;

	q->next=p->next;//q->next=plist
	p->next=q;
}

//查找
CNode *Search(CList plist,int key)
{
	CNode *p;
	for(p=plist->next;p!=plist;p=p->next)
	{
		if(p->data==key)
		{
			return p;
		}
	}
	return NULL;
}

//删除
bool DeleteVal(CList plist,int key)
{
	CNode *p=Search(plist,key);
	CNode *q;
	if(p==NULL)
	{
		return false;
	}
	if(p->next!=plist)
	{
		q=p->next;
		p->data=q->data;
		p->next=q->next;
		free(q);
	}
	else
	{
		for(p=plist;p->next!=plist;p=p->next)
		{
			if(p->next->data==key)
			{
				break;
			}
		}
		q=p->next;
		p->next=q->next;
		free(q);
	}
	return true;
}

//获取数据节点总数,不包含头
int GetLength(CList plist)
{
	int count=0;
	CNode *p;
	for(p=plist->next;p!=plist;p=p->next)
	{
		count++;
	}
	return count;
}

//判空
bool IsEmpty(CList plist)
{
	if(plist->next==plist)
	{
		return true;
	}
	return false;
	//return GetLength(plist)==0;
}

//清空
void Clear(CList plist)
{
	Destroy(plist);
}

//摧毁
void Destroy(CList plist)
{
	CNode *p;
	while(plist->next!=plist)
	{
		p=plist->next;
		plist->next=p->next;
		free(p);
	}
}


//输出
void Show(CList plist)
{
	for(CNode *p=plist->next;p!=plist;p=p->next)
	{
		printf("%d  ",p->data);
	}
	printf("\n");
}

#include <stdio.h>
#include "clist.h"

int main()
{
	CNode head;
	InitList(&head);
	
	for(int i=0;i<20;i++)
	{
		Insert_head(&head,i);
	}
	Show(&head);
	
	for(int i=0;i<20;i++)
	{
		Insert_tail(&head,i);
	}
	Show(&head);

	printf("%d\n",Search(&head,3));
	printf("%d\n",Search(&head,0));
	printf("%d\n",Search(&head,11));

	DeleteVal(&head,3);
	Show(&head);
	DeleteVal(&head,8);
	Show(&head);
	DeleteVal(&head,20);
	Show(&head);

	printf("%d\n",GetLength(&head));
	printf("%d\n",IsEmpty(&head));


	return 0;
}

静态链表

#pragma once

//静态链表：利用顺序表模拟链表
//有两条链，一条有效数据链，一条空闲链
//有效数据链：带头节点的循环链表，维护有效数据节点，0下标作为链表头
//空链表：带头节点的循环链表，维护空闲节点信息，1下标作为链表头


#define SIZE 10

typedef struct SNode
{
	int data;
	int next;
}SNode,SLinkList[SIZE],*PList;

//typedef SNode SLinkList[SIZE];

void InitList(PList plist);

//头插
bool Insert_head(PList plist,int val);

//尾插
bool Insert_tail(PList plist,int val);

//删除
bool Delete(PList plist,int key);

void Destroy(PList plist);

void Clear(PList plist);

bool IsEmpty(PList plist);

void Show(PList plist);

#include <stdio.h>
#include <assert.h>
#include "slist.h"


void InitList(PList plist)
{
	assert(plist!=NULL);

	plist[0].next=0;
	for(int i=1;i<SIZE;i++)
	{
		plist[i].next=i+1;
	}
	plist[SIZE-1].next=1;
}

//空闲链为空则满
static bool IsFull(PList plist)
{
	return plist[1].next==1;
}

//头插
bool Insert_head(PList plist,int val)
{
	if(IsFull(plist))
	{
		return false;
	}

	int p=plist[1].next;
	plist[1].next=plist[p].next;

	plist[p].data=val;
	plist[p].next=plist[0].next;
	plist[0].next=p;

	return true;
}

//尾插
bool Insert_tail(PList plist,int val)
{
	if(IsFull(plist))
	{
		return false;
	}
	int p=plist[1].next;
	plist[1].next=plist[p].next;

	plist[p].data=val;

	int q;
	for(q=0;plist[q].next!=0;q=plist[q].next);

	plist[p].next=plist[q].next;
	plist[q].next=p;

	return true;
}

static int SeachPri(PList plist,int key)
{
	for(int p=0;plist[p].next!=0;p=plist[p].next)
	{
		if(plist[plist[p].next].data==key)
		{
			return p;
		}
	}
	return -1;
}
//删除
bool Delete(PList plist,int key)
{
	int p=SeachPri(plist,key);
	if(p==-1)
	{
		return false;
	}

	int q=plist[p].next;
	plist[p].next=plist[q].next;

	plist[q].next=plist[1].next;
	plist[1].next=q;

	return true;
}

void Destroy(PList plist)
{
	plist[0].next=0;
}

void Clear(PList plist)
{
	Destroy(plist);
}

bool IsEmpty(PList plist)
{
	return plist[0].next==0;
}

void Show(PList plist)
{
	for(int p=plist[0].next;p!=0;p=plist[p].next)
	{
		printf("%d ",plist[p].data);
	}
	printf("\n");
}

#include <stdio.h>
#include "plist.h"

int main()
{
	PNode head;
	InitPoly(&head);
	Insert(&head,2,3);
	Insert(&head,2,1);
	Insert(&head,5,5);
	Insert(&head,4,4);
	Insert(&head,5,3);
	Show(&head);

	PNode head1;
	InitPoly(&head1);
	Insert(&head1,3,2);
	Insert(&head1,1,3);
	Insert(&head1,4,1);
	Insert(&head1,7,4);
	Insert(&head1,5,2);
	Show(&head1);

	Add(&head,&head1);
	Show(&head);

	Sub(&head,&head1);
	Show(&head);

	Destroy(&head);
	Show(&head);

	return 0;
}

利用带头结点的单链表来描述一元多项式

#pragma once
//利用带头结点的单链表来描述一元多项式

typedef struct PNode
{
	double cofe;//系数
	int expn;//指数
	struct PNode *next;
}PNode,*PList;

void InitPoly(PList pl);

//多项式指数从小到大有序
bool Insert(PList pl,double cofe,int expn);

void Destroy(PList pl);

void Show(PList pl);

//pA+=pB
void Add(PList pA,PList pB);

//pA -= pB
void Sub(PList pA,PList pB);

//pA *= pB
void Multi(PList pA,PList pB);


#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "plist.h"



void InitPoly(PList pl)
{
	assert(pl!=NULL);
	if(pl==NULL)
	{
		return ;
	}
	pl->next=NULL;
}

//查找指数expn的前驱
static PNode *SearchPri(PList pl,int expn)
{
	PNode *p;
	for(p=pl;p->next!=NULL;p=p->next)
	{                                       
		if(p->next->expn>=expn)
		{
			break;
		}
	}
	return p;
}

//多项式指数从小到大有序
bool Insert(PList pl,double cofe,int expn)
{
#define EPS 0.0000001
	PNode *p=SearchPri(pl,expn);
	
	if(p->next!=NULL&&p->next->expn==expn)
	{
		PNode *q=p->next;
		q->cofe+=cofe;
		if(-EPS<=q->cofe&&q->cofe<=EPS)
		{
			p->next=q->next;
			free(q);
		}
	}
	else
	{
		PNode *q=(PNode *)malloc(sizeof(PNode));
		q->cofe=cofe;
		q->expn=expn;
		q->next=p->next;
		p->next=q;
	}
	return true;
}

void Destroy(PList pl)
{
	assert(pl!=NULL);
	if(pl==NULL)
	{
		return;
	}
	PNode *p;
	while(pl->next!=NULL)
	{
		p=pl->next;
		pl->next=p->next;
		free(p);
	}
}

void Show(PList pl)
{
	for(PNode *p=pl->next;p!=NULL;p=p->next)
	{
		printf("%fx^%d+",p->cofe,p->expn);
	}
	printf("\n");
}

//pA+=pB
void Add(PList pA,PList pB)
{
	PNode *q;
	for(q=pB->next;q!=NULL;q=q->next)
	{
		Insert(pA,q->cofe,q->expn);
	}
}

//pA -= pB
void Sub(PList pA,PList pB)
{
	PNode *q;
	for(q=pB->next;q!=NULL;q=q->next)
	{
		Insert(pA,-(q->cofe),q->expn);
	}
}

//pA *= pB
void Multi(PList pA,PList pB);



#include <stdio.h>
#include "slist.h"

int main()
{
	SLinkList s;
	InitList(s);

	//for(int i=0;i<10;i++)
	//{
	//	Insert_head(s,i);
	//}
	//Show(s);

	for(int i=0;i<10;i++)
	{
		Insert_tail(s,i);
	}
	Show(s);

	Delete(s,2);
	Show(s);

	Delete(s,-1);
	Show(s);

	printf("%d\n",IsEmpty(s));

	Destroy(s);
	Show(s);

	return 0;
}
asdfghjklcgu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 链表
subsecurity的专栏
03-18 306
//Data Class to put into the linked list //Any class in this linked list must support two method: //Show(thevalue) //and //Compare(return relative position) class Data { public: Data(int val):myValue(val) { } ~Data() { } int Compar
C/C++笔试题（编程题）
weixin_33842328的博客
02-25 1476
面试过程中遇到的编程题整理，于此备录。分享，共勉。（持续更新中......欢迎补充） （1）用户输入M, N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序。 程序代码如下： 1 #include &lt;stdio.h&gt; 2 #include &lt;stdlib.h&gt; 3 4 // 节点结构定义 5 typedef ...
编程实现链表的基本操作函数。
mo_chen1025的博客
05-14 1863
编程实现链表的基本操作函数。 (1). void CreatList(LinkList &La,int m) //依次输入 m 个数据，并依次建立各个元素结点，逐个插入到链表尾；建立带表头结点的单链表 La； (2). void ListPrint(LinkList La) //将单链表 La 的数据元素从表头到表尾依次显示。 (3).void ListInsert (LinkList &...
带头结点与不带头结点的单链表-LinkList
知行合一，止于至善
05-04 6278
1.辅助文件包Assistance.h#ifndef __ASSISTANCE_H__ // 如果没有定义__ASSISTANCE_H__ #define __ASSISTANCE_H__ // 那么定义__ASSISTANCE_H__// 辅助软件包// ANSI C++标准库头文件 #include <cstring>
单向链表的基本操作以及常见面试题分析
A__B__C__的博客
08-04 458
目录： 一、单链表的基本操作 1、初始化链表 2、尾部插入 3、尾部删除 4、头部插入 5、头部删除 6、销毁链表 7.打印单链表内容 8、查询数据为d的节点 9、在指定位置之前插入一个节点 10、指定位置节点删除 11、删除数据为d，第一次出现的节点 12、删除数据为d的所有节点 二，链表常见面试题 1、...
单链表代码
02-01
单链表是一种基础的数据结构，它在计算机科学和编程中有着广泛的应用。在这个"单链表代码"压缩包中，我们可以找到用C语言实现的单链表操作的示例代码，这些代码通常会涵盖单链表的基本操作，如创建、插入、删除节点...
单链表逆序
03-04
单链表逆序是数据结构领域中的一个常见操作，它涉及到对链表节点顺序的反转。在本场景中，我们将详细探讨如何实现这个过程，包括单链表的基本概念、逆序算法的步骤以及如何在实际编程中应用这些概念。 首先，我们...
单链表的实现
04-21
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色。单链表由一系列节点组成，每个节点包含两部分：数据元素和一个指向下一个节点的指针。这种数据结构允许快速的插入和删除操作，但随机访问的效率较低...
数据结构实验代码
圣三一
10-21 3978
抽象数据类型的表示与实现 一、实验目的及要求 （1）了解非数值问题的数学模型不是数学方程，而是表、树和图之类的数据结构。 （2）理解数据、数据元素、数据对象、数据结构和数据类型等的定义。掌握数据的逻辑结构和存储结构及其种类；算法的重要特征等。 （3）熟悉类C语言的书写规范，特别注意参数的区别，输入输出的方式和错误处理方式，以及抽象数据类型的表示和实现。 （4）会根据语句频度估算算法的时间复杂度。 ...
简单说一说数据结构——链表
Jour的博客
02-20 2862
数组是一种非常简单的存储数据序列的数据结构。平时开发中，要存储多个元素，数组是最常用的数据结构。但是，在大多数语言中，数组的大小是固定的。从数组的起点或中间插入或移除项的成本非常高，因为需要频繁地移动元素。链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每一个元素由一个存储元素本身的节点和一个指向下一个元素的引用（称为指针或链接）组成。相对于数组，链表添加或者移除元素的时
C++实现带头节点的单链表
123456789的博客
03-18 1097
用友元函数 友元函数会破坏封装性，C++能不用就尽量不用 #include &lt;iostream&gt; class CLink; class Node { public: Node(int val) { mdata=val; pnext=NULL; } //不用写析构函数 因为头结点是在栈上开辟的 //不需要手动去释放 所以不写析构函数 private: int md...
手写单链表-并实现单链表元素逆置
子盛
11-06 1321
数组作为数据存储有一定的缺陷，在无序数组中，搜索是低效的；在有序数组中，插入效率低，不管在哪一种数组中，删除效率都很低，数组创建后它的大小是不可改变的。 链表：在内存中不是连续的，添加删除效率高，不支持高效随机访问
遍历
123456789的博客
04-02 1664
给如图所示的二叉树进行先序遍历，中序遍历，后序遍历 先序遍历 先访问根，再访问左，再访问右 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct BINARYNODE { char ch; struct BINARYNODE* lchild; struct B...
递归
123456789的博客
06-28 949
递归： （1）直接或间接的调用自身的算法 （2）使用函数自身给出的定义 1. 阶乘 循环实现阶乘 时间复杂度：O(n) 空间复杂度：S(1) int fun(int n) { int sum = 1; for(int i = 1; i <= n; ++i) { sum = sum * i; if(sum < 0) return -1; } return sum; ...
二叉树
123456789的博客
04-05 544
二叉树特点     每个结点最多只有两棵子树（不存在度大于2的结点）     左子树和右子树次序不能颠倒（有序树）。     节点分左右子树 二叉树性质 1、 在二叉树的第i层上至多有2(i-1)个结点（i>0） 2、 深度为k的二叉树至多有2k-1个结点（k>0） ...
中缀表达式变成后缀表达式
123456789的博客
01-11 402
中缀表达式变成后缀表达式 3+42/(5-4+1) 1、加括号 （ 3+（（42）/ (（5-4）+1) ）） 2、把符号放在括号外面 （ 3 （（4 2）* (（5 4）- 1) +）/）+ 3、除去括号 3 4 2 * 5 4 - 1 +/+ 转换过程需要用到栈，具体过程如下： 1）如果遇到操作数，我们就直接将其输出。 2）如果遇到操作符，则我们将其放...
二路归并排序
123456789的博客
01-11 362
算法描述 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 重复步骤3直到某一指针超出序列尾 将另一序列剩下的所有元素直接复制到合并序列尾 算法排序 时间复杂度 时间复杂度O(nlogn) 空间复杂度O(n) 稳定 算...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值