数据结构与算法--顺序表--单链表

于 2025-05-15 19:40:50 发布
阅读量671 收藏 26
点赞数 8
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43528481/article/details/147569379

一 顺序表

  • 需要指向存储位置的基地址
  • 分配一段连续的内存
  • 用length记录实际的元素的个数，也即顺序表的长度，因为顺序表是允许删除和插入元素的
  • 不需要定义数组

在这里插入图片描述

1.1 普通结构体数组实现版本，实现白色的点以一定的步长移除画面，大量for循环，并且由于数组内部数据需要去除的点并不是连续的，就需要每次从0遍历到数组的结尾，但是实际上，已经消失的点可以不用再进行循环和判断

在这里插入图片描述

#include <iostream>
#include <exception>
#include <stdexcept>
#include "string"
#include <fstream>
#include<conio.h>
#include<Windows.h>
#include <graphics.h>

#define SCREEN_WIDTH 654
#define SCREEN_HEIGHT 480
#define STAR_MAX_NUM 100
#define MAX_STEP 2
#define MAX_STAR_RADIUS 3
#define BOTTOM_MARGIN 100
#define IMG_SIZE 50

enum STATUS {
	STOP=0,
	UP,
	DOWN,
	LEFT,
	RIGHT,
	RANDON
};

struct STAR {
	int x;
	int y;
	unsigned radius;
	int step;  //每次走的间隔
	int color;
	bool alive;
	enum STATUS stat;
}star[STAR_MAX_NUM];

void initStar(int i) {
	//初始化星星
	star[i].x = rand() % SCREEN_WIDTH;
	star[i].y = rand() % (SCREEN_HEIGHT - IMG_SIZE);
	star[i].step = rand() % MAX_STEP + 1;
	int rgb = 0;
	rgb = rand() % 255;
	star[i].color = RGB(rgb, rgb, rgb);
	star[i].radius = rand() % MAX_STAR_RADIUS;

	setfillcolor(star[i].color);
	solidcircle(star[i].x, star[i].y, star[i].radius);

	star[i].alive = true;
}


void eraseStar(int i) {
	for (int i = 0; i < STAR_MAX_NUM; i++) {
		//擦除原来的星星
		setfillcolor(BLACK);
		solidcircle(star[i].x, star[i].y, star[i].radius);

		if (star[i].alive && (star[i].y - star[i].step) >0) {
			star[i].y = star[i].y - star[i].step;
			setfillcolor(star[i].color);
			solidcircle(star[i].x, star[i].y, star[i].radius);
		}
		else {
			star[i].alive = false;
		}
	}
}

//判断画面里面还有没有星星
bool hasStar() {
	for (int i = 0; i < STAR_MAX_NUM; i++) {
		if (star[i].alive == true) {
			return true;
			break;
		}
	}
	return false;
}

int main() {
	initgraph(SCREEN_WIDTH, SCREEN_HEIGHT);

	IMAGE bg_img;
	loadimage(&bg_img, _T("y3.png"), IMG_SIZE, IMG_SIZE, true);
	putimage(int(SCREEN_WIDTH * 0.3), SCREEN_HEIGHT - IMG_SIZE, &bg_img);
	putimage(int(SCREEN_WIDTH * 0.7), SCREEN_HEIGHT - IMG_SIZE, &bg_img);

	//绘制星星
	for (int i = 0; i < STAR_MAX_NUM; i++) {
		initStar(i);
	}

	//消除星星,并不是直接擦除，是以一定的步长走出画面的
	int i = 0;
	while(hasStar()) {
		for (int i = 0; i < STAR_MAX_NUM; i++) {
			eraseStar(i);
		}
		Sleep(100);
	}

	system("pause");
	return 0;
}

1.2 顺序表实现

  • 插入元素，插入位置不能小于0，也不能大于当前数组长度；还需要判断数组是不是满了，如果满了就不能再插入；从最后一个元素开移动
  • 添加元素：判断空间有没有满即可

定义顺序：

  • （1) 定义一个结构体，包含顺序表的首地址，内存大小，以及实际元素个数
typedef struct _OrderList Olist;   //定义结构体的别名
struct _OrderList {
	int* firstElement;  //顺序表的首地址
	int elemNum;        //档期那表里的元素
	int size;            //顺序表分配的空间，也就是连续内存的大小
};
  • (2)为结构体分配内存空间

1.2.1 结构体别名问题 ，定义结构体的别名，可能有时候名字太长了typedef 

typedef struct _OrderList Olist;   //定义结构体的别名，可能有时候名字太长了

struct _OrderList {
	int* firstElement;  //顺序表的首地址
	int elemNum;        //档期那表里的元素
	int size;            //顺序表分配的空间，也就是连续内存的大小
};

typedef  struct {
	int* firstElement;  //顺序表的首地址
	int elemNum;        //档期那表里的元素
	int size;            //顺序表分配的空间，也就是连续内存的大小
}Olist;

1.2.2 顺序表可以直接list.elems[i]来访问数组，数组名本质上是指向数组第一个元素的指针。因此，elems 作为 int* 类型，可以像数组一样使用下标操作符 [] 来访问元素。类似于函数形参，void print(int *array) 和 void print(int array[])一样

elems[i] 等价于 *(elems + i)，即通过指针算术运算访问第 i 个元素的值

void listPrint(Olist& list) {
	cout << "顺序表元素个数" << list.elemNum << ", 顺序表空间:" << list.size << endl;
	for (int i = 0; i < list.elemNum; i++) {
		cout << list.elems[i] << " ";
	}
	cout << endl;
}

1.2.3 连续输入数据 cout << "\n请输入要插入的位置和元素:"; cin >> pos >> e; 

#include <iostream>
#include <exception>
#include <stdexcept>
#include "string"
#include <fstream>
#include<conio.h>
#include<Windows.h>
#include <graphics.h>


using namespace std;
#define MAX_SIZE 20


typedef struct _OrderList Olist;   //定义结构体的别名
struct _OrderList {
	int* elems;  //顺序表的首地址
	int elemNum;           //表里的元素个数
	int size;            //顺序表分配的空间，也就是连续内存的大小
};

void listPrint(Olist& list) {
	cout << "\n顺序表元素个数" << list.elemNum << ", 顺序表空间:" << list.size << endl;
	for (int i = 0; i < list.elemNum; i++) {
		cout << list.elems[i] << " ";
	}
	cout << endl;
}

bool  init(Olist& list) {
	//初始是没有元素的，为首地址元素分配空间其实就是为顺序表分配空间
	list.elems = new int[MAX_SIZE];
	if (!list.elems) {
		return false;
	}
	list.elemNum = 0;
	list.size = MAX_SIZE;
	return true;
}

bool appendList(Olist& list, int ele) {
	if (list.elemNum == list.size) {
		cout << "顺序表已经满了，不能再插入" << endl;
		return false;
	}
	list.elems[list.elemNum] = ele;   //能这样做是因为地址是连续的
	list.elemNum++;
	return true;
}

bool insertList(Olist& list, int position, int ele) {
	if (list.elemNum == list.size) {
		cout << "顺序表已经满了，不能再插入" << endl;
		return false;
	}

	if (position < 0 || position >= list.elemNum) {
		cout << "插入位置不合法" << endl;
		return false;
	}

	for (int i = list.elemNum - 1; i >= position; i--) {
		list.elems[i + 1] = list.elems[i];
	}
	list.elems[position] = ele;
	list.elemNum++;
	return true;
}

bool deleteList(Olist& list, int position)
{
	if (list.elemNum == 0 || position < 0 || position >= list.elemNum) {
		cout << "删除位置不合法" << endl;
		return false;
	}

	list.elems[position] = -1;
	for (int i = position; i < list.elemNum-1; i++) {
		list.elems[i] = list.elems[i+1];
	}
	list.elemNum--;
	return true;
}

void destroyList(Olist& list) {
	if (list.elems) delete[] list.elems;

	list.size = 0;
	list.elemNum = 0;
}

int main() {
	Olist list;
	
	///////////////////////////////////////////////////////
	cout << "初始化顺序表" << endl;
	if (!init(list)) {
		cout << "顺序表内存分配失败" << endl;
		return 0;
	}

	listPrint(list);

	///////////////////////////////////////////////////////
	int count = 0;
	int e;
	cout << "请输入要添加的元素个数:";
	cin >> count;

	for (int i = 0; i < count; i++) {
		cout << "\n请输入要添加的元素:";
		cin >> e;
		appendList(list,e);
	}
	listPrint(list);

	/////////////////////////////////////////////////////////
	int pos;
	cout << "\n请输入要插入的位置和元素:";
	cin >> pos >> e;	
	if (insertList(list, pos, e))
	{
		cout << "插入成功" << endl;
	}
	else {
		cout << "插入失败" << endl;
	}
	listPrint(list);

	///////////////////////////////////////////////////////
	cout << "\n请输入要删除的位置";
	cin >> pos;
	if (deleteList(list, pos))
	{
		cout << "删除成功" << endl;
	}
	else {
		cout << "删除失败" << endl;
	}
	listPrint(list);


	destroyList(list);

	return 0;
}

1.3 顺序表优化星星消除。什么时候使用顺序表：频繁的遍历所有元素。顺序表存储数据都是相邻的。

知识点1：防止头文件重复包含

#ifndef _SATR_H_
#define _SATR_H_

。。。。
#endif

知识点2：顺序表的数据类型可以任意定义，顺序表本质是一个结构体，给的是一个结构体首地址，然后初始化的时候分配内存空间。而当前案例里面，星星本身也是一个结构体，因此顺序表里面的数据类型变成了结构体，Olist starList; //初始化一个顺序表，对应是首地址，存放第一颗星星，struct STAR star;创建的只是一颗星星，当前案例是在starList顺序表里面存放多颗星星，所以传入数据void eraseStar(Olist& list, int i)是顺序表时，访问顺序表里面的每一颗星星，需要先通过顺序表访问每一个对象，再访问对象本身的属性list.elems[i].alive

//定义顺序表，存储多个星星
typedef struct _OrderList Olist;   //定义结构体的别名
struct _OrderList {
	struct STAR* elems;  //顺序表的首地址
	int elemNum;           //表里的元素个数
	int size;            //顺序表分配的空间，也就是连续内存的大小
};

知识点3：删除顺序表里面的元素的的时候，是在void eraseStar(Olist& list, int i)函数里面调用了deleteList(list,i);进行元素的删除，而 不是 直接在主函数里面做如下操作，因为每一次消除星星,并不是直接擦除，是以一定的步长走出画面的，如果做如下操作，逻辑不对，走出画面的星星才擦除，而不是直接擦除

	int i = 0;
	while(starList.elemNum) {
		for (int i = 0; i < starList.elemNum; i++) {
			eraseStar(starList,i);
			deleteList(list,i);
		}
		Sleep(200);
	}

code

  • star.h
#pragma once
#ifndef _SATR_H_
#define _SATR_H_

#define SCREEN_WIDTH 654
#define SCREEN_HEIGHT 480
#define STAR_MAX_NUM 100
#define MAX_STEP 2
#define MAX_STAR_RADIUS 3
#define BOTTOM_MARGIN 100
#define IMG_SIZE 50

enum STATUS {
	STOP = 0,
	UP,
	DOWN,
	LEFT,
	RIGHT,
	RANDON
};

//定义星星结构体对象，描述一颗星星
struct STAR {
	int x;
	int y;
	unsigned radius;
	int step;  //每次走的间隔
	int color;
	bool alive;
	enum STATUS stat;
};

//定义顺序表，存储多个星星
typedef struct _OrderList Olist;   //定义结构体的别名
struct _OrderList {
	struct STAR* elems;  //顺序表的首地址
	int elemNum;           //表里的元素个数
	int size;            //顺序表分配的空间，也就是连续内存的大小
};

void listPrint(Olist& list);
bool  init(Olist& list);
bool appendList(Olist& list, struct STAR ele);
bool deleteList(Olist& list, int position);
void destroyList(Olist& list);
#endif
  • star.cpp
#include "star.h"
#include <iostream>

using namespace std;



void listPrint(Olist& list) {
	cout << "\n顺序表元素个数" << list.elemNum << ", 顺序表空间:" << list.size << endl;
}

bool  init(Olist& list) {
	//初始是没有元素的，为首地址元素分配空间其实就是为顺序表分配空间
	list.elems = new struct STAR[STAR_MAX_NUM];
	if (!list.elems) {
		return false;
	}
	list.elemNum = 0;
	list.size = STAR_MAX_NUM;
	return true;
}

bool appendList(Olist& list, struct STAR ele) {
	if (list.elemNum == list.size) {
		cout << "顺序表已经满了，不能再插入" << endl;
		return false;
	}
	list.elems[list.elemNum] = ele;   //能这样做是因为地址是连续的
	list.elemNum++;
	return true;
}

bool deleteList(Olist& list, int position)
{
	if (list.elemNum == 0 || position < 0 || position >= list.elemNum) {
		cout << "删除位置不合法" << endl;
		return false;
	}

	for (int i = position; i < list.elemNum - 1; i++) {
		list.elems[i] = list.elems[i + 1];
	}
	list.elemNum--;
	return true;
}

void destroyList(Olist& list) {
	if (list.elems) delete[] list.elems;

	list.size = 0;
	list.elemNum = 0;
}
  • mian
#include <iostream>
#include <exception>
#include <stdexcept>
#include "string"
#include <fstream>
#include<conio.h>
#include<Windows.h>
#include <graphics.h>
#include "star.h"


void initStar(struct STAR &star) {
	//初始化星星
	star.x = rand() % SCREEN_WIDTH;
	star.y = rand() % (SCREEN_HEIGHT - IMG_SIZE);
	star.step = rand() % MAX_STEP + 1;
	int rgb = 0;
	rgb = rand() % 255;
	star.color = RGB(rgb, rgb, rgb);
	star.radius = rand() % MAX_STAR_RADIUS;

	setfillcolor(star.color);
	solidcircle(star.x, star.y, star.radius);

	star.alive = true;
}


void eraseStar(Olist& list, int i) {
	for (int i = 0; i < list.elemNum; i++) {
		//擦除原来的星星
		setfillcolor(BLACK);
		solidcircle(list.elems[i].x, list.elems[i].y, list.elems[i].radius);

		if (list.elems[i].alive && (list.elems[i].y - list.elems[i].step) > 0) {
			list.elems[i].y = list.elems[i].y - list.elems[i].step;
			setfillcolor(list.elems[i].color);
			solidcircle(list.elems[i].x, list.elems[i].y, list.elems[i].radius);
		}
		else {
			list.elems[i].alive = false;
			deleteList(list,i);
		}
	}
}

int main() {
	initgraph(SCREEN_WIDTH, SCREEN_HEIGHT);

	IMAGE bg_img;
	loadimage(&bg_img, _T("y3.png"), IMG_SIZE, IMG_SIZE, true);
	putimage(int(SCREEN_WIDTH * 0.3), SCREEN_HEIGHT - IMG_SIZE, &bg_img);
	putimage(int(SCREEN_WIDTH * 0.7), SCREEN_HEIGHT - IMG_SIZE, &bg_img);

	Olist starList;  //初始化一个顺序表，对应是首地址，存放第一颗星星
	struct STAR star;

	init(starList);


	//绘制星星
	for (int i = 0; i < STAR_MAX_NUM; i++) {
		initStar(star);
		appendList(starList, star);
	}

	//消除星星,并不是直接擦除，是以一定的步长走出画面的
	int i = 0;
	while(starList.elemNum) {
		for (int i = 0; i < starList.elemNum; i++) {
			eraseStar(starList,i);
		}
		Sleep(200);
	}

	system("pause");
	return 0;
}

1.4 企业应用案例：顺序表管理并剔除超时连接。

在这里插入图片描述

  • connect.h
#pragma once
#ifndef _CONNECT_H_
#define _CONNECT_H_

#define SCREEN_WIDTH 654
#define SCREEN_HEIGHT 480
#define STAR_MAX_NUM 10
#define MAX_STEP 2
#define MAX_STAR_RADIUS 3
#define BOTTOM_MARGIN 100
#define IMG_SIZE 50

struct ConnectOut {
	int fd;  
	unsigned int timeout;
};

//定义顺序表，存储多个超时连接
typedef struct _OrderList Olist;   //定义结构体的别名
struct _OrderList {
	struct ConnectOut* elems;  //顺序表的首地址
	int elemNum;           //表里的元素个数
	int size;            //顺序表分配的空间，也就是连续内存的大小
};

void listPrint(Olist& list);
bool  init(Olist& list);
bool appendList(Olist& list, struct ConnectOut ele);
bool deleteList(Olist& list, int position);
void destroyList(Olist& list);
#endif
  • connect.cpp
#include "connect.h"
#include <iostream>

using namespace std;

void listPrint(Olist& list) {
	cout << "\n顺序表元素个数" << list.elemNum << ", 顺序表空间:" << list.size << endl;
	for (int i = 0; i < list.elemNum; i++) {
		cout << "[" << list.elems[i].fd << "] = " << list.elems[i].timeout << endl;
	}
}

bool  init(Olist& list) {
	//初始是没有元素的，为首地址元素分配空间其实就是为顺序表分配空间
	list.elems = new struct ConnectOut[STAR_MAX_NUM];
	if (!list.elems) {
		return false;
	}
	list.elemNum = 0;
	list.size = STAR_MAX_NUM;
	return true;
}

bool appendList(Olist& list, struct ConnectOut ele) {
	if (list.elemNum == list.size) {
		cout << "顺序表已经满了，不能再插入" << endl;
		return false;
	}
	list.elems[list.elemNum] = ele;   //能这样做是因为地址是连续的
	list.elemNum++;
	return true;
}

bool deleteList(Olist& list, int position)
{
	if (list.elemNum == 0 || position < 0 || position >= list.elemNum) {
		cout << "删除位置不合法" << endl;
		return false;
	}

	for (int i = position; i < list.elemNum - 1; i++) {
		list.elems[i] = list.elems[i + 1];
	}
	list.elemNum--;
	return true;
}

void destroyList(Olist& list) {
	if (list.elems) delete[] list.elems;

	list.size = 0;
	list.elemNum = 0;
}


#include <iostream>
#include <exception>
#include <stdexcept>
#include "string"
#include <fstream>
#include<conio.h>
#include<Windows.h>
#include <graphics.h>
#include "connect.h"
#include <time.h>

using namespace std;
void checkConnectOut(Olist &list, time_t now);

int main() {
	time_t now, end, last_timeout;
	time(&now);
	end = now + 60;
	last_timeout = now;

	Olist list;
	struct ConnectOut ConOut;

	init(list);

	//随机模拟超时
	for (int i = 0; i < 10; i++) {
		ConOut.fd = i;
		ConOut.timeout = now + 5 + 2 * i;
		appendList(list, ConOut);
	}
	listPrint(list);


	do{
		//cout << "last_timeout = " << last_timeout << ", now =  " << now << endl;
		//每隔一秒检查一次是否有超时,说明上一次到现在已经过去1秒了
		if (last_timeout + 0.999 < now) {
			checkConnectOut(list, now);
			last_timeout = now;
		}
		time(&now);
	} while (now < end); //检查指定时间内的超时连接

	destroyList(list);

	Sleep(10);
	system("pause");
	return 0;
}

void checkConnectOut(Olist& list, time_t now) {
	cout << "超时检查。。。。。\n";
	for (int i = 0; i < list.elemNum; i++) {
		if (list.elems[i].timeout > now) {
			continue; // 直接进入下一次循环
		}

		cout << "[" << list.elems[i].fd << "] 超时，已关闭..." << endl;
		deleteList(list, i);
		i--;
	}
}

二 单链表：可以让删除和插入元素时，尽可能地移动较少的数据

  • 顺序表存在的问题：如果数据太多，删除或移动靠前的数据，后面的所有的数据都需要移动
  • LinkList用于表示首节点，LinkNode用于表示其余的节点
  • 链表的核心理解：每个节点本身就占据一个地址，同时地址内存存了下一个节点的地址
    在这里插入图片描述
    在这里插入图片描述
  • 单链表头节点一般不存数据，指针指向下一个元素，尾节点指针为NULL，链表只能通过上一个节点才能知道下一个节点，不像顺序表，顺序表可以根据索引直接推断出元素位置
    在这里插入图片描述

2.1 头插法和尾插法，头插法，先进入的存在最后面，尾插入法，先进入的存在最里面

在这里插入图片描述
在这里插入图片描述

2.1.1 为什么传递链表的时候，传递的是LinkList*&，传递指针本身已经能修改内容了：主要是为了在函数内部能够 修改指针本身的值list = new LinkList;，而不仅仅是修改指针指向的内容。其他插入打印等函数可以只使用指针而不使用指针的引用

void init(LinkList* &list) {	
	list = new LinkList;
	if (!list)
	{
		cout << "初始化内存分配失败" << endl;
		return;
	}
	list->data = -1;
	list->next = NULL;
}

```3
1

```bash
void init(LinkList* list) {
    list = new LinkList;   修改的是局部副本，外部指针不变
    list->next = nullptr;
}

int main() {
    LinkList* myList = nullptr;
    init(myList);   myList 仍然是 nullptr，没有被初始化！
    // ...
}

2.1.2 主函数里面，LinkList* list = NULL;只是初始化头节点为空指针，在插入的时候，没插入一个数据，都需要node = new LinkNode;分配新的内存空间来存放数据

int main() {
	LinkList* list = NULL;
	LinkNode* node = NULL;
	init(list);

	int num;
	int number;
	cout << "请输入要插入的数据个数:";
	cin >> num;

	cout << " ------------ 头插法---------" << endl;
	for (int i = 0; i < num; i++) {
		node = new LinkNode;
		cout << "请输入第" << i+1 << "个元素:";
		cin >> node->data;
		insert_head(list, node);
	}
	printList(list);

2.2 任意位置插入元素

//p = list->next;  1 3 5 ,在第2个位置插入4 ，将会变成1 3 4 5
	p = list;   1 3 5 ,在第2个位置插入4 ，将会变成1 4 3 5

bool insert(LinkList*& list, LinkNode* node, int pos) {
	LinkNode* p = NULL;

	//p = list->next;
	p = list;

	int counter = 0;
	//循环遍历找到pos位置的节点
	while (p && counter < pos-1) {
		p = p->next;
		counter++;
	};

	//索引超出有效范围
	if (!p || counter > pos - 1) {
		cout << "插入位置超出有效范围" << endl;
		return false;
	}

	node->next = p->next;
	p->next = node;
	return true;
}

2.3 获取指定位置的元素

2.3.1 为什么下列调用，只有在函数里面能正确打印node的值，在主函数里面无法正确打印，而其他函数形参也是LinkNode* node，却能实现数据插入链表bool insert(LinkList*& list, LinkNode* node, int pos)。和前面的原因一样，因为bool getElem(LinkList*& list, int pos, LinkNode* node)函数在函数内部对指针本身进行了修改， node = p->next;，而insert函数内部只是修改 node->next = p->next; p->next = node;指针指向的值，而没有修改指针本身，要修改指针本身，就需要传递指针的引用 ，或者下面的方式

- 简单来说：函数形参传递指针，函数内部只能修改指针指向的值，而无法修改指针本身的地址，正确用法bool getElem(LinkList*& list, int pos, LinkNode* &node)

在这里插入图片描述
在这里插入图片描述

--------------------------主函数---------------------------
	cout << " ------------ 取指定位置元素---------" << endl;
	int pos;
	while (1) {
		node = new LinkNode;
		cout << "请输入要取的元素的位置";
		cin >> pos ;
		getElem(list, pos, node);
		printList(list);
		//cout << "位置" << pos << "处的元素是" << node->data << endl;
	}

bool getElem(LinkList*& list, int pos, LinkNode* node) {
	if (!list || !list->next) {
		return false;
	}

	LinkNode* p = NULL;
	int counter = 1;
	p = list;

	while (p && counter < pos) {
		p = p->next;
		counter++;
	}

	//索引超出有效范围
	if (!p || counter > pos) {
		cout << "选取元素位置超出有效范围" << endl;
		return false;
	}

	node = p->next;
	return true;

}

2.4 完整程序

#include <iostream>
#include <exception>
#include <stdexcept>
#include "string"
#include <fstream>
#include<conio.h>
#include<Windows.h>
#include <graphics.h>
#include <time.h>

using namespace std;

typedef struct LinkNode {
	int data;
	struct LinkNode* next; //指向下一个节点的指针
}LinkList,LinkNode;  //LinkList表示初始节点

void init(LinkList*& list);
bool insert_head(LinkList*& list, LinkNode* node);
bool insert_end(LinkList*& list, LinkNode* node);
bool insert(LinkList*& list, LinkNode* node, int pos);
void printList(LinkList*& list);
bool getElem(LinkList*& list,int pos, LinkNode* &node);  //链表，取第几个元素，将值给node传出来
bool findElem(LinkList*& list, int elem, int &index);  //按值查找，链表，查找元素
bool deleteElem(LinkList*& list,int pos);
void LinkDestroy(LinkList*& list);

int main() {
	LinkList* list = NULL;
	LinkNode* node = NULL;
	init(list);

	int num;
	int number;
	cout << "请输入要插入的数据个数:";
	cin >> num;

	cout << " ------------ 头插法---------" << endl;
	for (int i = 0; i < num; i++) {
		node = new LinkNode;
		cout << "请输入第" << i+1 << "个元素:";
		cin >> node->data;
		insert_head(list, node);
	}
	printList(list);

	cout << " ------------ 尾插法---------" << endl;
	for (int i = 0; i < num; i++) {
		node = new LinkNode;
		cout << "请输入第" << i + 1 << "个元素:";
		cin >> node->data;
		insert_end(list, node);
	}
	printList(list);


	cout << " ------------ 指定位置插入---------" << endl;
	int pos;
	while (1) {
		node = new LinkNode;
		cout << "请输入要插入的位置和数据";
		cin >> pos >> node->data;
		insert(list, node, pos);
		printList(list);
	}


	cout << " ------------ 取指定位置元素---------" << endl;
	int pos;
	while (1) {
		node = new LinkNode;
		cout << "请输入要取的元素的位置";
		cin >> pos ;
		getElem(list, pos, node);
		printList(list);
		cout << "位置" << pos << "处的元素是" << node->data << endl;
	}

	cout << " ------------ 按值查元素，并返回位置---------" << endl;
	int value, index;
	while (1) {
		node = new LinkNode;
		cout << "请输入要查找的元素";
		cin >> value;
		printList(list);
		if (findElem(list, value, index)) {
			cout << value << "位置" << index << endl;
		}
		else {
			cout << "元素不存在" << endl;
		}
	}

	cout << " ------------ 删除元素---------" << endl;
	int index;
	while (1) {
		node = new LinkNode;
		cout << "请输入要删除的元素位置";
		cin >> index;
		printList(list);
		if (deleteElem(list, index)) {
			cout << index << "位置删除成公"  << endl;
			printList(list);
		}
		else {
			cout << "元素不存在" << endl;
		}
	}

	LinkDestroy(list);
	printList(list);
	system("pause");
	return 0;
}

bool deleteElem(LinkList*& list, int pos) {
	if (!list || !list->next) {
		cout << "链表为空" << endl;
		return false;
	}

	LinkNode* p = NULL;
	p = list;

	int counter = 0;
	while (p && counter < pos-1) {
		
		p = p->next;
		cout << p->data << " ";
		counter++;
	}

	if (!p || counter > pos-1) {
		cout << "删除位置不合法" << endl;
		return false;
	}

	LinkNode* temp = NULL;  //用来存要删除的节点，最后要将其delete,因为在主函数里面是通过new建立的链表
	temp = p->next;
	p->next = temp->next;
	delete temp;
	return true;
}

void LinkDestroy(LinkList*& L) {

	LinkNode* temp = NULL; //用于存放即将删除的节点
	temp = L;

	while (L) {
		L = L->next;
		delete temp;
		temp = L;
	}
}

bool findElem(LinkList*& list, int elem, int& index) {
	if (!list || !list->next) {
		index = -1;
		return false;
	}

	LinkNode* p = NULL;
	int counter = 1;
	p = list->next;

	while (p && p->data != elem) {
		p = p->next;
		counter++;
	}

	if (!p) {
		return false;
	}
	index = counter;
	return true;
}


bool getElem(LinkList*& list, int pos, LinkNode* &node) {
	if (!list || !list->next) {
		return false;
	}

	LinkNode* p = NULL;
	int counter = 1;
	p = list;

	while (p && counter < pos) {
		p = p->next;
		counter++;
	}

	//索引超出有效范围
	if (!p || counter > pos) {
		cout << "选取元素位置超出有效范围" << endl;
		return false;
	}

	node = p->next;
	return true;

}


void init(LinkList*& list) {	
	list = new LinkList;
	if (!list)
	{
		cout << "初始化内存分配失败" << endl;
		return;
	}
	list->data = -1;
	list->next = NULL;
}

bool insert_head(LinkList*& list, LinkNode* node) {
	if (!list || !node) {
		cout << "内存分配失败" << endl;
		return false;
	}
	node->next = list->next;
	list->next = node;

	return true;
}

void printList(LinkList*& list) {

	LinkNode* p = NULL;

	if (!list) {
		cout << "链表为空" << endl;
		return;
	}

	p = list->next;

	do {
		cout << p->data << " ";
		p = p->next;
	}while(p);
	cout << endl;
}

bool insert_end(LinkList*& list, LinkNode* node) {
	if (!list || !node) {
		cout << "内存分配失败" << endl;
		return false;
	}

	LinkNode* p = NULL;
	p = list->next;

	while(p->next) {
		p = p->next;
	};

	node->next = NULL;
	p->next = node;

	return true;
}


bool insert(LinkList*& list, LinkNode* node, int pos) {
	LinkNode* p = NULL;

	//p = list->next;
	p = list;

	int counter = 0;
	//循环遍历找到pos位置的节点
	while (p && counter < pos-1) {
		p = p->next;
		counter++;
	};

	//索引超出有效范围
	if (!p || counter > pos - 1) {
		cout << "插入位置超出有效范围" << endl;
		return false;
	}

	node->next = p->next;
	p->next = node;
	return true;
}
数据结构与算法-单链表篇
kwenzh的博客
04-18 1万+
        在数据结构中，链表可能是程序员会建立的最简单的数据结构。也是非常基础的一种数据结构，往往简单的东西越需要扎实，大多数的情况是眼高手低觉得很简单差不多，一写代码就出错，一运行就崩溃，完成链表这一数据结构主要在于对指针的使用。         链表是一种线性的数据结构，相比静态申请数组空间必须要给定长度，链表更加长灵活，如果数据的个数会随着时间变化而增加或者减少，链表是一种很好的存储...
数据结构与算法-顺序表（链表篇）
09-09
在IT领域，数据结构与算法是编程基础的重要组成部分，它们直接影响到程序的效率和设计质量。本主题聚焦于“顺序表”中的“链表”部分，这是一个基础且至关重要的概念，广泛应用于各种软件系统。 链表是一种线性数据...
数据结构---顺序表，链表
includeevey的博客
08-03 2809
2w字带你走进链表
数据结构与算法-线性表-单链表（Linked List）
晴空闲云
05-15 921
单链表是一种动态数据结构，通过节点存储数据和指向下一个节点的指针来实现。与顺序表相比，单链表在插入和删除操作上更为高效，但无法随机访问元素。单链表的基本操作包括初始化、创建（头插法和尾插法）、获取元素、插入、删除、计算长度、判断是否为空、清空和销毁链表。初始化操作的时间复杂度为O(1)，而创建链表和获取元素的操作时间复杂度为O(n)。单链表的实现需要定义节点结构，并通过指针操作进行链表的构建和遍历。
数据结构与算法-重点复习总结
小熊Xavier
12-20 2126
数据结构与算法期末复习重点总结（待修改）
数据结构---顺序表---单链表
m0_65301172的博客
08-27 1052
程序 = 数据结构 + 算法这里以int为例子顺序表和链表的区别很明显，链表空间地址不是连续的，顺序表空间地址是连续的；链表需要的空间大，但是理论上可以存储无限数据，而顺序表需要空间较小，存储的元素个数有限；顺序表访问元素比链表方便。
数据结构与算法---单向链表
weixin_73602725的博客
03-01 1904
单向链表的详细讲解（附完整版）
数据结构和算法-5.1-单链表&有序链表
o118abcdef的博客
01-29 926
定义 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的； 链表由多个链结点组成，每个链结点由两部分组成，一个存储数据元素的数据域，一个存储下一个结点地址的指针域； 在链表中，寻找一个特定元素的唯一方法，就是沿着这个元素的链一直向下寻找； 解决的问题 无序数组搜索慢，有序数组插入慢，且数组的删除效率低，大小固定； 链表则常用来替换数组，作为其他存储结构的基础，以解决上面问题； 除非需要频繁的用下标随机访问各个数据，否则很多地方都可以用链表代替数组。
数据结构与算法-抽象数据类型ADT系列
nameofworld的博客
04-29 518
以前在学习数据结构的时候做实验，老师要求用来写这些实现代码。不过以前学习的时候使用的编程语言是，里面会用到很多指针。现在编代码过程大多数时候都是用Java。不过思路应该还是可以参考一下的。二叉树：前序、中序、后序遍历。哈夫曼树。图。链表。栈。队列。邻接矩阵。邻接表。
【数据结构】线性表-顺序表和单链表
weixin_58052073的博客
07-12 1731
本文用c++实现了线性表和单链表的数据结构及操作
Java数据结构与算法--单链表(Linked List)
当一个合格的软件工程师
10-04 2315
1.1 链表(Linked List)介绍 小结上图： 链表是以节点的方式来存储，是链式存储。 每个节点包含 data 域， next 域：指向下一个节点。 如图：发现链表的各个节点不一定是连续存储。 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。 1.2 单链表介绍 单链表(带头结点) 逻辑结构示意图如下： 1.2.1 单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作。 第一种方法在添加英雄时，直接添加到链表的尾部 思路分析示意图
数据结构与算法----线性表及Java实现顺序表、链表、栈、队列 定义线性表节点的结构.pdf
04-18
数据结构与算法是程序设计的两大基础，大型的IT企业面试时也会出数据结构和算法的题目，它可以说明你是否有良好的逻辑思维，如果你具备良好的逻辑思维，即使技术存在某些缺陷，面试公司也会认为你很有培养价值，至少...
数据结构与算法-实验二单链表
11-19
单链表是一种基础的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在单链表中，数据的存取...同时，这也是对数据结构与算法基础理论的实践应用，对于提升编程能力和算法思维能力大有裨益。
西安电子科技大学-数据结构与算法-期末知识点总结.pdf
01-05
"西安电子科技大学-数据结构与算法-期末知识点...本资源涵盖了数据结构与算法的基本概念、线性表、栈与队列、树与二叉树、图、查找算法和排序算法等方面的知识点，对于学习数据结构与算法的学生具有重要的参考价值。
基因工程的操作工具和操作程序练习题.doc
08-04
基因工程的操作工具和操作程序练习题.doc
SIEMENS数控车床编程实例PPT.ppt
08-04
SIEMENS数控车床编程实例PPT.ppt
网站安全管理制度.doc
08-04
网站安全管理制度.doc
惠普HP LaserJet M1005 MFP打印机驱动程序
最新发布
08-04
惠普 HP LaserJet M1005 MFP 是一款面向中小企业和 SOHO 办公场景的黑白激光多功能一体机，集打印、复印、扫描三项核心功能于一体。具体功能如下： 打印功能：采用黑白激光打印技术，打印速度为 15ppm（Letter）/14ppm（A4），打印分辨率为 600×600dpi，借助 HP 分辨率增强技术（REt）和 FastRes 1200 技术，可实现高达 FastRes 1200dpi 的打印质量。支持手动双面打印，月打印负荷为 5000 页，标配 150 页进纸盒和 10 页优先进纸插槽，可打印 A4 幅面以下多种尺寸纸张，如 A5、B5 等，也可打印信封、明信片等介质。 复印功能：复印速度与打印速度相同，为 15ppm（Letter）/14ppm（A4），复印分辨率为 600×600dpi，支持 25%-400% 缩放复印，最大复印页数可达 99 份，还可设置复印数量、明暗度等参数。 扫描功能：采用平板式扫描平台和 CIS 扫描元件，光学分辨率高达 1200×1200dpi，增强分辨率可达 19200dpi，灰度级为 256，支持 JPEG、TIFF、PDF 等多种文件格式输出，方便用户根据需求选择。 其他功能：配备 Hi - Speed USB 2.0 端口，方便与电脑等设备连接。具备 “0 秒预热技术”，可缩短首页输出时间，降低功耗，延长打印寿命。支持 N-up 打印（即在一张纸上打印多页内容）和 EconoMode 省墨模式，可节省纸张和耗材。
数据结构与算法-线性表深度解析：顺序表与链表
"《数据结构与算法》-数据结构C++，主要讲解了线性表的概念、抽象数据类型定义以及不同的存储实现，包括顺序表和单链表，同时涉及线性表的其他存储结构，如双链表。本章重点讨论了顺序存储结构和链接存储结构的思想...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值