链表基础操作

链表基本操作

1.链表结构体定义

struct Node{
int data;
Node*next;
}

2.不需要指针的基本操作

//判断链表是否为空
bool EmptyList(Node* head) {
	if (head->next == NULL) {
		return true;
	}
	return false;
}
//返回链表的长度
int LinkLength(Node* head) {
	return head->data;
}

3.需要一个指针的基本操作

//返回第i个元素（用来查找元素位置）
void GetElem(Node* head, int i,int& a) {
	Node* p;
    int j = 1;
	p = head->next;
	while (p && j < i) {
		p = p->next;
		j++;
	}
	if (!p || j > i)  //没有找到元素有两情况，一种是i>n,一种是i<j;
		return;
	a = p->data;
	return;
}

//返回与a相等元素的位置
int LocateElem(Node* head, int a) {
	Node* p;
	int j = 1;
	p = head->next;
	while (p && p->data != a) {
		p = p->next;
		j++;
	}
	if (!p)
		return 0;
	return j;
}

4.需要两个指针的基本操作

//两个指针的情况
//第一种就是申请结点的时候，一个指针用来申请结点，一个指针负责插入
//后面的指针负责申请空间
//第二种情况是防止断链，删除结点的时候需要另外一个结点记住链表位置

//创建链表
void CreatLink(Node*& head, int n) {
	head = new Node;
	head->next = NULL;
	head->data = n;
	Node* pre, * p;
	pre = head;
	for (int i = 0; i < n; i++) {
		p = new Node;
		cin >> p->data;
		p->next = pre->next;
		pre->next = p;
		pre = p;
	}
}

//清空链表
void ClearLink(Node*& head) {
	Node* pre, * p;
	pre = head->next;
	while (pre) {
		p = pre->next;
		delete pre;
		pre = p;
	}
	head->next = NULL;
}

//获取a元素前一个元素
int PriorElem(Node* head, int a) {
	Node* pre, * p;
	pre = head;
	p = head->next;
	while (p && p->data != a) {
		pre = p;
		p = pre->next;
	}
	return pre->data;
}

//获取a元素后一个元素  //其实这里可以只用一个指针
int NextElem(Node* head, int a) {
	Node* pre, * p;
	pre = head->next;
	p = pre->next;
	while (p && a != pre->data) {
		pre = p;
		p = pre->next;
	}
	return p->data;


//在第i个位置插入数据
void InsertElem(Node*& head, int i, int a) {
	Node* pre, * p;
	pre = head->next;
	int j = 1;
	while (j < i - 1) {
		pre = pre->next;
		j++;
	}
	p = new Node;
	p->data = a;
	p->next = pre->next;
	pre->next = p;
	head->data++;
}

//删除第i个位置的元素
void DeleteElem(Node* head, int i, int& a) {
	Node* pre, * p;
	int j = 1;
	pre = head;
	p = pre->next;
	while (j<i) {
		pre = p;
		p = pre->next;
		j++;
	}
	pre->next = p->next;
	a = p->data;
	delete p;
}
//将元素逆序  //两个结点是为了防止断链
void ResortLink(Node*& head) {
	Node* pre, * p;
	pre = head->next;
	head->next = NULL;
	while (pre) {
		p = pre->next;
		pre->next = head->next;
		head->next = pre;
		pre = p;
	}
}

5.需要三个指针的基本操作

//一个指针是指向比较的元素
//另外两个指针是为了执行删除结点操作。


//删除相同的元素，删除后面的
void DeleteSame(Node* head) {
	Node* elem, * pre, * p;
	elem = head->next;
	while (elem) {
		//删除与elem.data相同的元素
		pre = elem;
		p = pre->next;
		while (p && p->data != elem->data) {
			pre = p;
			p = pre->next;
		}
		if (p) {
			pre->next = p->next;
			delete p;
			head->data--;
		}
		elem = elem->next;
	}
}

6.需要四个指针的基本操作

//四个指针，都是因为有两个链表，
//一个链表是因为删除结点，需要记住位置，防止断链
//一个链表是因为插入结点需要一个指针，寻找插入的地方需要一个指针


//选择排序
void SelectSort(Node*& head) {
	Node* max, *maxpre, *pre, *p;  //max指向最大值，p复制往后遍历
	Node* head1 = new Node;
	head1->next = NULL;
	maxpre = head;
	max = maxpre->next;
	while (max) {
		pre = max;
		p = pre->next;
		//遍历后面所有元素，是max指向最大值
		while (p) {
			if (p->data > max->data) {
				maxpre = pre;
				max = maxpre->next;
			}
			pre = p;
			p = pre->next;
		}
		//将最大值插入临时链表head1
		maxpre->next = max->next; //把这个结点取出来
		max->next = head1->next;  //将结点插入临时链表
		head1->next = max;
		maxpre = head; //再次指向第一个元素
		max = maxpre->next;
	}
	head->next = head1->next;
	delete head1;
}

//插入排序
void InsertSort(Node*& head) {
	Node* flag, * preflag, * pre, *p; //flag指向插入点
	//把链表分为有序链表和数据链表
	pre = head->next->next; //指向第2个元素
	p = pre->next;
	head->next->next = NULL;
	preflag = head;
	flag = preflag->next;
	//开始将数据链表中元素加入链表
	while (1) {
		//如果比插入点小就插入，否则插入点往后遍历
		while (flag) {
			if (pre->data < flag->data) {
				pre->next = preflag->next;
				preflag->next = pre;
				break;
			}
			preflag = flag;
			flag = preflag->next;
		}
		//所有插入点都不满足要求,插入到最后面
		if (!flag) {
			pre->next = preflag->next;
			preflag->next = pre;
		}
		//插入点重新指向第一个元素
		preflag = head;
		flag = preflag->next;
		//开始处理下一个元素
		pre = p;
		if (pre == NULL)
			break;
		p = pre->next;
	}
}

//两个链表合并之后依然有序，重复元素删除
void InsertSort(Node*& head1，Node* head2) {
	Node* flag, * preflag, * pre, *p; //flag指向插入点
	//把链表分为有序链表和数据链表
	pre = head2; //指向第2个元素
	p = pre->next;
	preflag = head1;
	flag = preflag->next;
	//开始将数据链表中元素加入链表
	while (1) {
		//如果比插入点小就插入，否则插入点往后遍历
		while (flag) {
			if (pre->data < flag->data) {
				pre->next = preflag->next;
				preflag->next = pre;
				break;
			}
            if(pre->data== flag->data)
                break;
			preflag = flag;
			flag = preflag->next;
		}
		//所有插入点都不满足要求,插入到最后面
		if (!flag) {
			pre->next = preflag->next;
			preflag->next = pre;
		}
		//插入点重新指向第一个元素
		preflag = head;
		flag = preflag->next;
		//开始处理下一个元素
		pre = p;
		if (pre == NULL)
			break;
		p = pre->next;
	}
}