数据结构与算法分析----单链表

已于 2022-02-22 15:09:47 修改
阅读量440 收藏
点赞数
文章标签： 数据结构 算法 c++
于 2022-02-22 11:16:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62538383/article/details/123051260
版权

61.耶斯莫拉

#include"stdafx.h"
#include<assert.h>
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;
typedef int ElemType;

typedef struct ListNode{
	ElemType data;
	struct ListNode *next;
}LinkNode,*LinkList;
//购买节点
ListNode *BuyNode(){
	ListNode *s = (ListNode *)malloc(sizeof(ListNode));
	if (s == NULL) exit(1);
	memset(s, 0, sizeof(ListNode));
	return s;
}
//释放节点
void FreeNode(ListNode *s){
	free(s);
}
//初始化单链表
ListNode *Init_LinkList(){
	ListNode *s = BuyNode();
	s->next = NULL;
	return s;
}
//打印链表
void PrintList(LinkList L){
	assert(L != NULL);
	ListNode *p=L->next ;
	while (p != NULL){
		cout << p->data << "   ";
		p = p->next;
	}
	cout << endl;
}
//查询链表
ListNode  * FindValue(LinkList L,ElemType val){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		if (p->data == val){
			return p;
		}
		p = p->next;
	}
	return NULL;
}
//返回当前节点的前一个节点
ListNode  * FindValue_Prev(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *prev = L;
	ListNode *p = L->next;
	while (p != NULL&&p->data != val){
		prev = p;
		p = p->next;
	}
	if (p == NULL){
		prev = NULL;

	}
	return prev;
}

//按位置查询节点
ListNode  *FindValue_index(LinkList L, int  pos){
	assert(L != NULL);
	ListNode *p = L->next;
	int i = 1;
	if (pos <= 0){
		cout << "位置信息不合法！" << endl;
		return NULL;
	}
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	return p;

}

//按位置查询前驱节点
ListNode  *FindValue_Prev_index(LinkList L, int  pos){
	assert(L != NULL);
	int i = 1;
	if (pos < 1)  return NULL;
	ListNode *p = L->next;
	ListNode *prev = L;
	while (p != NULL&&i < pos){
		prev = p;
		p = p->next;
		i++;
	}
	if (p == NULL){//这一步不可省略呀！！
		prev = NULL;
	}
	return prev;
}

//在指定节点插入元素
bool Insert_Next(LinkList L, ListNode *ptr, ElemType val){
	assert(ptr != NULL);
	if (ptr == NULL)  return false;
	LinkNode *r; 
	r = BuyNode();

	r->data = val;
	r->next = ptr->next;
	ptr->next = r;
	return true;
}
//头插法
void Push_Front(LinkList L, ElemType val){
	assert(L != NULL);
	Insert_Next(L,L, val);
}
//尾插法
void Push_Back(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p;
	p = L;
	while (p->next != NULL){
		p = p->next;
	}
	Insert_Next(L, p, val);
	
}
///
int main(){
	ListNode *head = Init_LinkList();
	for (int i = 0; i < 15; i++){
		Push_Back(head, i);
	}
	PrintList(head);
	
}

2.妈的  爷自己写的有这么不堪吗  非得debug滴这么久  算了  上代码！

#include"stdafx.h"
#include<assert.h>
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;
typedef int ElemType;

typedef struct ListNode{
	ElemType data;
	struct ListNode *next;
}LinkNode,*LinkList;
//购买节点
ListNode *BuyNode(){
	ListNode *s = (ListNode *)malloc(sizeof(ListNode));
	if (s == NULL) exit(1);
	memset(s, 0, sizeof(ListNode));
	return s;
}
//释放节点
void FreeNode(ListNode *s){
	free(s);
}
//初始化单链表
ListNode *Init_LinkList(){
	ListNode *s = BuyNode();
	s->next = NULL;
	return s;
}
//打印链表
void PrintList(LinkList L){
	assert(L != NULL);
	ListNode *p=L->next ;
	while (p != NULL){
		cout << p->data << "   ";
		p = p->next;
	}
	cout << endl;
}
//查询链表
ListNode  * FindValue(LinkList L,ElemType val){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		if (p->data == val){
			return p;
		}
		p = p->next;
	}
	return NULL;
}
//返回当前节点的前一个节点
ListNode  * FindValue_Prev(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *prev = L;
	ListNode *p = L->next;
	while (p != NULL&&p->data != val){
		prev = p;
		p = p->next;
	}
	if (p == NULL){
		prev = NULL;

	}
	return prev;
}

//按位置查询节点
ListNode  *FindValue_index(LinkList L, int  pos){
	assert(L != NULL);
	ListNode *p = L->next;
	int i = 1;
	if (pos <= 0){
		cout << "位置信息不合法！" << endl;
		return NULL;
	}
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	return p;

}

//按位置查询前驱节点
ListNode  *FindValue_Prev_index(LinkList L, int  pos){
	assert(L != NULL);
	int i = 1;
	if (pos < 1)  return NULL;
	ListNode *p = L->next;
	ListNode *prev = L;
	while (p != NULL&&i < pos){
		prev = p;
		p = p->next;
		i++;
	}
	if (p == NULL){//这一步不可省略呀！！
		prev = NULL;
	}
	return prev;
}

//在指定节点插入元素
bool Insert_Next(LinkList L, ListNode *ptr, ElemType val){
	assert(ptr != NULL);
	if (ptr == NULL)  return false;
	LinkNode *r; 
	r = BuyNode();

	r->data = val;
	r->next = ptr->next;
	ptr->next = r;
	return true;
}
//头插法
void Push_Front(LinkList L, ElemType val){
	assert(L != NULL);
	Insert_Next(L,L, val);
}
//尾插法
void Push_Back(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p;
	p = L;
	while (p->next != NULL){
		p = p->next;
	}
	Insert_Next(L, p, val);
	
}
//在指定位置插入节点
bool Insert_Pos(LinkList L, int pos, int val){
	assert(L != NULL);
	if (pos < 1) return false;
	int i = 1;
	ListNode *p; 
	p = L;
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	if (p != NULL){
		Insert_Next(L, p, val);
		return true;
	}
	else if (p == NULL&&i + 1 == pos){
		Insert_Next(L, p, val);
		return true;
	}
	else{
		cout << "插入位置不合法！" << endl;
		return false ;
	}

} 
//删除单链表中的元素
bool Delete_List(LinkList L, ListNode *ptr){
	assert(L != NULL);
	if (ptr == NULL)  return false;
	ptr->next = ptr->next->next;
	return true;
}
//从头部删除单链表的元素
void Pop_Front(LinkList L){
	assert(L != NULL);
	ListNode *p = L;
	if (p!= NULL){
		Delete_List(L, p);
	}
	else cout << "链表为空！" << endl;
}
//单链表尾删法
void Pop_Back(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next,*s=L;
	ListNode *pre = L;
	while (p->next != NULL){
		pre = p;
		p = p->next;
	}
	Delete_List(pre, s);
	//free(pre);
}
///
int main(){
	ListNode *head = Init_LinkList();
	
	for (int i = 1; i <= 15; i++){
		Push_Back(head, i);
	}
	PrintList(head);
	Pop_Back(head);
	//Pop_Front(head);
	PrintList(head);
	

	/*
	ListNode  *p = FindValue_index(head, 5);
	cout << p->data << endl;
	ListNode  *p = FindValue(head, 14);
	cout << p->data  << endl;
	while (1){
		int tag, pos, val;
		cout << "请输入插入位置和插入数值" << endl;
		cin >> pos >> val;
		if (val == -1)  break;
		tag=Insert_Pos(head, pos, val);
		PrintList(head);

	}
	*/
	cout << "时光作渡，眉目成书，从此深情不被辜负！" << endl;
}

2.呜呜呜代码丢失了  好惨！

这是临走前打印出来的  羽生结弦 俺爱你

3.昨天代码敲得脑子然乎了  乱写尾插法 现在更新一下改正的错误 并加一个时间复杂度为1的杉树所有值的函数

#include"stdafx.h"
#include<assert.h>
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;
typedef int ElemType;

typedef struct ListNode{
	ElemType data;
	struct ListNode *next;
}LinkNode, *LinkList;
//购买节点
ListNode *BuyNode(){
	ListNode *s = (ListNode *)malloc(sizeof(ListNode));
	if (s == NULL) exit(1);
	memset(s, 0, sizeof(ListNode));
	return s;
}
//释放节点
void FreeNode(ListNode *s){
	free(s);
}
//初始化单链表
ListNode *Init_LinkList(){
	ListNode *s = BuyNode();
	s->next = NULL;
	return s;
}
//打印链表
void PrintList(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		cout << p->data << "   ";
		p = p->next;
	}
	cout << endl;
}
//查询链表
ListNode  * FindValue(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		if (p->data == val){
			return p;
		}
		p = p->next;
	}
	return NULL;
}
//返回当前节点的前一个节点
ListNode  * FindValue_Prev(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *prev = L;
	ListNode *p = L->next;
	while (p != NULL&&p->data != val){
		prev = p;
		p = p->next;
	}
	if (p == NULL){
		prev = NULL;

	}
	return prev;
}

//按位置查询节点
ListNode  *FindValue_index(LinkList L, int  pos){
	assert(L != NULL);
	ListNode *p = L->next;
	int i = 1;
	if (pos <= 0){
		cout << "位置信息不合法！" << endl;
		return NULL;
	}
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	return p;

}

//按位置查询前驱节点
ListNode  *FindValue_Prev_index(LinkList L, int  pos){
	assert(L != NULL);
	int i = 1;
	if (pos < 1)  return NULL;
	ListNode *p = L->next;
	ListNode *prev = L;
	while (p != NULL&&i < pos){
		prev = p;
		p = p->next;
		i++;
	}
	if (p == NULL){//这一步不可省略呀！！
		prev = NULL;
	}
	return prev;
}

//在指定节点插入元素
bool Insert_Next(LinkList L, ListNode *ptr, ElemType val){
	assert(ptr != NULL);
	if (ptr == NULL)  return false;
	LinkNode *r;
	r = BuyNode();

	r->data = val;
	r->next = ptr->next;
	ptr->next = r;
	return true;
}
//头插法
void Push_Front(LinkList L, ElemType val){
	assert(L != NULL);
	Insert_Next(L, L, val);
}
//尾插法
void Push_Back(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p;
	p = L;
	while (p->next != NULL){
		p = p->next;
	}
	Insert_Next(L, p, val);

}
//在指定位置插入节点
bool Insert_Pos(LinkList L, int pos, int val){
	assert(L != NULL);
	if (pos < 1) return false;
	int i = 1;
	ListNode *p;
	p = L;
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	if (p != NULL){
		Insert_Next(L, p, val);
		return true;
	}
	else if (p == NULL&&i + 1 == pos){
		Insert_Next(L, p, val);
		return true;
	}
	else{
		cout << "插入位置不合法！" << endl;
		return false;
	}

}
//删除单链表中的元素
bool Delete_List(LinkList L, ListNode *ptr){
	assert(L != NULL);
	if (ptr == NULL)  return false;
	ptr->next = ptr->next->next;
	return true;
}
//从头部删除单链表的元素
void Pop_Front(LinkList L){
	assert(L != NULL);
	ListNode *p = L;
	if (p != NULL){
		Delete_List(L, p);
	}
	else cout << "链表为空！" << endl;
}
//单链表尾删法
void Pop_Back(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next, *s = L;
	ListNode *pre = L;
	while (p->next != NULL){
		pre = p;
		p = p->next;
	}
	Delete_List(L,pre);
	//free(pre);
}
void Swap(ElemType *a, ElemType *b){
	ElemType tmp= *a;
	*a = *b;
	*b = tmp;
}
//时间复杂度为O（1）的算法  删除所以值相等的元素
void Delete_All(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p = L->next, *pre = L;
	while (p != NULL){
		if (p->data != val){
			pre = pre->next;
			Swap(&(pre->data), &(p->data));
		}
		p = p->next;
	}
	while (pre->next != NULL) {
		Pop_Back(L);
	}
}

///
int main(){
	ListNode *head = Init_LinkList();
	ElemType arr[] = { 1, 23, 1, 45, 12, 456, 13};
	for (int i = 0; i < 7; i++){
		Push_Back(head, arr[i]);
	}
	PrintList(head);
	Delete_All(head, 12);
	PrintList(head);


	/*
	ListNode  *p = FindValue_index(head, 5);
	cout << p->data << endl;
	ListNode  *p = FindValue(head, 14);
	cout << p->data  << endl;
	while (1){
	int tag, pos, val;
	cout << "请输入插入位置和插入数值" << endl;
	cin >> pos >> val;
	if (val == -1)  break;
	tag=Insert_Pos(head, pos, val);
	PrintList(head);

	}
	*/
	cout << "时光作渡，眉目成书，从此深情不被辜负！" << endl;
}

3.好啦 带头节点的单链表操作就到此为止啦!

#include"stdafx.h"
#include<assert.h>
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;
typedef int ElemType;

typedef struct ListNode{
	ElemType data;
	struct ListNode *next;
}LinkNode, *LinkList;
//购买节点
ListNode *BuyNode(){
	ListNode *s = (ListNode *)malloc(sizeof(ListNode));
	if (s == NULL) exit(1);
	memset(s, 0, sizeof(ListNode));
	return s;
}
//释放节点
void FreeNode(ListNode *s){
	free(s);
}
//初始化单链表
ListNode *Init_LinkList(){
	ListNode *s = BuyNode();
	s->next = NULL;
	return s;
}
//打印链表
void PrintList(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		cout << p->data << "   ";
		p = p->next;
	}
	cout << endl;
}
//查询链表
ListNode  * FindValue(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		if (p->data == val){
			return p;
		}
		p = p->next;
	}
	return NULL;
}
//返回当前节点的前一个节点
ListNode  * FindValue_Prev(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *prev = L;
	ListNode *p = L->next;
	while (p != NULL&&p->data != val){
		prev = p;
		p = p->next;
	}
	if (p == NULL){
		prev = NULL;

	}
	return prev;
}

//按位置查询节点
ListNode  *FindValue_index(LinkList L, int  pos){
	assert(L != NULL);
	ListNode *p = L->next;
	int i = 1;
	if (pos <= 0){
		cout << "位置信息不合法！" << endl;
		return NULL;
	}
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	return p;

}

//按位置查询前驱节点
ListNode  *FindValue_Prev_index(LinkList L, int  pos){
	assert(L != NULL);
	int i = 1;
	if (pos < 1)  return NULL;
	ListNode *p = L->next;
	ListNode *prev = L;
	while (p != NULL&&i < pos){
		prev = p;
		p = p->next;
		i++;
	}
	if (p == NULL){//这一步不可省略呀！！
		prev = NULL;
	}
	return prev;
}

//在指定节点插入元素
bool Insert_Next(LinkList L, ListNode *ptr, ElemType val){
	assert(ptr != NULL);
	if (ptr == NULL)  return false;
	LinkNode *r;
	r = BuyNode();

	r->data = val;
	r->next = ptr->next;
	ptr->next = r;
	return true;
}
//头插法
void Push_Front(LinkList L, ElemType val){
	assert(L != NULL);
	Insert_Next(L, L, val);
}
//尾插法
void Push_Back(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p;
	p = L;
	while (p->next != NULL){
		p = p->next;
	}
	Insert_Next(L, p, val);

}
//在指定位置插入节点
bool Insert_Pos(LinkList L, int pos, int val){
	assert(L != NULL);
	if (pos < 1) return false;
	int i = 1;
	ListNode *p;
	p = L;
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	if (p != NULL){
		Insert_Next(L, p, val);
		return true;
	}
	else if (p == NULL&&i + 1 == pos){
		Insert_Next(L, p, val);
		return true;
	}
	else{
		cout << "插入位置不合法！" << endl;
		return false;
	}

}
//删除单链表中的元素
bool Delete_List(LinkList L, ListNode *ptr){
	assert(L != NULL);
	if (ptr == NULL)  return false;
	ptr->next = ptr->next->next;
	return true;
}
//从头部删除单链表的元素
void Pop_Front(LinkList L){
	assert(L != NULL);
	ListNode *p = L;
	if (p != NULL){
		Delete_List(L, p);
	}
	else cout << "链表为空！" << endl;
}
//单链表尾删法
void Pop_Back(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next, *s = L;
	ListNode *pre = L;
	while (p->next != NULL){
		pre = p;
		p = p->next;
	}
	Delete_List(L,pre);
	//free(pre);
}
void Swap(ElemType *a, ElemType *b){
	ElemType tmp= *a;
	*a = *b;
	*b = tmp;
}
//时间复杂度为O（1）的算法  删除所以值相等的元素
void Delete_All(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p = L->next, *pre = L;
	while (p != NULL){
		if (p->data != val){
			pre = pre->next;
			Swap(&(pre->data), &(p->data));
		}
		p = p->next;
	}
	while (pre->next  != NULL) {
		Pop_Back(L);
	}
}
//清除函数--->只剩头节点
void ClearList(LinkList L){
	ListNode *p =L;
	while (p->next != NULL){
		Pop_Back(L);
	}
}
//摧毁函数--->头节点也清空
void DestoryList(LinkList L){
	assert(L != NULL);
	ClearList(L);

	free(L);
	cout << "破坏成功！" << endl;
}
///
int main(){
	ListNode *head = Init_LinkList();
	ListNode *p = head->next;
	ElemType arr[] = { 1, 23, 1, 45, 12, 456, 13};
	for (int i = 0; i < 7; i++){
		Push_Back(head, arr[i]);
	}
	PrintList(head);
	ClearList(head);
	cout << p;
	PrintList(head);


	/*
	ListNode  *p = FindValue_index(head, 5);
	cout << p->data << endl;
	ListNode  *p = FindValue(head, 14);
	cout << p->data  << endl;
	while (1){
	int tag, pos, val;
	cout << "请输入插入位置和插入数值" << endl;
	cin >> pos >> val;
	if (val == -1)  break;
	tag=Insert_Pos(head, pos, val);
	PrintList(head);

	}
	*/
	cout << "时光作渡，眉目成书，从此深情不被辜负！" << endl;
}

1.一直都知道在一个函数中定义变量的位置很重要  但是没有想到先定义也会出问题  保守起见  以后每次定义变量遵循用时定义  md搞我心态

这个时逆置后的结果 代码最后上吧 

#include"stdafx.h"
#include<assert.h>
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;
typedef int ElemType;

typedef struct ListNode{
	ElemType data;
	struct ListNode *next;
}LinkNode, *LinkList;
//购买节点
ListNode *BuyNode(){
	ListNode *s = (ListNode *)malloc(sizeof(ListNode));
	if (s == NULL) exit(1);
	memset(s, 0, sizeof(ListNode));
	return s;
}
//释放节点
void FreeNode(ListNode *s){
	free(s);
}
//初始化单链表
ListNode *Init_LinkList(){
	ListNode *s = BuyNode();
	s->next = NULL;
	return s;
}
//打印链表
void PrintList(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		cout << p->data << "   ";
		p = p->next;
	}
	cout << endl;
}
//查询链表
ListNode  * FindValue(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p = L->next;
	while (p != NULL){
		if (p->data == val){
			return p;
		}
		p = p->next;
	}
	return NULL;
}
//返回当前节点的前一个节点
ListNode  * FindValue_Prev(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *prev = L;
	ListNode *p = L->next;
	while (p != NULL&&p->data != val){
		prev = p;
		p = p->next;
	}
	if (p == NULL){
		prev = NULL;

	}
	return prev;
}

//按位置查询节点
ListNode  *FindValue_index(LinkList L, int  pos){
	assert(L != NULL);
	ListNode *p = L->next;
	int i = 1;
	if (pos <= 0){
		cout << "位置信息不合法！" << endl;
		return NULL;
	}
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	return p;

}

//按位置查询前驱节点
ListNode  *FindValue_Prev_index(LinkList L, int  pos){
	assert(L != NULL);
	int i = 1;
	if (pos < 1)  return NULL;
	ListNode *p = L->next;
	ListNode *prev = L;
	while (p != NULL&&i < pos){
		prev = p;
		p = p->next;
		i++;
	}
	if (p == NULL){//这一步不可省略呀！！
		prev = NULL;
	}
	return prev;
}

//在指定节点插入元素
bool Insert_Next(LinkList L, ListNode *ptr, ElemType val){
	assert(ptr != NULL);
	if (ptr == NULL)  return false;
	LinkNode *r;
	r = BuyNode();

	r->data = val;
	r->next = ptr->next;
	ptr->next = r;
	return true;
}
//头插法
void Push_Front(LinkList L, ElemType val){
	assert(L != NULL);
	Insert_Next(L, L, val);
}
//尾插法
void Push_Back(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p;
	p = L;
	while (p->next != NULL){
		p = p->next;
	}
	Insert_Next(L, p, val);

}
//在指定位置插入节点
bool Insert_Pos(LinkList L, int pos, int val){
	assert(L != NULL);
	if (pos < 1) return false;
	int i = 1;
	ListNode *p;
	p = L;
	while (p != NULL&&i<pos){
		p = p->next;
		i++;
	}
	if (p != NULL){
		Insert_Next(L, p, val);
		return true;
	}
	else if (p == NULL&&i + 1 == pos){
		Insert_Next(L, p, val);
		return true;
	}
	else{
		cout << "插入位置不合法！" << endl;
		return false;
	}

}
//删除单链表中的元素
bool Delete_List(LinkList L, ListNode *ptr){
	assert(L != NULL);
	if (ptr == NULL)  return false;
	ptr->next = ptr->next->next;
	return true;
}
//从头部删除单链表的元素
void Pop_Front(LinkList L){
	assert(L != NULL);
	ListNode *p = L;
	if (p != NULL){
		Delete_List(L, p);
	}
	else cout << "链表为空！" << endl;
}
//单链表尾删法
void Pop_Back(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next, *s = L;
	ListNode *pre = L;
	while (p->next != NULL){
		pre = p;
		p = p->next;
	}
	Delete_List(L, pre);
	//free(pre);
}
void Swap(ElemType *a, ElemType *b){
	ElemType tmp = *a;
	*a = *b;
	*b = tmp;
}
//时间复杂度为O（1）的算法  删除所以值相等的元素
void Delete_All(LinkList L, ElemType val){
	assert(L != NULL);
	ListNode *p = L->next, *pre = L;
	while (p != NULL){
		if (p->data != val){
			pre = pre->next;
			Swap(&(pre->data), &(p->data));
		}
		p = p->next;
	}
	while (pre->next != NULL) {
		Pop_Back(L);
	}
}
//清除函数--->只剩头节点
void ClearList(LinkList L){
	ListNode *p = L;
	while (p->next != NULL){
		Pop_Back(L);
	}
}
//摧毁函数--->头节点也清空
void DestoryList(LinkList L){
	assert(L != NULL);
	ClearList(L);

	free(L);
	cout << "破坏成功！" << endl;
}
/*
void Inversion_List(LinkList L){
assert(L != NULL);
LinkList  head = Init_LinkList();
ListNode *p = L->next;
while (p != NULL){
Push_Front(head, p->data);
p = p->next;
}
ListNode	*q = head->next, *s = L->next;
while (q != NULL&&s!=NULL){
s->data = q->data;
s = s->next;
q = q->next;
}
}
*/
//单链表逆置(老师的算法yyds!)
void Inversion_List(LinkList L){
	assert(L != NULL);
	ListNode *p = L->next,*pre=L;
	pre->next = NULL;
	while (p != NULL){
		Push_Front(L, p->data);
		p = p->next;
	}
}
///
int main(){
	ListNode *head = Init_LinkList();
	ListNode *p = head->next;
	ElemType arr[] = { 1, 23, 1, 45, 12, 456, 13 };
	for (int i = 0; i < 7; i++){
		Push_Back(head, arr[i]);
	}
	PrintList(head);
	Inversion_List(head);
	cout << "逆置后的链表为：" << endl;
		/*
		ClearList(head);
	cout << p;
		*/
	PrintList(head);


	/*
	ListNode  *p = FindValue_index(head, 5);
	cout << p->data << endl;
	ListNode  *p = FindValue(head, 14);
	cout << p->data  << endl;
	while (1){
	int tag, pos, val;
	cout << "请输入插入位置和插入数值" << endl;
	cin >> pos >> val;
	if (val == -1)  break;
	tag=Insert_Pos(head, pos, val);
	PrintList(head);

	}
	*/
	cout << "时光作渡，眉目成书，从此深情不被辜负！" << endl;
}

仗剑天涯津一
关注
数据结构|单链表的算法解析 C++
yanyanyanzi111的博客
07-21 1019
本周学习了数据结构的单链表知识，现将有关单链表的几种算法分析和代码记录于本文链表常用操作p=l;//头节点p=l->next;//首元结点q=p->next;p=q;p!=NULL;p->next!
数据结构与算法分析----单链表增加 删除 查找 求表长 判空 逆置 合并 链接
小缪的博客
03-07 490
逆置采用头插法逆置 #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node* next; } node; node* linkedlist_init(); void linkedlist_destory(node* head); int linkedlist_insert(node* head, int pos, int x); int linked.
数据结构与算法分析——单链表
qq_30697841的博客
08-20 362
单链表 链表由一系列不必在内存中相邻的结构组成。每一个结构均含有表元素和指向包含该元素后继元的结构的指针，即Next指针。 代码实现如下 List.h#ifndef _List_Hstruct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; typedef int
数据结构与算法分析--单链表
qq_38473009的博客
09-21 605
头结点：单链表前面附设的一个结点 头指针：从头指针开始，指向第一个结点的指针 首节点：第一个包含元素的结点 单链表的存储结构： typedef struct Node{ ElemType data; struct Node *next; }Node; typedef struct Node *LinkList; //定义LinkList 单链表的读取实现： ...
线性表单链表算法分析（C语言）
weixin_43293451的博客
03-12 459
#include "pch.h" #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int ElemType; typedef int Status; /*存储结构*...
邻接表（spfa模版）
weixin_30546933的博客
07-15 121
http://www.cnblogs.com/tonghao/p/4708661.html//数组模拟 邻接表只是储存图的方法，要求最短路还是要用其他算法。SPFA迪杰斯特拉等等算法。 #include<stdio.h> #include<iostream> #include<stdlib.h> #include<qu...
数据结构与算法分析-Java语言描述(第3版)源码.rar
03-18
《数据结构与算法分析-Java语言描述(第3版)源码》是计算机科学领域的一本经典教材，主要关注如何用Java语言实现各种数据结构和算法。这本书的第三版不仅涵盖了基本的数据结构如数组、链表、栈、队列、树、图，还深入...
西安电子科技大学-数据结构与算法-期末知识点总结.pdf
01-05
"西安电子科技大学-数据结构与算法-期末知识点...本资源涵盖了数据结构与算法的基本概念、线性表、栈与队列、树与二叉树、图、查找算法和排序算法等方面的知识点，对于学习数据结构与算法的学生具有重要的参考价值。
【数据结构和算法分析】单链表的基本实现
HY's blooooog
07-25 533
public class MyList {          /*      * 单向链表的基本实现      * 包括插入结点，删除结点，查询某一位置结点的值，修改结点的值，反正结点的位置等基本功能      */     Node headNode;   //头结点     Node tailNode;   //尾结点     int length;    //链表长度   
单链表算法总结
健身房
10-13 739
C语言单链表算法总结
单链表基本算法
xiaomashitu_的博客
04-06 635
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int LinkType; typedef struct LinkNode{ LinkType data; struct LinkNode *next; }LinkList; //链表初始化 void Linklistinit(LinkList **head) { ...
数据结构与算法——单链表
weiye1497的博客
05-23 361
目录 前言 链表是有序链表，在内存存储如下： 单链表(带头结点) 逻辑结构示意图如下 二、使用步骤 使用带 head 头的单向链表实现编号、姓名的添加，完成对人物的增删改查操作 1.链表的基本信息 2.读取链表的一些方法 3.链表测试 前言 链表是一种根据元素节点逻辑关系排列起来的一种数据结构。利用链表可以保存多个数据，这一点类似于数组的概念，但是数组本身有一个缺点,数组的长度固定，不可改变，在长度固定的情况下首选的肯定是数组，但是在现实的开发之中往往要保存的内容长度是不确定的，那...
[数据结构与算法分析] 单链表基本操作的实现
weixin_30770783的博客
02-01 162
　　这几天还在啃Weiss书的Ch.3，随手把书上单链表基本操作的代码打了一遍，顺便补充了一点自己写的东西（一堆注释以及几个函数），经过测试应该是没问题。 　　这次尝试用所谓的"Google Style"写代码，习惯了缩进4空格的Windows风格后再改到缩进2空格，真的是有些不习惯。本来Google Style中，变量应该都是小写字母，但我实在不喜欢小写的L和P，变量命名仍就坚持自己的习惯——...
单链表的常用算法
kxbdys的博客
03-30 5316
一、判断链表是否为空 1、空表：链表中无元素，称为空链表，但头指针和头节点仍然存在。 2、算法思路：判断头结点的指针域是否为空。 int ListEmpty(LinkList L){ //若L为空表，则返回1，否则返回0 if(L->next) //非空 return 0; else return 1; } ...
单链表经典算法 (详细思路解析和代码实现)
最新发布
aaa114514aaaa的博客
04-28 1935
有关单链表经典算法的解析
数据结构与算法分析 C语言描述 单链表的实现
lclwjl的专栏
04-13 1015
数据结构 链表 实现
数据结构与算法分析：（三）单向链表
riemann_的博客
02-22 864
一、什么是链表？ 链表是一种物理上非连续、非顺序的存储结构，数据元素之间的顺序是通过每个元素的指针（类似C语言中的指针，Java中是引用）关联的。 链表由一系列节点组成，每个节点一般至少会包含两部分信息：一部分是元素数据本身，另一部分是指向下一个元素地址的“指针”。这样的存储结构让链表相比其他线性的数据结构来说，操作会复杂一些。 说到链表，我们经常拿来与数组比。我们先看下面一张图再来对比它们的各自...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值