概述
链表:通过一组任意的存储单元来存储线性表的数据,这组存储单元可以是连续或不连续的,
每个节点包括
- 数据域(当前节点的数值)
- 指针域(存储下一个节点的位置)
各个节点通过指针域串起来,像一条链子,所以叫“链表”。
单链表:每个节点只有一个指向直接后继节点的指针,所以叫“单链表”
实现过程
注:本文均为带头结点的单链表
单链表结构体:
#include <stdio.h>
#include <stdlib.h>
#define ARRMALLOCSIZE 5
#define FALSE 0
#define TRUE 1
typedef struct listNode
{
int data; //数据域
struct listNode *next; //指针域
}linkList;
头结点初始化:
void initLinkList(linkList *tempList)
{
tempList->next = NULL; //指针域制空
}
创建单链表有两种方法,头插法和尾插法,头插法的特点是:逆序存储的数据,而尾插法则是正序存储的
头插法创建单链表:
int headCreateLinkList(linkList *tempList)
{
int temp;
linkList *node;
node = (linkList *)malloc(sizeof(linkList));
//创建失败
if(!node)
return FALSE;
scanf("%d", &temp);
while(temp != -1)
{
node->data = temp;
node->next = tempList->next;
tempList->next = node;
node = (linkList *)malloc(sizeof(linkList));
//创建失败
if(!node)
return FALSE;
scanf("%d", &temp);
}
free(node);
return TRUE;
}
尾插法创建单链表:
int footCreateLinkList(linkList *tempList)
{
int temp;
linkList *node, *flag; //flag指针永远指向tempList尾部位置
flag = tempList;
node = (linkList *)malloc(sizeof(linkList));
//创建失败
if(!node)
return FALSE;
scanf("%d", &temp);
while(temp != -1)
{
node->data = temp;
node->next = flag->next;
flag->next = node;
flag = node;
node = (linkList *)malloc(sizeof(linkList));
//创建失败
if(!node)
return FALSE;
scanf("%d", &temp);
}
free(node);
return TRUE;
}
返回单前操作位置的前一个位置的指针:这样做可以省去好多代码,比如删除指定位置的数据,查找指定位置的数据,修改指定位置的数据
//返回dest-1位置开始的链表指针
linkList *searchLinkListDestBefore(linkList *tempList, int dest)
{
linkList * p = tempList;
int i = 0, linkListLength;
linkListLength = getLinkListLength(tempList);
//位置合法性判断
if(dest < 0 || dest > linkListLength)
return NULL;
for(i = 0; i < dest; i++)
p = p->next;
return p;
}
数据添加(指定位置):
//向链表的dest位置插入num
int insertLinkList(linkList *tempList, int dest, int num)
{
linkList *p, *node;
//调用上文说到的方法
p = searchLinkListDestBefore(tempList, dest-1); //现在p指向dest-1节点
if(!p) //dest-1位置不存在判断
return FALSE;
node = (linkList *)malloc(sizeof(linkList));
if(!node)
return FALSE;
node->data = num; //dest不存在或不存在不影响
node->next = p->next;
p->next = node;
return TRUE;
}
数据修改(指定位置):
//把链表dest位置的值改为num
int changeLinkList(linkList *tempList, int dest, int num)
{
linkList *p = searchLinkListDestBefore(tempList, dest-1); //现在p指向dest-1节点
if(!p || !p->next) //dest-1位置不存在判断
return FALSE;
p->next->data = num;
return TRUE;
}
数据删除(指定位置):
//删除链表中的第dest位置的值
int deleteLinkList(linkList *tempList, int dest)
{
linkList *p = searchLinkListDestBefore(tempList, dest-1); //现在p指向dest-1节点
if(!p || !p->next) //dest-1 或 dest位置不存在判断
return FALSE;
if(!p->next->next) //dest存在,但为最后一个节点
p->next = NULL;
else //dest存在,为中间节点
p->next = p->next->next;
return TRUE;
}
说到查找,有两种查找方式,一种是按值查找,一种是按位置查找,如果是按值查找的话,有一点我们应该注意,查到的位置有可能有多个,构建一个结构体,用来存储这多个位置
按值查找的结果(结构体):
typedef struct resultNode
{
int *arr; //该数组存储所有的结果
int length; //结果数组的长度
}resNode;
按值查找:
//[按值dest]查找,对应节点的位置存储在tempNode里--按值查找
int searchLinkListByValue(linkList *tempList, int num, resNode *tempNode)
{
linkList *p = tempList->next;
int j = 1;
tempNode->length = 0;
tempNode->arr = (int *)malloc(sizeof(int) * ARRMALLOCSIZE);
//创建失败
if(!tempNode->arr)
return FALSE;
//循环对链表进行遍历
while(p)
{
//空间不足开辟空间
if((!(tempNode->length % 5)) && tempNode->length != 0)
{
tempNode->arr = (int *)realloc(tempNode->arr, sizeof(int) * (tempNode->length + 1) * ARRMALLOCSIZE);
//创建失败
if(!tempNode->arr)
return FALSE;
}
if(p->data == num)
{
tempNode->arr[tempNode->length++] = j;
}
p = p->next;
j++;
}
return TRUE;
}
按位置查找:
//查找dest位置的值--按位置查找
int searchLinkListByIndex(linkList *tempList, int dest)
{
linkList *p = searchLinkListDestBefore(tempList, dest-1); //现在p指向dest-1节点
if(!p || !p->next) //dest-1 或 dest位置不存在判断
return FALSE;
return p->next->data;
}
获取单链表的表长:
//获取表长(记得包括表头)
int getLinkListLength(linkList *tempList)
{
int length = 0;
linkList *p = tempList;
while(p)
{
length ++;
p = p->next;
}
return length;
}
单链表输出:
//输出
void printfLinkList(linkList *tempList)
{
linkList *p = tempList->next;
while(p)
{
printf("%-4d", p->data);
p = p->next;
}
}
单链表是指针,结构体的一个很好的学习点,我做了个简单的实现上面一些列的功能的demo,需要学习的同学可以运行看看。
实例实现
示例图:
实例代码可以点击Demo查看
更多数据结构与算法实例代码查看(下载)地址:https://github.com/52UUD/Algorithm-Design