数据结构之链表

 

算法：
狭义：算法是与数据的存数方式密切相关的

 

广义： 算法是与数据的存储方式无关  

            泛型：利用某种技术达到的效果是：不同的存数方式，执行的操作是一样的

 

数据结构：

 

狭义：数据结构是专门研究数据存储的问题
           数据的存储包含两个方面：个体的存储+个体关系的存储
广义：数据结构既包含数据的存储也包含数据的操作

 

           对存储数据的操作就是算法

 

数据的存储结构有：
    线性：
         连续存储【数组】
  优点：存取速度快
缺点：事先必须知道数组的长度
           需要大块连续的内存块
           插入删除元素很慢
           空间通常是有限制
         离散存储【链表】
                        优点：空间没有限制
                                   插入删除元素很快
缺点：存取速度慢（因为要找某个元素要一个一个遍历）
    线性结构的应用--栈和队列
    非线性:
                树

 

                图

 

 

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct Node
{
	int data;  //数据域
	struct Node * pNext; //指针域
}NODE,*PNODE; //NODE等价于struct Node, PNODE等价于struct Node *2
//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE);
bool insert_list(PNODE,int,int);//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值是从1开始
bool delete_list(PNODE,int,int*);
void sort_list(PNODE);
void main()
{	
	int val;
	PNODE pHead=NULL;//等价于struct Node * pHead=NULL
	pHead=create_list();//create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址赋给pHead
	traverse_list(pHead);
	if(is_empty(pHead))
		printf("链表为空!\n");
	else
		printf("链表不空!\n");
	
	int len=length_list(pHead);
	printf("链表长度是%d\n",len);
	sort_list(pHead);
	traverse_list(pHead);
	
	insert_list(pHead,4,33);
	traverse_list(pHead);
	
	if(delete_list(pHead,4,&val))
	{
		printf("删除成功,您删除的元素是:%d\n ",val);	
	}
	else
	{
		printf("删除失败!您删除的元素不存在!\n");
	}
	traverse_list(pHead);
}

PNODE create_list(void)
{
	int len;//用来存放有效节点的个数
	int i;
	int val;//用来临时存放用户输入的节点的值
	
	//分配了一个不存放有效数据的头结点
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;
	printf("请输入您需要生成的链表节点的个数: len=");
	scanf("%d",&len);
	
	for(i=0;i<len;i++)
	{
		printf("请输入第%d个节点的值:",i+1);
		scanf("%d",&val);
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			printf("分配失败，程序终止!\n");
			exit(-1);
		}
		pNew->data=val;
		pTail->pNext =pNew;
		pNew->pNext=NULL;
		pTail=pNew;		
	}
	return pHead;
}
void traverse_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	while(NULL!=p)
	{
		printf("%d ",p->data);
		p=p->pNext; 
	}
	printf("\n");
	return;
}
bool is_empty(PNODE pHead)
{
	if(NULL==pHead->pNext)
		return true;
	else
		return false;
}
int length_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	int len=0;
	while(NULL!=p)
	{
		len++;
		p=p->pNext;
	}	
	return len;
}
void sort_list(PNODE pHead)
{
	int i,j,t;
	int len=length_list(pHead);
	PNODE p,q;
	for(i=0,p=pHead->pNext;i<len-1;++i,p=p->pNext)
	{
		for(j=i+1,q=p->pNext;j<len;++j,q=q->pNext)
		{
			if(p->data > q->data)//类似于数组中的:a[i]>a[j];
			{
				t=p->data;//类似于数组中的:t=a[i];
				p->data=q->data; //类似于数组中的:a[i]>a[j];
				q->data=t;//类似于数组中的:a[j]=t;
			}
		}		
	}
	return;
}
//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值是从1开始
bool insert_list(PNODE pHead,int pos,int val)
{
	int i=0;
	PNODE p=pHead;
	while(NULL!=p&&i<pos-1)
	{
		p=p->pNext;
		i++;
	}
	if(i>pos-1||NULL==p)
		return false;
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		printf("动态分配内存失败!\n");
		exit(-1);
	}
	pNew->data=val;
	PNODE q=p->pNext;
	p->pNext=pNew;
	pNew->pNext=q;
	return true;
}
bool delete_list(PNODE pHead,int pos,int* pVal)
{
	int i=0;
	PNODE p=pHead;
	while(NULL!=p->pNext && i<pos-1)
	{
		p=p->pNext;
		i++;
	}
	if(i>pos-1||NULL==p->pNext)
		return false;
	PNODE q=p->pNext;
	*pVal=q->data;
	//删除p后节点面的节点
	p->pNext=p->pNext->pNext;
	free(q);
	q=NULL;
	return true;
}