单向链表的设计实现

要素

1.结构体变量
2.指向结构体变量的指针

运算符

-> :指向运算符
eg:p->成员名 即 （*p).成员名

即三种形式等价：结构体变量.成员名 <=> (*p).成员名 <=> p->成员名

new delete运算符
（相对于C语言中的malloc free函数，new delete作为运算符执行效率更高）
动态分配撤销存储空间

格式：new 类型[初值]
delete 指针变量
delete [] 指针变量
eg：

new int;//开辟存放整数的内存空间，返回一个指向该内存空间的地址（即指针）
new int(100);//开辟存放一个整数的空间，并指定该整数的初值是100，返回指针
new char[10];//开辟一个存放字符数组的空间，返回首元素地址
new int[5][4];//开辟一个二维数组空间，返回首元素地址
float *p = new float（3.14159） //开辟存放单精度数的空间，指定初值，将返回的地址赋给p

结构图

分类

静态链表

简单静态链表举例

#include <iostream>
using namespace std;
struct student
{
	int num;
	float score;
	struct student* next;
};
int main()
{
	student a, b, c, * head, * p;
	a.num = 15203; a.score = 89.5;
	b.num = 15204; b.score = 99;
	c.num = 15205; c.score = 86;
	head = &a;
	a.next = &b;
	b.next = &c;
	c.next = NULL;
	p = head;
	cout << "学号\t" << "成绩" << endl;
	do
	{
		cout << p->num << "\t"<< p->score << endl;
		p = p->next;
	} while (p != NULL);
	return 0;
}

所有结点均在程序中定义，不是临时开辟，也不能用完后释放。

动态链表

各结点可以随时插入删除，结点并没有变量名
即操作无名结构体变量。
以student 结构体举例

typedef struct student
{
	int num;
	float score;
	struct student* next;
}Stu;

动态链表的建立

int n;//记录节点数
Stu * create(void)//建立链表 返回头指针
{
	Stu* p1, * p2, * head;
	n = 0;
	p1 = p2 = (Stu*)new int(LEN);
	cout << "input information:\n";
	head = NULL;
	cin >> p1->num >> p1->score;
	while (p1->num != 0)//以0 为输入终止标志
	{
		n++;
		if (n == 1) head = p1;
		else p2->next = p1;
		p2 = p1;
		p1 = (Stu*)new int(LEN);
		p1->next = p1;//p1后移，开辟新的空间
		cin >> p1->num >> p1->score;
	}
	p2->next = NULL;
	return head;
}

动态链表的插入

插入过程即指针的重新连接
默认链表是有序的

Stu* insert(Stu* head, Stu* stud)
{
	Stu* p0, *p1, *p2;
	p2 = head;
	p1 = head;
	p0 = stud;
	if (head == NULL) {
		head = p0; p0->next = NULL;
	}//插入空链表，将head指向插入的结点
	else
	{
		while (p1->num < p0->num && p1->next != NULL)
		{
			p2 = p1;//未到插入位置且未到链尾，p1指向下个结点
			p1 = p1->next;
		}
		if (p1->num >= p0->num)//找到位置
		{
			if (p1 == head)//p1不变，p0插在p1前面
			{
				head = p0;
				p0->next = p1;
			}
			else//p0插在p2和p1之间
			{
				p2->next = p0;
				p0->next = p1;
			}
		}
		else//p1指向链尾都没找到位置，则p0插在链尾
		{
			p1->next = p0;
			p0->next = NULL;
		}
	}
	return head;
}

动态链表的删除

跳过删除的结点 并 删除

Stu * del(Stu* head,int del_num)
{
    Stu *p1, *p2;
    p1 = head;
    p2 = p1->next;
     while (p1->num != del_num)//未到删除位置，p1指向下一结点
      {
	      p2 = p1;
	      p1 = p1->next;
      }
	 p2->next = p1->next;
     delete p1;
     return head;
}

动态链表的输出

void print(Stu* head)
{
	Stu* p;
	p = head;
	do
	{
		cout << p->num << p->score;
		p = p->next;
	} while (p != NULL);
}

主函数调用实现

int main()
{
	//函数声明
	Stu* del(Stu* head, int del_num);
	Stu* insert(Stu* head, Stu* stud);
	Stu* creat(void);
	void print(Stu* head);

	Stu* head, * stud;
	stud = (Stu*)new int(LEN);
	int del_num;
	head = creat();
	print(head);
	cout << "input the num to be delete:\n";
	cin >> del_num;
	head = del(head, del_num);
	print(head);
	cout << "input num to be inserted:\n";
	cin >> stud->num >> stud->score;
	print(head);
	return 0;
}