数据结构 数据表 学习笔记

最新推荐文章于 2022-04-02 15:25:12 发布
最新推荐文章于 2022-04-02 15:25:12 发布
阅读量384 收藏 1
点赞数
分类专栏： C++ 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stone_OverLooking/article/details/104636126
版权

数据结构学习笔记
线性表
概念
全名为线性存储结构。使用线性表存储数据的方式可以这样理解，即“把所有数据用一根线儿串起来，再存储到物理空间中”
分类
将数据依次存储在连续的整块物理空间中，这种存储结构称为顺序存储结构（简称顺序表）
数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系，这种存储结构称为链式存储结构（简称链表）
顺序表
概念
顺序表对数据的物理存储结构也有要求。顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。如图
在这里插入图片描述
Tips：顺序表在申请时需要为顺序表记录两个数据。
1：顺序表申请的存储容量
2：顺序表的长度，也就是表中存储数据元素的个数
3：顺序表申请的存储容量要大于顺序表的长度
声明顺序表

typedef struct Table{
    int* head;//声明了一个名为head的长度不确定的数组，也叫“动态数组”
    int length;//记录当前顺序表的长度
    int size;	//记录顺序表分配的存储容量
}table;

Tips：
head 是我们声明的一个未初始化的动态数组，不要只把它看做是普通的指针
初始化顺序表
给链表头 head 动态数据申请足够大小的物理空间；
给 size 和 length 赋初值；

table initTable(){
table t;
//构造一个空的顺序表，动态申请存储空间
    t.head=(int*)malloc(Size*sizeof(int)); 
    if (!t.head) //如果申请失败，作出提示并直接退出程序
    {
        printf("初始化失败");
        exit(0);
    }
    t.length=0;//空表的长度初始化为0
    t.size=Size;//空表的初始存储空间为Size
    return t;
}

顺序表元素赋值

for (int i=1; i<=Size; i++) 
{
    t.head[i-1]=i;
    t.length++;
}

顺序表显示数据
//输出顺序表中元素的函数

void displayTable(table t)
{
    for (int i=0;i<t.length;i++)
    {
        printf("%d ",t.head[i]);
    }
    printf("\n");
}

顺序表插入元素
插入函数，其中，elem为插入的元素，add为插入到顺序表的位置

table addTable(table t,int elem,int add)
{
//判断插入本身是否存在问题（如果插入元素位置比整张表的长度+1还大（如果相等，是尾随的情况），或者插入的位置本身不存在，程序作为提示并自动退出）
if (add>t.length+1||add<1)
{
printf("插入位置有问题");
    return t;
 }
//做插入操作时，首先需要看顺序表是否有多余的存储空间提供给插入的元素，如果没有，需要申请
if (t.length==t.size)
{
    t.head=(int *)realloc(t.head, (t.size+1)*sizeof(int));
    if (!t.head)
    {
       printf("存储分配失败");
       return t;
    }
    t.size+=1;
} 
//插入操作，需要将从插入位置开始的后续元素，从最后面一个元素逐个后移。
for (int i=t.length-1; i>=add-1; i--)
{
    t.head[i+1]=t.head[i];
}
//后移完成后，直接将所需插入元素，添加到顺序表的相应位置
t.head[add-1]=elem;
//由于添加了元素，所以长度+1
t.length++;
return t;
}

顺序表删除元素

table delTable(table t,int add)
{
if (add>t.length || add<1) 
{
        printf("被删除元素的位置有误");
        exit(0);
    }
    //删除操作
for (int i=add; i<t.length; i++) 
{
    //找到需要删除的元素，使其后面的元素前移一位
        t.head[i-1]=t.head[i]; 
    }
    t.length--;
    return t;
}

顺序表查找元素
//查找函数，其中，elem表示要查找的数据元素的值

int selectTable(table t,int elem)
{
for (int i=0; i<t.length; i++) 
{
        if (t.head[i]==elem) 
{
            return i+1;
        }
}
//如果查找失败，返回-1
    return -1;
}

顺序表修改元素
//更改函数，其中，elem为要更改的元素，newElem为新的数据元素

table amendTable(table t,int elem,int newElem)
{
//先查找到该元素位置下标
int add=selectTable(t, elem); 
//由于返回的是元素在顺序表中的位置，所以-1就是该元素在数组中的下标
t.head[add-1]=newElem;
    return t;
}

链表
概念
链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。
在这里插入图片描述
Tips：链表中每个数据的存储都由以下两部分组成：
数据元素本身，其所在的区域称为数据域；
指向直接后继元素的指针，所在的区域称为指针域
在这里插入图片描述
一个完整的链表需要由以下几部分构成：
在这里插入图片描述
头指针：一个普通的指针，它的特点是永远指向链表第一个节点的位置。很明显，头指针用于指明链表的位置，便于后期找到链表并使用表中的数据；

节点：链表中的节点又细分为头节点、首元节点和其他节点：
头节点：其实就是一个不存任何数据的空节点，通常作为链表的第一个节点。对于链表来说，头节点不是必须的，它的作用只是为了方便解决某些实际问题；
首元节点：由于头节点（也就是空节点）的缘故，链表中称第一个存有数据的节点为首元节点。首元节点只是对链表中第一个存有数据节点的一个称谓，没有实际意义；
其他节点：链表中其他的节点
注意：链表中有头节点时，头指针指向头节点；反之，若链表中没有头节点，则头指针指向首元节点。
声明链表
typedef struct Link
{
char elem; //代表数据域
struct Link * next; //代表指针域，指向直接后继元素
}link;
//link为节点名，每个节点都是一个 link 结构体
//由于指针域中的指针要指向的也是一个节点，因此要声明为 Link 类型

创建链表

link * initLink()
{
    //创建一个头结点
link * p=(link*)malloc(sizeof(link)); 
//声明一个指针指向头结点，
link * temp=p; 
    //生成链表
for (int i=1; i<5; i++)
{
        link *a=(link*)malloc(sizeof(link));
        a->elem=i;
        a->next=NULL;
//此处temp->next其实就是head->next，temp->next此时指向的是a的地址。就是head->next指向a的地址
        temp->next=a;
//将a的地址值赋值给temp，即temp指向了节点a。
        temp=temp->next; 
    }
    return p;
}

带头节点的链表

link * initLink()
{
    //创建一个头结点
link * p=(link*)malloc(sizeof(link)); 
//声明一个指针指向头结点，
link * temp=p; 
    //生成链表
for (int i=1; i<5; i++)
{
        link *a=(link*)malloc(sizeof(link));
        a->elem=i;
        a->next=NULL;
//此处temp->next其实就是head->next，temp->next此时指向的是a的地址。就是head->next指向a的地址
        temp->next=a;
//将a的地址值赋值给temp，即temp指向了节点a。
        temp=temp->next; 
    }
    return p;
}

不带头结点的链表(带首元节点)

link * initLink()
{
    link * p=NULL;         //创建头指针
    link * temp = (link*)malloc(sizeof(link));//创建首元节点    
    temp->elem = 1;       //首元节点先初始化
    temp->next = NULL;
    p = temp;             //头指针指向首元节点
    //从第二个节点开始创建
for (int i=2; i<5; i++)
{
        //创建一个新节点并初始化
        link *a=(link*)malloc(sizeof(link));
        a->elem=i;
        a->next=NULL;
        //将temp节点与新建立的a节点建立逻辑关系
        temp->next=a;
        //指针temp每次都指向新链表的最后一个节点，
//其实就是 a节点，这里写temp=a也对
        temp=temp->next;
    }
    //返回建立的节点，只返回头指针 p即可，通过头指针即可找到整个链表
    return p;
}

链表插入数据
在这里插入图片描述
插入思想：
虽然新元素的插入位置不固定，但是链表插入元素的思想是固定的，只需做以下两步操作，即可将新元素插入到指定的位置：
将新结点的 next 指针指向插入位置后的结点；
将插入位置前结点的 next 指针指向插入结点；
//p为原链表，elem表示新数据元素，add表示新元素要插入的位置

link * insertElem(link * p,int elem,int add)
{
    link * temp=p;//创建临时结点temp
for (int i=1; i<add; i++) //首先找到要插入位置的上一个结点
{
        if (temp==NULL) {
            printf("插入位置无效\n");
            return p;
        }
        temp=temp->next;
    }   
    //创建插入结点c
    link * c=(link*)malloc(sizeof(link));
    c->elem=elem;    
    c->next=temp->next; //向链表中插入结点
    temp->next=c;
    return  p;
}

链表删除数据
//p为原链表，add为要删除元素的值

link * delElem(link * p,int add)
{
    link * temp=p;
    //temp指向被删除结点的上一个结点
for (int i=1; i<add; i++) 
{
        temp=temp->next;
}
//单独设置一个指针指向被删除结点，以防丢失
    link * del=temp->next; 
//删除某个结点的方法就是更改前一个结点的指针域    
temp->next=temp->next->next; 
    free(del);//手动释放该结点，防止内存泄漏
    return p;
}

链表查找数据
//p为原链表，elem表示被查找元素、

int selectElem(link * p,int elem)
{
//新建一个指针t，初始化为头指针 p
    link * t=p;
    int i=1;
    //由于头节点的存在，因此while中的判断为t->next
    while (t->next)
    {
        t=t->next;
        if (t->elem==elem) 
        {
             return i;
         }
        i++;
    }
    //程序执行至此处，表示查找失败
    return -1;
}

链表更新数据
//更新函数，其中，add 表示更改结点在链表中的位置，newElem 为新的数据域的值

link *amendElem(link * p,int add,int newElem)
{
link * temp=p;
//在遍历之前，temp指向首元结点
    temp=temp->next; 
    //遍历到被删除结点
for (int i=1; i<add; i++) 
{
        temp=temp->next;
    }
    temp->elem=newElem;
    return p;
}

计算链表的大小

size_t LinkListSize(LP_RECSEGMENT_INFO_V20 *head)
{
	if(head==NULL)
	{
		return 0;
	}
	LP_RECSEGMENT_INFO_V20 *cur=head;  
	size_t size=0;
	for(;*cur!=NULL;*cur=(*cur)->pNext)
	{
		size++;
	}
	if(*cur==NULL)
	{
		return 0;
	}
	return size;
}

struct Node
{
    int data ;
    Node *next ;
};
typedef struct Node Node ;

(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)

Node * ReverseList(Node *head) //链表逆序
{
    if ( head == NULL || head->next == NULL )
    return head;
    Node *p1 = head ;
    Node *p2 = p1->next ;
    Node *p3 = p2->next ;
    p1->next = NULL ;
    while ( p3 != NULL )
    {
        p2->next = p1 ;
        p1 = p2 ;
        p2 = p3 ;
        p3 = p3->next ;
    }
    p2->next = p1 ;
    head = p2 ;
    return head ;
}

(2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）

Node * Merge(Node *head1 , Node *head2)
{
    if ( head1 == NULL)
        return head2 ;
    if ( head2 == NULL)
        return head1 ;
    Node *head = NULL ;
    Node *p1 = NULL;
    Node *p2 = NULL;
    if ( head1->data < head2->data )
    {
        head = head1 ;
        p1 = head1->next;
        p2 = head2 ;
    }
    else
    {
        head = head2 ;
        p2 = head2->next ;
        p1 = head1 ;
    }
    Node *pcurrent = head ;
    while ( p1 != NULL && p2 != NULL)
    {
    if ( p1->data <= p2->data )
    {
        pcurrent->next = p1 ;
        pcurrent = p1 ;
        p1 = p1->next ;
    }
    else
    {
        pcurrent->next = p2 ;
        pcurrent = p2 ;
        p2 = p2->next ;
    }
}
if ( p1 != NULL )
    pcurrent->next = p1 ;
if ( p2 != NULL )
    pcurrent->next = p2 ;
return head ;
}

(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。(Autodesk)

Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
    return head2 ;
if ( head2 == NULL)
    return head1 ;
Node *head = NULL ;
if ( head1->data < head2->data )
{
    head = head1 ;
    head->next = MergeRecursive(head1->next,head2);
}
else
{
    head = head2 ;
    head->next = MergeRecursive(head1,head2->next);
}
return head ;
}

添加一段完整的代码块，删除兼容了删除尾结点。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;

typedef struct SwiperItemNode
{
	int layout_qss_val;
	int play_time;
	string camera_id;
	string camera_name;
	SwiperItemNode()
	{
		layout_qss_val = 0;
		play_time = 0;
		camera_id = "";
		camera_name = "";
	}
	SwiperItemNode(SwiperItemNode &s)
	{
		layout_qss_val = s.layout_qss_val;
		play_time = s.play_time;
		camera_id = s.camera_id;
		camera_name = s.camera_name;
	}
	~SwiperItemNode()
	{
		layout_qss_val = 0;
		play_time = 0;
		camera_id = "";
		camera_name = "";
	}
	SwiperItemNode *next = NULL;
} SWIPER_ITEM_NODE;

typedef struct SwiperItemRootNode
{
	string layout_name;
	string label_VM_Id;
	int Node_count;
	SWIPER_ITEM_NODE *node_data;
	SwiperItemRootNode()
	{
		node_data = (SWIPER_ITEM_NODE *)malloc(sizeof(SWIPER_ITEM_NODE));
		layout_name = "";
		label_VM_Id = "";
		Node_count = 0;
		node_data = NULL;
	}
	SwiperItemRootNode(SwiperItemRootNode &s)
	{
		layout_name = s.layout_name;
		label_VM_Id = s.label_VM_Id;
		Node_count = s.Node_count;
		node_data = s.node_data;
	}
	~SwiperItemRootNode()
	{
		layout_name = "";
		label_VM_Id = "";
		Node_count = 0;
		node_data = NULL;
	}
	SwiperItemRootNode *next = NULL;
} SWIPER_ITEM_ROOT_NODE;

class ItemNodeLink
{
public:
	ItemNodeLink() {}
	~ItemNodeLink() {}

public:
	SWIPER_ITEM_ROOT_NODE *item_node;

public:  //创建父链表 CURD
	int create_node_link(SWIPER_ITEM_ROOT_NODE **head)
	{
		//创建一个头结点
		//head = (SWIPER_ITEM_ROOT_NODE *)malloc(sizeof(SWIPER_ITEM_ROOT_NODE));
		*head = new SWIPER_ITEM_ROOT_NODE();
		if (!(head)) /* 存储分配失败 */
		{
			return -1;
		}
		(*head)->label_VM_Id = "";
		(*head)->layout_name = "";
		(*head)->Node_count = 0;
		(*head)->node_data = NULL;
		(*head)->next = NULL;
		return 0;
	}
	int add_node_link(SWIPER_ITEM_ROOT_NODE *head, SWIPER_ITEM_NODE *data, string layout_name, string label_VM_Id)
	{
		//创建插入结点
		//程序中的内存错误是因为使用malloc分配一个结构体内存，但是string是一个类。
		//并没有调用string的构造函数，所以string在malloc之后没有正确构造，导致使用时段错误	
		SWIPER_ITEM_ROOT_NODE *insert_node = new SWIPER_ITEM_ROOT_NODE();
		if (!insert_node)
			return -1;
		insert_node->layout_name = layout_name;
		insert_node->label_VM_Id = label_VM_Id;
		insert_node->node_data = data;

		//尾插法
		//使新数据成为尾结点
		insert_node->next = NULL;
		//创建临时结点temp,指向头结点
		SWIPER_ITEM_ROOT_NODE *temp = head;
		//找到链表的末端指针
		while (temp->next != NULL)
		{
			temp = temp->next;
		}
		temp->next = insert_node;//使上一个数据的next指向新数据 形成链表

		//头插
		//将现有头的next NULL赋值给该新申请的next,使之为空即使该数据成为尾结点
		//insert_node->next = head->next;
		//head->next = insert_node;
		
		return 0;
	}


	//考虑到删除尾结点的问题
	int del_node_link(SWIPER_ITEM_ROOT_NODE **head, string label_VM_Id)
	{
		if (!*head)
			return -1;

		//创建临时结点temp,指向头结点
		SWIPER_ITEM_ROOT_NODE *temp = NULL, *pre = NULL;
		temp = *head;
		//先判断当前节点是不是最后一个节点，如果是最后一个节点删除
		while (temp->next != NULL)
		{
			pre = temp;
			temp = temp->next;
		}
		if (temp->label_VM_Id == label_VM_Id)
		{
			free(temp);
			temp = NULL;
			pre->next = NULL;
			return 0;
		}
		//不是最后一个节点，找到位置，删除
		temp = *head;
		int j = 0;
		if (!temp)
			return -1;
		while (temp->next)
		{
			temp = temp->next;
			if (temp->label_VM_Id == label_VM_Id)
			{
				j++;
				break;
			}
		}
		del_node_link(*head, j, label_VM_Id);
		return 0;
	}

	//删除第pos位置的元素
	int del_node_link(SWIPER_ITEM_ROOT_NODE *head, int pos, string label_VM_Id)
	{
		int j = 1;

		//创建临时结点temp,指向头结点
		SWIPER_ITEM_ROOT_NODE *temp, *pre;
		temp = head;
		if (!temp)
			return -1;
		while (temp->next && j < pos)
		{
			temp = temp->next;
			++j;
		}
		/* 第pos个元素不存在 */
		if (!(temp->next) || j > pos)
			return -1;

		pre = temp->next;
		temp->next = pre->next;
		DestroyList(pre->node_data);
		free(pre);
		return 0;
	}

	int select_node_link() {}
	int EmptyList(SWIPER_ITEM_ROOT_NODE *head)
	{
		if (head->next == NULL)
			return 1;
		return 0;
	}
	void Print_List(SWIPER_ITEM_ROOT_NODE *head)//遍历打印
	{
		if (EmptyList(head))
			return;
		SWIPER_ITEM_ROOT_NODE *p = head->next;
		SWIPER_ITEM_NODE* temp = NULL;
		while (p)
		{			
			printf("label id:%s \n", p->label_VM_Id.c_str());
			temp = p->node_data;
			Print_List(temp);
			p = p->next;
		}
	}

	int Len_Get(SWIPER_ITEM_ROOT_NODE *head, string label_VM_Id)//遍历获取长度
	{
		int len = 0;
		//获取当前父节点的子节点是否为空。
		SWIPER_ITEM_ROOT_NODE *p = head->next;
		while (p != NULL)
		{
			if (p->label_VM_Id == label_VM_Id) 
			{
				len = Len_Get(p->node_data);
				printf("child count:%d", len);
				break;
			}			
			p = p->next;
		}
		return len;
	}

public: //创建子链表 CURD
	int create_child_node_link(SWIPER_ITEM_NODE** head)
	{
		//创建一个头结点
		//程序中的内存错误是因为使用malloc分配一个结构体内存，但是string是一个类。
		//并没有调用string的构造函数，所以string在malloc之后没有正确构造，导致使用时段错误	
		//head = (SWIPER_ITEM_NODE *)malloc(sizeof(SWIPER_ITEM_NODE));
		*head=new SWIPER_ITEM_NODE();
		(*head)->next = NULL;
		(*head)->camera_id = "";
		(*head)->camera_name = "";
		(*head)->layout_qss_val = 0;
		(*head)->play_time = 0;	
		return 0;
	}

	int add_child_node_link(SWIPER_ITEM_NODE **head, string camera_id, string camera_name,int layout_qss_val,int play_time)
	{
		//创建插入结点
		//程序中的内存错误是因为使用malloc分配一个结构体内存，但是string是一个类。
		//并没有调用string的构造函数，所以string在malloc之后没有正确构造，导致使用时段错误	
		SWIPER_ITEM_NODE *data = new SWIPER_ITEM_NODE();
		if (!data)
			return -1;
		data->camera_id = camera_id;
		data->camera_name = camera_name;
		data->layout_qss_val = layout_qss_val;
		data->play_time = play_time;
		
		//尾插法
		//使新数据成为尾结点
		data->next = NULL;
		//创建临时结点temp,指向头结点
		SWIPER_ITEM_NODE *temp = *head;
		//找到链表的末端指针
		while (temp->next != NULL) 
		{
			temp = temp->next;
		}					
		temp->next = data;//使上一个数据的next指向新数据 形成链表

		//头插
		//将现有头的next NULL赋值给该新申请的next,使之为空即使该数据成为尾结点
		//data->next = head->next;
		//head->next = data;
		return 0;
	}
	//任意位置插入
	int add_child_node_link(SWIPER_ITEM_NODE *head,int pos, string camera_id, string camera_name, int layout_qss_val, int play_time) 
	{
		int j=0;
		//创建临时结点temp,指向头结点
		SWIPER_ITEM_NODE *temp = head ;
		SWIPER_ITEM_NODE *data = new SWIPER_ITEM_NODE();
		if (!data)
			return -1;
		data->camera_id = camera_id;
		data->camera_name = camera_name;
		data->layout_qss_val = layout_qss_val;
		data->play_time = play_time;		
		while (temp && j < (pos-1))
		{
			temp = temp->next;
			++j;
		}
		/* 第pos个元素不存在 */
		if (!temp || j > (pos-1))
			return -1;   	

		data->next = temp->next;
		temp->next = data;
		//也可以
		//SWIPER_ITEM_NODE *pre;
		//pre = temp->next;
		//temp->next = data;
		//data->next = pre;	
		return 0;
	}
	//考虑到删除尾结点的问题
	int del_child_node_link(SWIPER_ITEM_NODE **head, string camera_id)
	{
		if (!*head)
			return -1;
		
		//创建临时结点temp,指向头结点
		SWIPER_ITEM_NODE *temp=NULL, *pre=NULL;
		temp = *head;
		//先判断当前节点是不是最后一个节点，如果是最后一个节点删除
		while (temp->next != NULL)
		{
			pre = temp;
			temp = temp->next;
		}
		if (temp->camera_id == camera_id)
		{
			free(temp);
			temp = NULL;
			pre->next = NULL;
			return 0;
		}
		//不是最后一个节点，找到位置，删除
		temp = *head;
		int j = 0;
		if (!temp)
			return -1;
		while (temp->next)
		{
			temp = temp->next;
			if (temp->camera_id == camera_id) 
			{
				j++;
				break;
			}
		}
		del_child_node_link(*head, j, camera_id);

		return 0;
	}
private:
	//删除第pos位置的元素
	int del_child_node_link(SWIPER_ITEM_NODE *head,int pos, string camera_id)
	{
		int j=1;

		//创建临时结点temp,指向头结点
		SWIPER_ITEM_NODE *temp, *pre;
		temp = head;
		if (!temp)
			return -1;
		while (temp->next && j<pos)
		{
			temp = temp->next;
			++j;
		}
		/* 第pos个元素不存在 */
		if (!(temp->next) || j > pos)
			return -1;


		pre = temp->next;
		temp->next = pre->next;
		free(pre);
		return 0;
	}

	int select_child_node_link() {}
	
	int EmptyList(SWIPER_ITEM_NODE *head)
	{
		if (head->next == NULL)
			return 1;
		return 0;
	}

	//销毁链表  
	int DestroyList(SWIPER_ITEM_NODE *head)
	{
		SWIPER_ITEM_NODE *temp;
		if (head == NULL)
			return -1;
		while (head)
		{
			temp = head->next;
			free(head);
			head = temp;
		}
		return 0;
	}

	//清空链表  
	int ClearList(SWIPER_ITEM_NODE *head)
	{
		SWIPER_ITEM_NODE *temp, *pre;
		if (head == NULL)
			return 0;
		temp = head->next;
		while (temp != NULL)
		{
			pre = temp->next;
			free(temp);
			temp = pre;
		}
		head->next = NULL;
		return 1;
	}
public:
	void Print_List(SWIPER_ITEM_NODE *head)//遍历打印
	{
		if (EmptyList(head))
			return;
		SWIPER_ITEM_NODE *p = head->next;
		while (p)
		{
			printf("camera id:%s \n", p->camera_id.c_str());
			p = p->next;
		}
	}
	int Len_Get(SWIPER_ITEM_NODE *head)//遍历获取长度
	{
		int len = 0;
		SWIPER_ITEM_NODE *p = head->next;
		while (p)
		{
			p = p->next;
			len++;
		}
		return len;
	}

	void List_Reverse(SWIPER_ITEM_NODE* head)//链表转置
	{
		if (EmptyList(head))return;
		SWIPER_ITEM_NODE *p1, *p2, *p3;
		p1 = head->next;
		p2 = p1->next;
		p3 = p2->next;
		head->next = NULL;
		p1->next = NULL;
		while (p3->next)
		{
			p2->next = p1;
			p1 = p2;
			p2 = p3;
			p3 = p2->next;
		}
		p2->next = p1;
		p3->next = p2;
		head->next = p3;
	}
};

int main()
{
   printf("hello world\n");
   ItemNodeLink *item = new ItemNodeLink();

   SWIPER_ITEM_ROOT_NODE *head = NULL;       //父链表			
   SWIPER_ITEM_NODE *child = NULL;			//子链表

   int ret = item->create_node_link(&head); //创建空的父链表
   int childRet = item->create_child_node_link(&child);

   printf("create linknode ret====:%d \n", ret);
   printf("create child linknode childRet====:%d \n", childRet);
   
   childRet = item->add_child_node_link(&child,"123123","huawei",4,30);
   childRet = item->add_child_node_link(&child, "456456", "hiki", 13, 30);
   childRet = item->add_child_node_link(&child, "789789", "yushi", 13, 30);
   childRet = item->add_child_node_link(&child, "123789", "yushi", 13, 30);
   printf("child add-------------------------\n");
   item->Print_List(child);

   //item->add_child_node_link(child, 3, "785785", "huawei", 4, 30);
   //printf("add-------------------------\n");
   //item->Print_List(child);

   //item->del_child_node_link(&child, "123123");
   //printf("del-------------------------\n");
   //item->Print_List(child);

   //item->del_child_node_link(&child, "123789");
   //printf("del-------------------------\n");
   //item->Print_List(child);


	//item->del_child_node_link(child, 2, "");
	//printf("del-------------------------\n");
	//item->Print_List(child);

	//item->List_Reverse(child);
	//printf("tre-------------------------\n");
	//item->Print_List(child);


   int count=item->add_node_link(head,child,"layout1","78978931");   
   printf("parent add-------------------------\n");
   item->Print_List(head);

   count = item->add_node_link(head, child, "layout2", "12378595");
   printf("parent add-------------------------\n");
   item->Print_List(head);

   count = item->add_node_link(head, child, "layout3", "45678595");
   printf("parent add-------------------------\n");
   item->Print_List(head);

   item->del_node_link(&head,"45678595");
   printf("parent del-------------------------\n");
   item->Print_List(head);
   
   //获取当前父节点的子节点是否为空。
   SWIPER_ITEM_ROOT_NODE *p = head->next;
   while (p!=NULL)
   {	   
	   count = item->Len_Get(p->node_data);
	   printf("child count:%d", count);
	   p = p->next;
   }
   
   system("pause");
   if (head != NULL) 
   {
	   delete head;
	   head = NULL;
   }
	
   if (child != NULL)
   {
	   delete child;
	   child = NULL;
   }
	
   return 0;
}
Stone_OverLooking
关注
专栏目录
数据结构——表
moon_fair的博客
03-26 360
１、抽象数据类型＃抽象数据类型（abstract data type,ADT)是一些操作的集合。＃对诸如表，集合，图和他们的操作一起可以看做是抽象数据类型。２、表＃称一个元素前边的元素其前驱，后边的为其后继。不定义首元素的前驱和末元素的后继。＃要定义的操作：PrintList, MakeEmpty, Insert, Delete, Find, FindKth, Next, Previous.......
数据结构~数据表
weixin_43151932的博客
10-21 185
数据结构2-1：数据表及其实现
hey，欢迎浏览我的博客，希望能给你提供帮助。
12-11 515
多项式的表示： 对于这2001个分量，我们可以看到，只有2项是非0的，其余全是0，这会造成很大的空间浪费。而且做加法的时候，怎么也要做一个循环，从0开始一直做到2000，实际上还有很多是在加无效的0，所以虽然方便但是也有很大的问题。 只表示非0项——结构数组： 这样的一种方法显然是用指数、系数构成的结构存储在数组里面，来表示非零项。这种方法是一种节省空间的方法，而且操作效率也不算差。同时表示非零项的这种方法，不一定非要用数组来做，也可以用另外一种方法：链表 上面是按照指数系数从大到
数据结构：表
TOEFL_ITLS的博客
10-09 461
表是一种线性的数据结构，对于形如 A0,A1,A2,...,AN−1A_{0} ,A_{1} ,A_{2},...,A_{N-1} 一般的表，这个表大小是 N，我们将表长为 0 的表称为空表。 表的数组实现： printList 时间复杂度：O(N) findKth 时间复杂度：O(1) insert 和 delete 时间复杂度：O(N)链表实现： 为了避免插入和删除的线性时间复杂度我们
数据结构—表
Ai_xiaohua的博客
05-04 404
数据结构 数据元素是数据的基本单位，它在计算机处理和程序设计中通常作为独立个体 数据对象是具有相同特征的数据元素的集合，十数据的一个子集。 数据的物理结构 数据的物理结构又称存储结构，有顺序和链式两种不同的方式 顺序存储的特点是数据元素在存储器的相对位置来体现数据元素之间的相互关系 链式存储结构是通过一组任意存储单元来存储数据元素的，而这些存储单元可以是连续的也可以是不连续的 ...
数据结构（C语言描述）学习笔记、学习文档.zip
11-08
数据结构（C语言描述）学习笔记、学习文档 数据结构（C语言描述）学习笔记、学习文档 数据结构（C语言描述）学习笔记、学习文档 数据结构（C语言描述）学习笔记、学习文档 数据结构（C语言描述）学习笔记、学习文档 ...
数据结构学习笔记基数排序 详细讲解
最新发布
09-18
数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解...
数据结构学习笔记1
01-07
数据结构数据结构 数据结构 基本概念和术语 数据：是客观事物的符号表示，能够输入到计算机中并能被计算机程序处理的符号的总称 数据元素：是数据的基本单位，用于完整地描述一个对象 数据对象：是性质相同的数据...
数据结构学习笔记排序算法：基数排序
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
考研数据结构学习笔记.doc
10-20
"数据结构学习笔记" 本文档是一个关于数据结构学习笔记，涵盖了数据结构的基本概念、逻辑结构、物理结构、算法设计规范、算法时间复杂度分析、空间复杂度分析等方面的内容。下面是对每个知识点的详细解释： 一、...
数据结构---表
JIE的博客
10-27 990
表 顺序表：array 数据项： 存储元素的内存首地址 表的容量 元素的数量 注意： 1、不要越界 2、时刻保持元素的连续性 优点：支持随机访问、修改、访问、排序的效率比较高，大块的连续内存不容易产生内存碎片 缺点：堆内存要求比较高(内存连续)，插入、删除元素时不方便、效率低 链式表：list 节点的数据项： 数据域：可以是若干个各种类型的数据项 指针域：
MySQL（三）数据结构、数据表操作
qq_38904347的博客
10-13 398
数据类型 整型 小数 MySQL 浮点型和定点型可以用类型名称后加（M，D）来表示，M表示该值的总共长度，D表示小数点后面的长度，M和D又称为精度和标度，如float(7,4)的 可显示为-999.9999，MySQL保存值时进行四舍五入，如果插入999.00009，则结果为999.0001。 日期 datetime、timestamp 显示一样，不过timestamp效率高，因为范围小 字...
超清晰-数据结构之线性表
热门推荐
MClink的博客
05-25 3万+
鸟哥说，坚持学习基础才能有出人头地的一天。不能只专注于练武功了，内功也得练。 本篇文章是讲数据结构的第一篇，跟着书好好再过一篇基础。 一、线性表 线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。 对于非空的线性表或者线性结构的特点： （1）存在唯一的一个被称作“第一个”的数据元素； （2）...
【数据结构(C语言)】数据结构-表
PKM of bk
01-01 3439
主要内容：总结线性表、栈和队列、串、数组和广义表的基本概念，存储结构及基本操作。
数据表结构
奋斗
05-22 702
数据表结构 1.表结构 2.表关系 3.唯一索引 4.单索引及组合索引 5.后悔药-时间戳 CREATE TABLE mall_user ( id int(11) NOT NULL AUTO_INCREMENT COMMENT '用户表id', username varchar(50) NOT NULL COMMENT '用户名', ...
数据结构三大表
迁就100
03-29 1396
一、线性表（linear list） 是n个具有相同特性的数据元素的有限序列，常见的线性表有顺序表、链表、栈、队列、字符串 线性表在逻辑上是线性结构，连续的，但是在物理上不一定是连续的通常是以数组和链式结构的形式存储 二、顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组...
数据结构-表（顺序表、链表）定义和基本操作
早安不安的博客
04-02 2133
数据结构-表（顺序表、链表）定义和基本操作
数据结构之常用表结构
weixin_30419799的博客
11-13 1345
最近结合博客园和自己近几年的一些积累，觉得有必要对.Net常用的一些表进行一次总结，一边为了自己后面看另一方面也希望能够对各位博友有一定的帮助，有不正确的地方希望大家帮忙纠正，非常感谢！！！ 表的数组结构（针对一维数组）： 概述：数组是一个长度固定的表结构，它的元素必须存放在一个内存空间当中。 功能说明：它提供了表的创建、清除、复制和元素的存取以及排序搜索功能（由于它...
数据结构之数据表笔记
CSDN_Yangk的博客
02-24 158
1 顺序表的插入操作算法的思路次序是( ) (1)判断插入位置的合理性,异常抛出 (2)从最后一个遍历至第i个,每个后移一个位置 (3)表的长度+1 (4)在i处插入元素 答案是：1243 2 在n个结点的顺序表中,算法的时间复杂度是O(1)的是( )。 A 在第i个结点后插入一个新结点 B 将n个结点从小到大排序 C 删除第i个结点 D 访问第i个结点 答案是D 注：数据表的特点就是访问根据地址...
软考程序员数据结构学习笔记
"软考程序员数据结构笔记.doc 是一份针对软考程序员考试的详细学习资料，涵盖了数据结构的基础知识，包括线性结构、树形结构、集合以及数组、顺序表、字符串、特殊矩阵和稀疏矩阵等概念。文档还强调了分析问题、设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值