链表基础内容

#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 **********/
}

小结：

1. 插入和删除，先用p、q定位，再判断是否是链首，链尾不考虑也行
2. 遍历用h，查删用h->next  双指针