#include <iostream>
using namespace std;
struct Linked
{
/********* Begin *********/
//结构体的成员变量
int number;
float score;
Linked *next;
/********* End *********/
};
Linked* Create()
{
/********* Begin *********/
//创建并返回一个新链表
Linked *head = new Linked;
head->next = NULL;
return head;
/********* End *********/
}
void InsertAfter(Linked *node, int num, float sc)
{
/********* Begin *********/
//在指定节点后插入一个新节点,内容由 num,sc 参数指定
Linked * a = new Linked;
a->number = num;
a->score = sc;
if (!node->next)
a->next = NULL;
else
a->next = node->next->next;
node->next = a;
/********* End *********/
}
void DeleteAfter(Linked *node)
{
/********* Begin *********/
//删除此节点之后的一个节点
if (!node->next) return;
node->next = node->next->next;
/********* End *********/
}
Linked* GetByIndex(Linked *head, int index)
{
/********* Begin *********/
//返回指定索引处的节点,返回0是指头指针后的那个指针
Linked *a = new Linked;
a = head->next;
while (index)
{
a = a->next;
index--;
}
return a;
delete a;//好像没用了,函数自动delete?
/********* End *********/
}
void PrintAll(Linked *head)
{
/********* Begin *********/
//按格式打印此链表中所有节点的成员变量
Linked *a = new Linked;
a = head->next;
while (a)//遍历all
{
cout << a->number << " " << a->score << endl;
a = a->next;
}
delete a;
/********* End *********/
}
#include "linearList.h"
//函数delList:删除链表,释放空间
//参数:h-链表头指针
void delList(node *h)
{
node *p=h; //指针p指向头结点,第一个要删除的结点
while(p) //这个结点是存在的
{
h = h->next; //头指针h指向下一个结点(下一个结点的地址存在当前结点的指针域中,即h->next中
delete p; //删除p指向的结点
p = h; //p指向当前的头结点,即下一个要删除的结点
}
}
//函数printList:输出链表,每个数据之间用一个空格隔开
//参数:h-链表头指针
void printList(node *h)
{
cout<<"List:";
while(h)
{//h为真,即h指向的结点存在,则输出该结点的数据
cout<<" "<<h->data; //输出结点数据
h=h->next; //将该结点的指针域赋值给h,h就指向了下一个结点
}
cout<<endl; //输出换行符
}
//函数insertTail:链表尾部插入(分为空和非空,空直接返回,非空先找到尾指针、连接。再返回)
//参数:h-链表头指针,t-指向要插入的结点
//返回值:插入结点后链表的首结点地址
node *insertTail(node *h, node *t)
{
if(!h) //空链表单独处理
{
t->next=NULL; //链表尾指针置为NULL
return t; //返回第一个结点的地址(即链表头指针)
}
//非空链表的情况
node *p=h; //亦可以直接使用指针h
//让p指向最后一个结点
while(p->next)
p=p->next;
p->next = t; //让最后一个结点的指针域指向结点t
t->next=NULL; //链表尾指针置为NULL
return h; //返回第一个结点的地址(即链表头指针)
}
//函数insertHead:链表头部插入(无需考虑空否,插入方便)
//参数:h-链表头指针,t-指向要插入的结点
//返回值:插入结点后链表的首结点地址
node * insertHead(node *h, node *t)
{
t->next=h;
return t;
}
//函数insertSort:链表排序插入,根据数据信息来判断,该例是按照data的升序来的
//参数:h-链表头指针,t-指向要插入的结点
//返回值:插入结点后链表的首结点地址
node * insertSort(node *h, node *t)
{
node *p=NULL,*q=h; //定位第一个插入点:链首
while(q && q->data < t->data) //查找插入点
{//两个指针并行后移,移到需要插入的结点
p=q;
q=q->next;
}
if(p==NULL) //插入链首,亦包含了空链表的情况,所以插入链首和链尾的顺序不能颠倒
{
t->next = h;
return t;
}
/*if(q==NULL) //插入链尾,貌似可以直接与下个相并
{
p->next = t;
t->next = NULL;
return h;
}*/
//插入p、q之间
t->next=q;
p->next=t;
return h;
}
//函数search:在链表中查找包含数据num的结点
//参数:h-链表头指针,num-要查找的数据
//返回值:找到了返回该结点的地址,否则返回NULL
node * search(node * h, int num)
{
while(h)
{//h为真,即h指向的结点存在
if(h->data==num)
return h;
h=h->next; //将该结点的指针域赋值给h,h就指向了下一个结点
}
return NULL; //没找到包含num的结点
}
//函数delAt:删除链表中序号为i的结点,如果i是非法序号则不做操作
//参数:h-链表头指针,i-要删除结点的序号
//返回值:删除结束后链表首结点地址
node * delAt(node * h, int i)
{
if(i<0) //序号非法,不删除
return h;
node *p=NULL, *q = h; // 定位删除结点,试图让q指向要删除结点,p指向其前面的结点
for(int k=0;k<i;k++)
{
if(q->next==NULL) //后面没有结点了,序号非法
return h;
p=q;
q=q->next;
}
if(p) //p指向的结点存在,不是删除首结点
{
//删除q指向的结点,让p指向结点的指针域指向q的后续结点
p->next = q->next;
//释放空间
delete q;
return h;
}
else //删除首结点
{
h = q->next; //下一个结点成了首结点
//释放空间
delete q;
return h;
}
}
//函数delHas:删除链表中data为n的结点,如果有多个这样的结点,只删除第一个
//参数:h-链表头指针,n-结点包含的数据
//返回值:删除结束后链表首结点地址
node * delHas(node * h, int n)
{
node *p=NULL, *q=h; //p为要删除结点的前结点,q指向要删除结点
while(q)
{//h为真,即h指向的结点存在
if(q->data==n)
break; //找到了
if(q->next==NULL)//后面没有结点了,没有结点满足条件
return h; //不删除,直接返回
//继续往后找,两个指针一起后移
p=q;
q=q->next;
}
//删除q指向的结点
if(p==NULL)//删除头结点
{
h=q->next;//下一个结点变成头结点
delete q;//删除结点
return h;
}
//不是头结点
p->next=q->next;//把q指向结点的指针域(q后面结点的地址)赋值给p指向结点的指针域
return h;
}
//函数listLength:计算并返回链表的长度
//参数:h-链表头指针
//返回值:链表长度
int listLength(node * h)
{
int n=0;
while(h)
{
n++;
h=h->next;
}
return n;
}
//朴素想法
node * insertSort(node *h, node *t)
{
// 请在此添加代码,补全函数insertSort
/********** Begin *********/
if (!h) return t;//--------------------空链表
node *p, *q;
p = NULL;
q = h;
while (q->next != NULL)//--------------判断后继的情况
{
if (t->data < q->data)//--------------大前提
{
if (!p)//----------------------是否是首个
{
t->next = q;
return t;
}
else
{
p->next = t;
t->next = q;
}
return h;
}
else//-----------------------------指针后移
{
p = q;
q = q->next;
}
}
/*
if (!p && (t->data < q->data))//-------和上面思路相同,可以换一种写法
{
t->next = q;
return t;
}
if (t->data < q->data)
{
p->next = t;
t->next = q;
}
else
q->next = t;
*/
if (t->data < q->data)
{
if (!p)
{
t->next = q;
return t;
}
else
{
p->next = t;
t->next = q;
}
}
else
{
q->next = t;
}
return h;
}
#include "linearList.h"
//函数delAt:删除链表中序号为i的结点,如果i是非法序号则不做操作
//参数:h-链表头指针,i-要删除结点的序号
//返回值:删除结束后链表首结点地址
node * delAt(node * h, int i)
{
// 请在此添加代码,补全函数delAt
/********** Begin *********/
node *t = h;
if(i<0) //序号非法,不删除
return h;
if(i == 0)//删链首
{
h = h->next;
delete t;
return h;
}
for(int j = 1; j < i; j++)
{
if(!t) return h;//防止i大于链表的长度
t = t->next;
}//目前 ,t指向待删除的前一个,且目前只能保证t前面的都不为NULL
if(!t || !t->next) return h;//判断t和t->next空否
node *p = t->next;
t ->next = (t->next)->next;
delete p;
return h;
/********** End **********/
}
小结:
- 插入和删除,先用p、q定位,再判断是否是链首,链尾不考虑也行
- 遍历用h,查删用h->next 双指针