代码训练营第二期Day03

代码训练营第二期Day03

链表理论基础

什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

链接的入口节点称为链表的头结点也就是head。

如图所示：

单链表

双链表

单链表中的指针域只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

双链表 既可以向前查询也可以向后查询。

循环链表

循环链表，顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。

链表的存储

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

这个链表起始节点为2， 终止节点为7， 各个节点分布在内存的不同地址空间上，通过指针串联在一起。

链表的创建、删除、插入

//链表的定义
//单链表
struct ListNode{
	int val;//节点存储的元素值
	ListNode* next;//指向下一节点的指针
	ListNode(int x) :val(x), next(NULL) {};//节点的构造函数（初始化列表）
	//等价于：
	/*ListNode(int x) {
		val = x;
		next = NULL;
	}*/
	/*
	  如果没有自定义构造函数，C++默认生成一个 无参 的构造函数
	  如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！
	  使用自己定义的构造函数：
	  ListNode* head = new ListNode(5);
	  使用默认的构造函数：
	  ListNode* head = new ListNode();
	  head->val = 5;
	*/
};

class MyListNode {
public:
	//链表创建
	ListNode* CreateList() {
		cout << "Input ListNode" << endl;
		int InputNum = 1;
		ListNode* head, * nodetemp, * node;
		head = nullptr;		//C++11新标准，代码更健壮
		nodetemp = nullptr;
//提示：需要注意的是，此处使用while (cin>>Inputnum)作为循环判断条件，在函数最后必须清除cin缓冲区以继续后续输入。
		while (cin >> InputNum)
		{		
			node = new ListNode(InputNum); //创建一个新节点
			if (head == nullptr)//首次创建，头节点
			{
				head = node;
			}
			else//尾插法
			{
				nodetemp->next = node;
			}
			nodetemp = node;
			nodetemp->next = nullptr;
		}
		cin.clear();
		cin.ignore();
		return head;
	}
	//链表删除
	ListNode* DeleteNode(ListNode* head) {
		int locate;
		cout << "Input delete location: " << endl;
		cin >> locate;
		if (locate == 1)
		{
			head = head->next;
		}
		else
		{
			ListNode* temp;
			temp = head;
			//找到要删除节点的前一个节点
			for (int i = 1; i < locate-1; i++)
			{
				temp = temp->next;
			}
			temp->next = temp->next->next;
		}
		return head;
	}
	//插入节点
	ListNode* InsertNode(ListNode* head)
	{
		int locate, insertValue;
		cout << "Input insert location: " << endl;
		cin >> locate;
		cout << "Input insert node: " << endl;
		cin >> insertValue;
		ListNode* insertnode = new ListNode(insertValue);
		if (locate == 1)
		{
			//这两句顺序不能反
			insertnode->next = head;
			head = insertnode;
		}
		else
		{
			ListNode* temp;
			temp = head;
			//找到插入位置的前一节点
			for (int i = 1; i < locate-1; i++)
			{
				temp = temp->next;
			}
			if (temp == nullptr)
			{
				cout << "illegal location!" << endl;
				exit(0);
			}
			else if (temp->next == nullptr)
			{
				insertnode->next == nullptr;
				temp->next = insertnode;
			}
			else
			{
				//这两句顺序不能反
				insertnode->next = temp->next;
				temp->next = insertnode;
			}			
		}	

		return head;
	}
	//输出链表
	void PrintList(ListNode* head) {
		ListNode* count;
		count = head;
		while (count != nullptr)
		{
			cout << count->val << " ";
			count = count->next;
		}
		cout << endl;
	}
	
};

对于while(cin>>inputnum)的解释

cin是输入操作符，cin>>a的过程是先取得从键盘的输入值a，并将a赋给cin，因此while(cin>>a)的意思就是只要输入的值有效，那么就执行while体内的语句。

while(cin>>a)的合法性：

运算符返回的是流对象的引用，cin是一个流对象，而>>运算符返回左边的流对象，也就是说cin>>val返回cin，于是while(cin>>val)就变成了while(cin)，问题就变成了一个流对象在判断语句中的合法性。

不管是while(cin)还是if(cin)，都是合法的。因为定义一个类，然后定义该类的对象，然后使用if语句来判断它是不合法的。这说明，流对象具有某种转换函数，可以将一个流对象转换成判断语句可以识别的类型。

打开iostream.h文件中operator void *() const和bool operator!() const。这两个函数使得流对象可作为判断语句的内容。

operator void * () const;函数在while(cin)或是if(cin)时被调用，将流对象转换成void*类型。

bool operator!() const;函数在while(!cin)或是if(!cin)时被调用，将流对象转换成bool类型。

性能分析

再把链表的特性和数组的特性进行一个对比，如图所示：

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。

链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。

LeetCode 203.移除链表元素

203.移除链表元素

初步思路：遍历链表，找到要移除的元素，然后删除该节点，尝试后发现，因为无法直接定位到要删除元素的前一个元素，所以无法实现。不是普通的告诉删除那个地方的节点。

class Solution {
public:
	//203.移除链表元素
	ListNode* removeElements(ListNode* head, int val) {
		ListNode* virtualHead = new ListNode(0);//创建一个虚拟头节点
		virtualHead->next = head;
		ListNode* cur = virtualHead;
		while (cur->next != nullptr)
		{
			if (cur->next->value == val)
			{
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				//delete cur->next;		错误，cur->next已经变化了，必须需要一个中间指针tmp
				delete tmp;
			}
			else
			{
				cur = cur->next;
			}			
		}
		head = virtualHead->next;
		delete virtualHead;
		return head;
	}
};

LeetCode 707.设计链表

707.设计链表

链表操作的两种方式：

1. 直接使用原来的链表来进行操作。(不推荐)
2. 设置一个虚拟头结点在进行操作。(更方便)

class MyLinkedList {
public:
	//定义链表节点结构体
	struct LinkedNode
	{
		LinkedNode* next;
		int val;
		LinkedNode(int val) :val(val), next(nullptr){}	//用初始化列表初始化结构体，get
	};
	//初始化链表
	MyLinkedList() {
		_dummyHead = new LinkedNode(0);	//创建虚拟头节点
		_size = 0;
	}

	int get(int index) {
		//如果索引无效，则返回-1。
		if (index < 0 || index >= _size)
		{
			return -1;
		}
		LinkedNode* cur = _dummyHead->next;
		while (index--)
		{
			cur = cur->next;
		}
		return cur->val;
	}
	//头插法
	void addAtHead(int val) {
		//创建一个新节点
		LinkedNode* addNode = new LinkedNode(val);
		addNode->next = _dummyHead->next;
		_dummyHead->next = addNode;
		_size++;
	}
	//尾插法
	void addAtTail(int val) {
		//创建一个新节点
		LinkedNode* addNode = new LinkedNode(val);
		LinkedNode* cur = _dummyHead;
		//遍历到链表尾部
		while (cur->next != nullptr)
		{
			cur = cur->next;
		}
		addNode->next = cur->next;
		cur->next = addNode;
		_size++;
	}

	void addAtIndex(int index, int val) {
		if (index > _size || index < 0) {
            return;
        }
		//在链表中的第 index 个节点之前添加值为 val  的节点。
		//单链表无法往回找，所以必须使 cur 指向 index 的前一个节点。
		LinkedNode* cur = _dummyHead;		//注意这里是从虚拟头节点开始遍历的，而尾插法是从真正头节点开始遍历的
		//遍历到 index 的前一个节点。
		while (index--)
		{
			cur = cur->next;
		
		}
		//创建一个新节点
		LinkedNode* addNode = new LinkedNode(val);
		addNode->next = cur->next;
		cur->next = addNode;
		_size++;
	}
	//删
	void deleteAtIndex(int index) {
		//索引无效
		if (index < 0 || index >= _size)
		{
			return;
		}
		LinkedNode* cur = _dummyHead;
		//遍历到 index 的前一个节点。
		while (index--)
		{
			cur = cur->next;
		}
		LinkedNode* temp = cur->next;
		cur->next = cur->next->next;
		delete temp;
		_size--;
	}
	//打印
	void printLinkedList()
	{
		LinkedNode* cur = _dummyHead->next;
		while (cur->next != nullptr)
		{
			cout << cur->val << "  ";
			cur = cur->next;
		}
		cout << endl;
	}
private:
	LinkedNode* _dummyHead;
	int _size;
};

LeetCode 206.反转链表

206.反转链表

初步思路：
1、两个指针，一个从头开始，一个从尾开始，互换值，其实行不通，单链表无法往回走的
2、创建一个新链表存放结果，用头插法插入节点，比较浪费内存

LinkedNode* reverseList1(LinkedNode* Head)
{
	MyLinkedList result;
	LinkedNode* cur = Head;
	while (cur != nullptr)
	{
		LinkedNode* addNode = new LinkedNode(cur->val);
		addNode->next = result._dummyHead->next;
		result._dummyHead->next = addNode;
		result._size++;
		cur = cur->next;
	}
	return result._dummyHead;
}

//双指针法 反转链表
LinkedNode* reverseList(LinkedNode* Head)
{
	LinkedNode* pre = nullptr;
	LinkedNode* cur = Head;
	LinkedNode* temp = nullptr;		//保存cur的下一节点
    //注意顺序不能乱
	while (cur != nullptr)
	{
		temp = cur->next;		//保存cur的下一节点
		cur->next = pre;	//反转操作
		//更新指针
		pre = cur;
		cur = temp;
	}
	return pre;
}