C/C++、JAVA 数据结构 ：双向循环链表

最新推荐文章于 2023-10-02 20:41:16 发布
最新推荐文章于 2023-10-02 20:41:16 发布
阅读量510 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xielinhua88/article/details/51498495
版权

 不管是什么语言大致都一样的 ，先来看看用C来实现：

linkenList.h

 

#ifndef _LINKED_LIST
#define _LINKED_LIST

typedef void Tem;

typedef struct No {
	struct Node* next;
	struct Node* pre;
	Tem* data;
}Node;

typedef struct _No {
	struct Node* head;
	int len;
} LinkedList;

LinkedList*  initLinked();
int addFirst(LinkedList* list, Tem* t);
int addEnd(LinkedList* list,Tem* t);
int add(LinkedList* list, Tem* t,int pos);
Node* getNode(LinkedList* list,int pos);
int getLen(LinkedList* list);
int remove(LinkedList* list,int pos);
int destory(LinkedList* list);
#endif


#include "linkenList.h"
#include<stdlib.h>

LinkedList*  initLinked() {
	LinkedList* list = (LinkedList*)malloc(sizeof(LinkedList));//分配内存
	list->len = 0;
	return list;
}
/*在头部加入元素*/
int addFirst(LinkedList* list, Tem* t) {//在头部加入
	if (list == NULL || t==NULL)
	{
		return -1;
	}
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->data = t;
	newNode->next = NULL;
	if (list->len==NULL) {
		list->head = newNode;
		newNode->pre = NULL;
	}
	else {
		newNode->next = list-> head;
		Node* head=list->head;
		head->pre = newNode;
		list->head = newNode;
	}
	list->len++;
	Node* last = getNode(list, getLen(list) - 1);
	last->next = list->head;//让最后一个元素的下一个节点指向头节点形成循环
	return 0;
}

/*在尾部加入元素*/
int addEnd(LinkedList* list,Tem* t) {
	if (list == NULL || t==NULL)
	{
		return -1;
	}
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->data = t;
	newNode->next = NULL;
	newNode->pre = NULL;
	if (list->len == 0) {
		list->head = newNode;
	}
	else {
		Node* temp = list-> head;
		int i =1;
		while (temp&&i<list->len) {
			temp = temp->next;
			i++;
		}
		newNode->pre = temp;//改变新加入的上一个指针的指向
		temp->next = newNode;
		newNode->next = list->head;//让新加入的节点指向头结点
	}
	list->len++;
	return 0;
}
/*在指定位置加入元素*/
int add(LinkedList* list, Tem* t, int pos) {
	if (list == NULL || pos<0||t==NULL)
	{
		return -1;
	}
	if (pos==0) {
		addFirst(list,t);
	}
	else if(pos>=list->len){
		addEnd(list, t);
	}
	else {
		Node *newNode = (Node*)malloc(sizeof(Node));
		newNode->data = t;
		Node *p = list->head;
		int i = 1;
		while (p&&i<pos) {
			p = p->next;
			i++;
		}
		newNode->pre = p;//改变新加入的上一个指针的指向
		newNode->next = p->next;
		p->next=newNode;
		list->len++;
	}

	return 0;
}
/*获取指定位置元素*/
Node* getNode(LinkedList* list, int pos) {
	if (list == NULL || pos<0)
	{
		return -1;
	}
	Node* p = list->head;
	int i = 0;
	for (i = 0; i < pos;i++) {
		p = p->next;
	}
	return p;
}
/*获取链表长度*/
int getLen(LinkedList* list) {
	if (list == NULL)
	{
		return -1;
	}
	return list->len;
}
/*删除指定位置元素*/
int remove(LinkedList* list, int pos) {
	if (list==NULL||pos<0)
	{
		return -1;
	}


	Node *temp;
	if (pos == 0) {
		temp=list->head;
		list->head = temp->next;
	}
	else {
		Node *p = list->head;

		int i = 1;
		while (p&&i < pos) {
			p = p->next;
			i++;
		}
		temp = p->next;
		p->next = temp->next;
		free(temp);//释放要删除的内存
	}
	list->len--;
	return 0;
}
/*销毁链表*/
int destory(LinkedList* list) {
	if (list == NULL) {
		return -1;
	}
	free(list);
	return 0;
}

测试文件 


#include<stdlib.h>
#include<stdio.h>
#include"linkenList.h"

void main() {
	LinkedList* list=initLinked();
	add(list,21,0);
	add(list, 22,0);
	add(list, 23, 0);
	int len=getLen(list);
	int i = 0;
	for (int i = 0; i < len*4;i++) {
	Node* node=getNode(list,i);
	printf("%d\n",node->data);
	}
	remove(list, 1);
	printf("====================\n");
	for (int i = 0; i < getLen(list); i++) {
		Node* node = getNode(list, i);
		printf("%d\n", node->data);
	}
	destory(list);
	system("pause");
}

再来看看用java来实现

package com.xielinhua.link;

public class LinkedList<T> {
	private Node<T> head = null;// 头节点

	private int len;

	@SuppressWarnings("hiding")
	public class Node<T> {
		public T data;// 数据
		public Node<T> next;// 下一个节点
		public Node<T> pre;// 上一个节点
	}

	/**
	 * 在头部加入
	 * 
	 * @param t
	 * @return
	 */
	public boolean addFirst(T t) {
		Node<T> p = new Node<T>();
		p.data = t;
		p.pre = null;// 由于是在头部加入所以新加入的节点的上一个节点都为NULL
		if (head == null) {
			head = p;
		} else {
			head.pre = p;// 动态将原始的头节点的上一个节点指向新的节点
			p.next = head;
			head = p;
		}
		len++;
		Node<T> last = getNode(len - 1);// 获取最后一个元素的节点 然后让他的下一个节点指向头部 形成循环
		last.next = head;
		return true;
	}

	public Node<T> getNode(int index) {
		Node<T> p = head;
		for (int i = 0; i < index; i++) {
			p = p.next;
		}
		return p;
	}

	public int getLen() {

		return len;
	}

	/**
	 * 在尾部加入
	 * 
	 * @param t
	 * @return
	 */
	public boolean add(T t) {
		Node<T> p = new Node<T>();
		p.data = t;
		if (head == null) {
			head = p;
		} else {
			Node<T> current = head;
			int i = 1;
			while (current.next != null && i < len) {
				current = current.next;
				i++;
			}
			p.pre = current;// 动态改变将要插入的上一个节点指向
			current.next = p;
		}
		p.next = head;// 让他的下一个节点指向头部 形成循环
		len++;
		return true;
	}

	/**
	 * 在指定位置加入
	 * 
	 * @param t
	 * @param index
	 * @return
	 */
	public boolean add(T t, int index) {
		if (index >= len) {
			add(t);
		} else {
			if (index == 0) {
				addFirst(t);
			} else {
				Node<T> newNode = new Node<T>();
				newNode.data = t;
				newNode.next = null;
				Node<T> p = head;
				int i = 1;
				while (p.next != null && i < index) {
					p = p.next;
					i++;
				}
				newNode.pre = p;// 动态改变将要插入的上一个节点指向
				newNode.next = p.next;
				p.next = newNode;
				len++;
				Node<T> last = getNode(len - 1);
				last.next = head;
				return true;
			}

		}

		return false;
	}

	/**
	 * 删除指定位置的元素
	 * 
	 * @param index
	 * @return
	 */
	public boolean remove(int index) {
		if (index == 0) {
			head = head.next;
		} else {
			Node<T> p = head;
			Node<T> tmp;
			int i = 1;

			while (p.next != null && i < index) {
				p = p.next;
				i++;
			}
			tmp = p.next;
			p.next = tmp.next;
		}
		len--;
		return true;
	}

}


package com.xielinhua.link;

public class Test {

	public static void main(String[] args) {
		LinkedList<Integer> list = new LinkedList<>();
		list.add(12, 0);
		list.add(13, 0);
		list.add(14, 0);
		list.add(15, 0);

		for (int i = 0; i < list.getLen() * 2; i++) {

			System.out.println("数据==" + list.getNode(i).data);
		}
		System.out.println("===============");
		list.remove(1);
		for (int i = 0; i < list.getLen(); i++) {

			System.out.println("数据2==" + list.getNode(i).data);
		}

	}

}



最后来看看C++的实现： 



#pragma once
template<typename T>
 struct Node {
	Node* next;
	T data;
};


 template<typename T>
class linkedList2
{
	
public:
	linkedList2();
	~linkedList2();
	bool add(T &t);
	bool add(T &t,int pos);
	bool addFirst(T &t);
	Node<T>* getNode(int pos);
	int getLen();
	bool remove(int pos);
private:
	Node<T> *head;
	int len;
};



#include "linkedList2.h"


template<typename T>
linkedList2<T>::linkedList2()
{
	head =nullptr;
	len =0;
}

template<typename T>
linkedList2<T>::~linkedList2()
{
	
}

template<typename T>
Node<T>* linkedList2<T>::getNode(int index)//获取指定位置的元素
{
	Node<T> *p = head;
	for (int i = 0; i < index;i++) {
		p = p->next;
	}
	return p;
}
template<typename T>
bool linkedList2<T>::add(T & t)//在尾部加入
{
	Node<T> *newNode = new Node<T>();
	newNode->data = t;
	newNode->next = head;
	if (head==nullptr)
	{
		head = newNode;
	}
	else {
		Node<T> *p = head;
		int i = 1;
		while (p&&i<len) {
			p = p->next;
			i++;
		}
		p->next = newNode;
	}

	len++;

	return true;
}

template<typename T>
bool linkedList2<T>::addFirst(T & t)//在头部加入
{
	Node<T> *newNode = new Node<T>();
	newNode->data = t;
	
	if (head ==nullptr)
	{
		head = newNode;
	}
	else {
		newNode->next = head;
		head = newNode;
	}
	newNode->next = head;
	len++;

	return false;
}



template<typename T>
bool linkedList2<T>::add(T & t, int index)//在指定位置加入
{
	if (index>=len)
	{
		add(t);
	}
	else {
		if (index==0)
		{
			addFirst(t);
		}
		else {
			Node<T> *newNode = new Node<T>();
			Node<T> *current = head;
			int i = 1;
			while (current!=nullptr&&i<index) {
				current = current->next;
				i++;
			}
			newNode->next = current->next;
			current->next = newNode;
			len++;
			Node<T> *last = getNode(len-1);
			last->next = head;
			return true;
		}
	
	}
	return false;

	
}


template<typename T>
int linkedList2<T>::getLen()//
{
	return len;
}
template<typename T>
bool linkedList2<T>::remove(int pos)//删除指定位置元素
{
	if (pos==0)
	{
		head->next = head;
	}
	else {
	Node<T> *p = head;
	Node<T> *tem;
	int i = 1;
	while (p!=nullptr&&i<pos) {
		p = p->next;
		i++;
		}
	tem = p->next;
	p->next = tem->next;
	delete tem;//释放内存
	}
	len--;
	return true;
}



xielinhua88
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
带头结点的双向循环链表数据结构
01-08
用C++和Java实现带头节点的双向循环链表，要继承linearList类，并实现它的所有功能，另外，必须实现双向迭代器。 实现带头节点的双向循环链表，要具有以下的功能： 判断表是否为空，如果为空则返回true，不空返回...
java链表之--双向循环链表
basycai的博客
07-06 4448
在单链表中，查询下一个元素的时间是O(1)。查询上一个元素的时间却是O(n)。 为了克服这种缺点，有了双向链表----继而为了更加高效-----双向循环链表 此外引用不知哪位大神的一句话：判断数据结构使用 如果你要把数据集合看成一个环，可以顺时针走，也可以逆时针走，那你就可以用双向循环链表来描述 如果你要把数据集合看成一条链，可以双向遍历，那你就可以用双向链表来描述 如果你要
C/C++数据结构：【动图演示】 单链表的结构介绍与实现
weixin_43654363的博客
05-04 904
链表是一种 物理存储结构上非连续、非顺序的存储结构，在数据存储与表示方面有着非常多的应用场景，属于C/C++数据结构基础，今天，我们通过动图来了解C/C++单链表的结构讲解与实现方法
环形链表实现队列java_数据结构：双向链表实现队列与循环链表
weixin_36399948的博客
02-27 503
一、双向链表(double linked list)是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。双向链表的基本操作与单链表基本一样，除了插入和删除的时候需要更改两个指针变量，需要注意的是修改的顺序很重要，插入如图3-14-5，删除如图3-14-6。由于引入了prev指针，insert和delete函数中都有一些特殊情况需要用特殊的代码处理，不能和一般情况用同样的代码处理，这非常不爽，...
【数据结构】线性表-循环链表（图解、c++、java）
扑腾的江鱼复习仓库
01-17 1799
URLeisure的循环链表“完美”复习资料。
数据结构： 数组与链表
最新发布
timberman666的博客
10-02 1226
数据结构： 数组与链表
【数据结构】Java 数据结构目录
01-03
【循环链表CircleList】单向循环链表、双向循环链表以及约瑟夫环问题 【队列Queue】队列 Queue、双端队列 DeQueue、循环队列 CircleQueue、双端循环队列 CircleDeque 源码实现（Java） 【栈Stack】栈 Stack 源码 ...
18.双向链表.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
C++实现 数据结构与算法视频教程 01交换算法 02冒泡排序 03选择排序 04顺序排序 05折半排序 06递归算法 07递归折半查找 08算法_perm 09插入排序 10快速排序 11归并排序 12顺序栈 13顺序队列 14链表的基本概率 15...
Java单链表源码分析-ds-algos:ds-算法
06-05
Javascript、Python、C#、C++、C 等的学生也可以毫无困难地学习概念。 各种算法和数据结构的实现已经通过动画幻灯片进行了演示和实现。 它涵盖了许多关于算法和数据结构的面试室问题。 问题和解决方案由- 动画幻灯片...
超级有影响力霸气的Java面试题大全文档
07-18
引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始...
C 结构体嵌套一级指针 二级指针 动态分配内存
xielinhua88的博客
05-10 4130
#define _CRT_SECURE_NO_WARNINGS #include #include #include //结构体嵌套一级指针 二级指针 动态分配内存 typedef struct _Teacher { int age; int id; char *title; char **pStuarray; char name[64]; }Teacher; //打印结构体 v
C语言中 strchr() strncpy()的用法 以及根据某个字符切割字符串
xielinhua88的博客
05-10 3270
#define _CRT_SECURE_NO_WARNINGS #include #include #include //strchr() strncpy()的用法 以及根据某个字符切割字符串 int splitString(char* p1, char c, char buffer[10][30], int *count) { char* p = NULL, *pTmp = NULL;
C/C++,java 数据结构---线性链表存储数据:获取数据慢，增删快
xielinhua88的博客
05-19 688
LinkList.h#ifndef _LINK_LIST #define _LINK_LIST typedef void LinkList; typedef struct _linklist { struct _linklist* next; }LinkListNode; LinkList* create(); int insert(LinkList* list,LinkListNode*
C++拷贝构造函数的调用时机，如没有重载等号操作符，需重写使用深拷贝
xielinhua88的博客
05-10 659
#define _CRT_SECURE_NO_WARNINGS #include using namespace std; /**拷贝构造函数 调用时机：（以下会调用copy） Test t1; Test t2=t1;//如果没有重载=操作符， Test t1(t2); void function(t1);//t1实参初始化形参 ，形参是一个元素 Test function(){ //函数的返
C/C++ 数据结构---线性顺序存储数据:查询快，增删慢
xielinhua88的博客
05-16 603
顺序存储结构       顺序存储结构其主要使用的是数组来存储数据的， 所以它的特点是：查询快，增删慢！  为什么增删慢呢？由于增删需要把插入的位置元素后移或者前移 所以效率就要慢了！当然如果是插入在末尾的话 就另当别论了！ 下面来看看头文件： seqList.h #ifndef _SEQ_LIST_ #define _SEQ_LIST_ typedef void SeqList; ty
c/c++数据结构 栈和队列
xielinhua88的博客
06-11 369
栈的特性就是先进后出只能在一端操作，好多应用场合 比如浏览器的后退呀、敲代码时编辑器Ctrl+z 返回上一步呀 等等 ，队列的话是先进先出 两边操作，首先C我们用数组来实现一个栈和队列 然后C++在用链表实现栈和队列 定义一些宏变量 以便修改方便 #define ElemType int //栈元素这里使用int类型 #define MAX_SIZE 10 //初始化栈的大小
C/c++数据结构 二叉树的常用方法
xielinhua88的博客
06-12 337
#include #include #define ElemType char typedef struct binNode{ ElemType data; struct binNode *left,*right; }BinNode,*BinTree; char *arry="ab##ce##f##"; int i=0; //按照先序创建一颗树 void crea
JAVA/C 线性顺序存储结构
xielinhua88的博客
05-30 305
首先是JAVA代码： package com.xielinhua.arraylist; public class MyArrayList { private Object[] data; private int cap = 10;// 空间大小 private int newCap = 10; private int len = 0; public MyArrayList() {
C语言数据结构双向循环链表
09-27
在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值