今天看啥
热点:

算法数据结构 单链表的实现+操作 以及和顺序表的对比


顺序表和单链表的优缺点对比:

顺序表的优点,无需为表示表中元素之间的逻辑关系而增加额外的存储空间;

可以快速的存取表中的任意位置的元素。

顺序表的缺点,插入后删除操作需要移动大量元素;

当线性表长度不稳定时,存储空间难确定,容易造成存储空间碎片。

 

对于单链表

链式存储即元素存储的内存单元可以是不连续,分散的。对于元素间如何来维护他们的关系(即逻辑结构,每个元素的前驱和后继。)

即用到一个指针域来存储他和前驱或是后继直接的关系。

如上面的是一个单链表的指针结构,即每个元素中存储了他的后继元素的内存空间地址。

\

应用场景选择

由上图可以简单的知道数据的常见的操作,增,删,改,查时。

对于数据操作偏向于查和改时,顺序存储的速度是非常快的,而链表的话,则必须从头节点开始遍历查找。

但是涉及到插入或是删除元素时,顺序存储每次操作为了维护顺序,必须移动元素,而对于链表来说,只需新增一个存储单元后,对其中几个指针域中指针的指向做下改变就行。

tips1. 但是我们要注意的是, 表的插入和删除操作其实有两部分组成:遍历找到第i个元素,然后删除或插入。那其实顺序表这步的时间复杂度为 O(1),

而单链表的时间复杂度为O(n),虽然后面的话顺序表需要将i后面的元素都往后移动一位,话费的时间相对来说就是O(n),而单链表无需移动元素,

时间就为O(1)。看上去其实貌似扯平啊,这样单链表相对于线性表的顺序存储结构来说没什么大的优势。但是如果在第i点插入k个元素时,

那么相对于链表来说只要第一遍历查找到了第i个元素后,之后的操作基本是是O(1),而顺序的操作的话,是每次都要移动n-i个元素,O(n),

效果就出来了。

tips2.而对于顺序表,如果我们的插入和删除操作,在不考虑存储空间额分配这个死角的话(即存储空间可以动态的申请,不考虑溢出),

都是在对最后的一个元素进行操作,那不是也很好,即删除和插入都是在表尾进行,那么就不用移动大量元素了。

 

 

代码实现:

 


#ifndef _LIST_H
#define _LIST_H

#include
#include//断言
#include
#include
#include


#include
using namespace std;

#define ElemType int

typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node, *PNode;

typedef PNode List;


/*-------------------------函数声明------------------------*/
void menu();//菜单
void InitList(List *list);//初始化函数
bool CreateList(List *list, int count);//创建函数
bool isEmpty(List *list);//判断空
bool push_front(List *list, ElemType x);//头插
int push_back(List *list, ElemType x);//尾插
bool pop_front(List *list);//头删
bool pop_back(List *list);//尾删
Node* find(List *list, ElemType x);//查询 返回输入序号的指针
int	LocatePos(List *list, ElemType x);//查询 获取输入序号的值
void Length(List *list);//长度
bool delete_pos(List *list, ElemType pos);//位置删除
bool delete_val(List *list, ElemType x);//值删
bool modify(List *list, int pos, ElemType x);//修改某位置的值域
bool DestroyList(List *list);//摧毁
void ShowList(List list);//显示
bool insert_pos(List *list, int pos, ElemType x);//位置插入
bool insert_val(List *list, ElemType x);//值 插入(有序前提)
bool sort(List *list);//排序
Node* resver(List *list);//逆置
void reverse_2(List *list);//逆置
Node* next(List *list, ElemType key);//返回输入位置的后继节点
Node* prio(List *list, ElemType key);//返回输入位置的前驱节点
Node* Pfind(List *list, size_t pos);//返回对应位置的指针



#endif





#include"List.h"



/*-----------------函数实现部分----------------------*/
void menu()
{
	cout << "								   " << endl;
	cout << "**********************************" << endl;
	cout << "* [100] CreateList               *" << endl;
	cout << "* [0] quit_system [1] push_back  *" << endl;
	cout << "* [2] push_front  [3] show_list  *" << endl;
	cout << "* [4] pop_back    [5] pop_front  *" << endl;
	cout << "* [6] insert_pos				 *" << endl;
	cout << "* [8] delete_pos  [9] delete_val *" << endl;
	cout << "* [10] find       [11] LocatePos *" << endl; 
	cout << "* [12] modify     [13] destroy   *" << endl;
	cout << "* [14] sort       [15] resver    *" << endl;
	cout << "* [16] length     [17] next      *" << endl;
	cout << "* [18] prio                      *" << endl;
	cout << "**********************************" << endl;
	cout << "plese chose:>";
}

/*-----------初始化单链表———————————————*/
void InitList(List *list)
{
	*list = (Node *)malloc(sizeof(Node));
	(*list)->next = NULL;
	(*list)->data = 0;
}

/*---------头节点的方式创建单链表---------------------*/
//???????
bool CreateList(List *list,int count) //Node * *list
{
	Node *p = *list;
	ElemType x = 0;
	for (int i = 1; i <= count; ++i)
	{
		cin >> x;
		p = p->next = (Node *)malloc(sizeof(Node));
		p->data = x;
		p->next = NULL;
		(*list)->data++;
	}
	return false;
}

/*----判断空--------*/
bool isEmpty(List *list)
{
	return (NULL == (*list)->next);
}


/*-----------------尾插————————————*/
int push_back(List *list, ElemType x)
{
	if (isEmpty(list))
		return 0;
	Node* cur = (*list)->next;
	while (cur->next != NULL)
	{
		cur = cur->next;
	}
	Node *p = (Node *)malloc(sizeof(Node));
	if (p == NULL)
		return 0;
	p->data = x;
	cur->next = p;
	p->next = NULL;

	(*list)->data++;
}

/*-----------------头插————————————*/
bool push_front(List *list, ElemType x)
{
	Node *p = (Node *)malloc(sizeof(Node));
	if (p == NULL)
		return false;
	p->data = x;
	p->next = (*list)->next;
	(*list)->next = p;

	(*list)->data++;
}


/*------显示--------------*/
void ShowList(List list)
{
	Node *p = list->next;
	while (p != NULL)
	{
		cout << p->data << "-->";
		p = p->next;
	}
	cout << "Nul" << endl;
}

/*-----------------尾删————————————*/
bool pop_back(List *list)
{
	if (isEmpty(list))
		return false;
	Node* cur = (*list);
	while (cur->next != NULL && cur->next->next != NULL)
	{
		cur = cur->next;
	}
	free(cur->next);
	cur->next = NULL;
	(*list)->data--;
	return true;
}



/*-----------------头删————————————*/
bool pop_front(List *list)
{
	if (isEmpty(list))
		return false;
	Node *p = (*list)->next;
	(*list)->next = p->next;
	free(p);
	p = NULL;
	(*list)->data--;
}


/*-------------------按位置插入--------------*/
bool insert_pos(List *list, int pos, ElemType x)
{
	Node *p = Pfind(list, pos - 1);//寻找第i-1个结点
	if (p == NULL)//i<1或i>n+1时插入位置i有错
	{
		cout << "ERROR POS" << endl;
	}
		Node* s = (Node *)malloc(sizeof(Node));
		s->data = x;
		s->next = p->next; 
		p->next = s;
	return false;
}


/*--------位置删除---------------*/
bool delete_pos(List *list, ElemType pos)
{
	int count = 1;
	Node* cur = NULL;
	Node* pre = *list;
	while (pre->next != NULL && pre->next->next != NULL && count < pos)//找到前驱
	{
		pre = pre->next;
		count++;
	}
	if (count != pos)
	{
		cout << "ERROE pos" << endl;
		return false;
	}
	cur = pre->next;
	pre->next = cur->next;
	free(cur);
	cur = NULL;
	(*list)->data--;
	return  true;
}


/*----------按值删除-------------*/
bool delete_val(List *list, ElemType x)
{

	Node* pre = *list;
	Node* cur = NULL;
	while (pre->next != NULL && pre->next->next != NULL)//找到前驱
	{
		if (x == pre->next->data)
		{
			cur = pre->next;
			pre->next = cur->next;
			free(cur);
			cur = NULL;
			return true;
		}
		pre = pre->next;
	}
	(*list)->data--;
	return true;
}

/*----------------查询 返回指针————————————*/
Node* find(List *list, ElemType x)
{
	Node *p = (*list)->next;
	while (p)
	{
		if (p->data != x)
			p = p->next;
		else
			break;
	}
	return p;
}

/*----------输入序号 返回指针——————*/
Node* Pfind(List *list, size_t pos)
{
	size_t count = 1;
	Node *p = (*list)->next;
	while (count < pos)
	{
		p = p->next;
		count++;
	}

	if (count != pos)
		return NULL;
	return p;	
}

/*-----------------查询 返回序号————————————*/
int	LocatePos(List *list, ElemType x)
{
	Node* cur = (*list)->next;
	int count = 0;
	while (cur)
	{
		count++;
		if (x == cur->data)
			return count;    //返回是第几个元素
		cur = cur->next;
	}
	return 0;
}


/*--------------修改---------------*/
bool modify(List *list,int pos, ElemType x)
{
	int count = 1;
	if (pos < 0 || pos >(*list)->data)
		return false;
	Node* cur = (*list)->next;
	while (cur != NULL && cur->next != NULL)
	{
		if (count == pos)
		{
			cur->data = x;
			return true;
		}
		cur = cur->next;
		count++;
	}
	return false;
}

/*-------销毁-------------*/
bool DestroyList(List *list)
{
	Node *p = (*list);
	Node *q = NULL;
	while (p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	(*list)->next = NULL;
	cout << "the List was destroyed !" << endl;
	cout << "After destroy ,any operation is invalid!" << endl;
	cout << "Please quit_system!" << endl;
	return true;
}

/*----------排序--------------*/
bool sort(List *list)
{
	if (isEmpty(list))
		return false;
	Node* p = NULL;
	Node* q = NULL;
	for (p = (*list)->next; p != NULL; p = p->next)
	{
		for (q = p->next; q != NULL; q = q->next)
		{
			if (p->data > q->data)
			{
				p->data = p->data   ^    q->data;
				q->data = p->data   ^    q->data;
				p->data = p->data   ^    q->data;
			}
		}
	}
	return true;
}


/*-------逆置-----------*/
Node* resver(List *list)
{
	Node *p = (*list)->next;
	Node *q = NULL;
	Node *r = NULL;

	while (p)
	{
		q = p->next;
		p->next = r;
		r = p;
		p = q;
	}
	
	return r;
}

void reverse_2(List *list)
{
	Node *p, *q;
	p = (*list)->next;    //P指向链表第一个元素  
	(*list)->next = NULL; //断开头结点与链表  
	while (p != NULL)
	{
		q = p;
		p = p->next;
		q->next = (*list)->next;  //相当于前插法构建新的链表,和原来的相反  
		(*list)->next = q;
	}
}


/*----------------返回长度————————————*/
void Length(List *list)
{
	cout << "the length of list is:>" << (*list)->data << endl;
}

/*-----------------返回后继————————————*/
Node* next(List *list, ElemType key)  //输入节点序号返回其后继节点
{
	Node* cur = (*list)->next;
	int count = 1;

	if (isEmpty(list) || key < 0 || key > (*list)->data)
		return false;

	while (count < key)
	{
		cur = cur->next;
		count++;
	}
	if (count == key)
	{
		cur = cur->next;
		return cur;
	}
	else
	{
		cout << "ERROE" << endl;
		return false;
	}
}


/*-----------------返回前驱————————————*/
Node* prio(List *list, ElemType key)
{
	Node* pre = (*list);
	Node* cur = (*list)->next;
	int count = 1;
	if (isEmpty(list) || key < 1 || key > (*list)->data)
		return false;
	while (count < key)
	{
		pre = pre->next;
		cur = cur->next;
		count++;
	}
	if (count == key)
	{
		return pre;
		
	}
	else
	{
		cout << "ERROE" << endl;
		return false;
	}
}


#include"List.h"

int main(void)
{

	List mylist;
	InitList( &mylist);
	
	ElemType item;
	int pos = 0;
	int select = 1;
	int length = 0;

	

	while (select)
	{
		menu();
		cin >> select;
		switch (select)
		{

		case 100:
			cout << "please input the length:>" ;
			cin >> length;
			cout << "please input the data:>" ;
			CreateList(&mylist, length);
			
			break;

		case 1:
			cout << "please enter data:>";
			cin >> item;
			push_back(&mylist, item);
			break;

		case 2:
			cout << "please enter data:>";
			cin >> item;
			push_front(&mylist, item);
			break;

		case 3:
			ShowList(mylist);
			break;

		case 4:
			pop_back(&mylist);
			break;

		case 5:
			pop_front(&mylist);
			break;

		case 6:
			cout << "please enter position:>";
			cin >> pos;
			cout << "please enter insert data:>";
			cin >> item;
			insert_pos(&mylist, pos, item);
			break;


		case 8:
			cout << "please enter position:>";
			cin >> pos;
			delete_pos(&mylist, pos);
			break;

		case 9:
			cout << "please enter delete data:>";
			cin >> item;
			delete_val(&mylist, item);
			break;

		case 10:
			cout << "please enter data:>";
			cin >> item;
			cout << "the piont of pos is:>" << find(&mylist, item) << endl;
			break;

		case 11:
			cout << "please enter data:>";
			cin >> item;
			cout << "the number of pos is>" << LocatePos(&mylist, item)<< endl;
			break;

		case 12:
			cout << "please enter position:>";
			cin >> pos;
			cout << "please enter the modify data:>";
			cin >> item;
			modify(&mylist, pos, item);
			break;


		case 13:
			DestroyList(&mylist);
			break;

		case 14:
			sort(&mylist);
			cout << "the changes of SeqList will be incremental ! " << endl;
			ShowList(mylist);
			break;

		case 15:
			(mylist)->next = resver(&mylist);
			cout << "the changes of List will be resver ! " << endl;
			ShowList(mylist);
			reverse_2(&mylist);
			cout << "the changes of List will be resver ! " << endl;
			ShowList(mylist);
			break;

		case 16:
			Length(&mylist);
			break;

		case 17:
			cout << "please enter position:>";
			cin >> pos;
			if (pos <= 0 || pos >= (mylist)->data)//保证输入位置正确
			{
				cout << "ERROR POS" << endl;
				break;
			}

			cout << "the NextPosData is:>" << next(&mylist, pos)->data;
			break;


		case 18:
			cout << "please enter position:>";
			cin >> pos;
			if (pos <= 1 || pos > (mylist)->data)//保证输入位置正确
			{
				cout << "ERROR POS" << endl;
				break;
			}

			cout << "the PrePosData is:>" << prio(&mylist, pos)->data;
			break;

		

		}

	}

	return 0;
}






 


www.bkjia.comtruehttp://www.bkjia.com/Javabc/991922.htmlTechArticle算法数据结构 单链表的实现+操作 以及和顺序表的对比 顺序表和单链表的优缺点对比: 顺序表的优点,无需为表示表中元素之间的逻辑关...

相关文章

相关搜索: 数据结构 算法 顺序

帮客评论

视觉看点