2024年大数据最全数据结构---顺序表，链表_顺序链表(1)，面试官都被搞懵了

最新推荐文章于 2024-05-31 14:19:08 发布
最新推荐文章于 2024-05-31 14:19:08 发布
阅读量924 收藏 8
点赞数 23
分类专栏： 程序员 文章标签： 数据结构 大数据 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84181058/article/details/138460469
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

前言

线性表

线性表的概念

顺序表

顺序表的概念

顺序表的结构

接口实现

相关面试题分析

顺序表的问题及思考

链表

链表的概念及结构

链表的分类

单链表的实现

接口实现

链表面试题

双向链表

顺序表和链表的区别

前言

这篇文章主要讲顺序表和链表，有几点需要大家注意一下：1.在学习的时候如果认为看着比较吃力的话，建议先去看看c语言–指针于结构体。2.当我们学习数据结构更多的是要练习，一遍一遍的把练习把基础打牢固。3.我们希望大家都能养成爱画图的习惯，很多时候图画出来了，思路就清晰了，代码就自然出来。4.遇到bug多调试，不熟不要怕慢慢就熟了。在这里与君共勉，互相加油，互相学习。

线性表

线性表的概念

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

顺序表

顺序表的概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表的结构

1. 静态顺序表：使用定长数组存储元素。

2.动态顺序表：使用动态开辟的数组存储。

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

接口实现

SeqList.h—头文件，声明

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int SLDateType;

typedef struct SeqList
{
	SLDateType* a;
	size_t size;
	size_t capacity;
}SeqList;

//初始化
void SeqListInit(SeqList* ps);

//销毁
void SeqListDestroy(SeqList* ps);

//打印
void SeqListPrint(SeqList* ps);

//尾加
void SeqListPushBack(SeqList* ps, SLDateType x);

//头加
void SeqListPushFront(SeqList* ps, SLDateType x);

//头删
void SeqListPopFront(SeqList* ps);

//尾删
void SeqListPopBack(SeqList* ps);

//顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);

//顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDateType x);

//顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos);

SeqList.c—函数实现

#define _CRT_SECURE_NO_WARNINGS
#include  "SeqList.h"


void SeqListInit(SeqList* ps)//初始化
{
	assert(ps);

	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

void SeqListDestroy(SeqList* ps)//销毁
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

void SeqListPrint(SeqList* ps)//打印
{
	assert(ps);

	for (size_t i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SLCheckCapacity(SeqList* ps)//检查
{
	if (ps->size==ps->capacity)
	{
		SLDateType newCapcity = ps->capacity==0 ? 4 : ps->capacity * 2;
		SLDateType* temp = (SLDateType*)realloc(ps->a, sizeof(ps->a)*newCapcity);
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = temp;
		ps->capacity = newCapcity;
	}
}

void SeqListPushBack(SeqList* ps, SLDateType x)//尾加
{
	assert(ps);
	SLCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;
}

void SeqListPushFront(SeqList* ps, SLDateType x)//头加
{
	assert(ps);
	SLCheckCapacity(ps);

	int end = ps->size-1;
	while (end >= 0)
	{
		ps->a[end+1] = ps->a[end];
		end--;	
	}
	ps->a[0] = x;
	ps->size++;
}

void SeqListPopFront(SeqList* ps)//头删
{
	assert(ps);

	if (ps->size == 0)
	{
		return;
	}
	SLDateType str = 0;
	SLDateType end = ps->size - 1;
	while (str <= end)
	{
		ps->a[str] = ps->a[str + 1];
		str++;
	}
	ps->size--;
}

void SeqListPopBack(SeqList* ps)//尾删
{
	assert(ps);
	if (ps->size == 0)
	{
		return;
	}
	ps->size--;
}

int SeqListFind(SeqList* ps, SLDateType x)//顺序表插入
{
	assert(ps);

	int end = ps->size - 1;
	while (end>=0)
	{
		if (ps->a[end] == x)
			return end;
		end--;
	}
	return -1;
}

void SeqListInsert(SeqList* ps, size_t pos, SLDateType x)//顺序表在pos位置插入x
{
	assert(ps);

	if (pos < 0 || pos >(ps->size - 1))
	{
		printf("输入错误\n");
		return;
	}

	for (size_t i = ps->size; i > pos; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
		
	ps->a[pos] = x;
	ps->size++;
}

void SeqListErase(SeqList* ps, size_t pos)//顺序表删除pos位置的值
{
	assert(ps);

	if (pos < 0 || pos >(ps->size - 1))
	{
		printf("输入错误\n");
		return;
	}

	for (size_t i = pos; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i+1];
	}
	ps->size--;
}

test.c—测试

#define _CRT_SECURE_NO_WARNINGS
#include "SeqList.h" 

int main()
{
	SeqList s;
	SeqListInit(&s);

	SeqListPushBack(&s, 1);
	SeqListPrint(&s);

	SeqListPushFront(&s, 2);
	SeqListPushFront(&s, 3);
	SeqListPrint(&s);

	SeqListPopFront(&s);
	SeqListPrint(&s);

	int ret = SeqListFind(&s, 2);
	if (ret == 1)
		printf("yes\n");
	else
		printf("no\n");

	SeqListInsert(&s, 1, 5);
	SeqListPrint(&s);

	SeqListErase(&s, 1);
	SeqListPrint(&s);
}

这里建议实现一个函数了就先测试了来，后面过多了就容易看着眼花缭乱的。大神就另当别论！

相关面试题分析

例题1

原地移除数组中所有的元素val，要求时间复杂度为O(N)，空间复杂度为O(1)。链接

实现过程：

实现代码：

int removeElement(int* nums, int numsSize, int val){
   
   int src=0,dest=0;
   while(src<numsSize)
   {
       if(nums[src]==val)
       {
           src++;
       }
       else
       {
           nums[dest++]=nums[src++];
       }
   }
    return dest;
}

例题2

删除排序数组中的重复项：链接

实现过程：

实现代码：

int removeDuplicates(int* nums, int numsSize){
   if (numsSize == 0) {
		return 0;
	}
    int src=1,dest=0;
    while(src<numsSize)
    {
        if(nums[src]==nums[dest])
        {
            src++;
        }
        else
        {
            dest++;
            nums[dest]=nums[src];
            src++;
        }
    }
    return dest+1;
}

例题3

合并两个有序数组：链接

实现过程—2种情况:：

实现代码：

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
   int src=m-1,dest=n-1;
   int end=m+n-1;
   while(src>=0&&dest>=0)
   {
       if(nums1[src]>nums2[dest])
       {
           nums1[end]=nums1[src];
           src--;
           end--;
       }
       else
       {
           nums1[end]=nums2[dest];
           end--;
           dest--;
       }
   }
   while(dest>=0)
   {
       nums1[end]=nums2[dest];
       end--;
       dest--;
   }
}

//方法二--插入快排
int cmp(void* dest,void* src)
{
    return *(int*)dest-*(int*)src;
}
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
   
    for (int i=0;i!=n;i++){
		nums1[m+i] = nums2[i];
	}
    qsort(nums1,n+m,sizeof(int),cmp);
}
顺序表的问题及思考

问题：

  1. 中间/头部的插入删除，时间复杂度为O(N)

  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

如何解决这一问题呢？下面给出了链表的结构来看看。

链表

链表的概念及结构

概念：

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

单向或者双向

带头或者不带头

循环或者非循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

  2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面代码实现了就知道了。

单链表的实现

在学习单链表之前，我们需要弄明白我们是否需要改变我们传过去的参数？如果需要改变那我们传参的时候，实现功能的函数用什么接受参数？我们知道单链表是需要结构体来实现的，一个是存数据一个是存地址，那么结构体中的变量就应该是一个int类型的数据和一个指针。当我们明白结构体重的变量之后，我们会发现实现增删改查就是改变指针中的地址。数据有地址，指针也有地址。所需要改变指针地址时，我们就用二级指针来接受指针的地址。下面就是说明为什么需要用二级指针来接受。

接口实现

SList.h–函数声明

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>
#include <stdlib.h> 
typedef int SLTDateType;

//创建结构体
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);

// 单链表打印
void SListPrint(SListNode* phead);

// 单链表尾插
void SListPushBack(SListNode** pphead, SLTDateType x);

// 单链表的头插
void SListPushFront(SListNode** pphead, SLTDateType x);

// 单链表的尾删
void SListPopBack(SListNode** pphead);

// 单链表头删
void SListPopFront(SListNode** pphead);

// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);

// 单链表的销毁
void SListDestroy(SListNode* phead);

SList.c–功能实现

#include "SList.h"

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode)* 1);
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

// 单链表打印
void SListPrint(SListNode* phead)
{
	assert(phead);
	SListNode*cur = phead;

	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

// 单链表尾插
void SListPushBack(SListNode** pphead, SLTDateType x)
{
	assert(pphead);

	SListNode* newnode = BuySListNode(x);
	if (*pphead == NULL)//为空
	{
		*pphead = newnode;
	}
	else//不为空
	{
		SListNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

// 单链表的头插
void SListPushFront(SListNode** pphead, SLTDateType x)
{
	assert(pphead);
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

// 单链表的尾删
void SListPopBack(SListNode** pphead)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		return;
	}

	SListNode* tail = *pphead;
	while (tail->next->next != NULL)
	{
		tail = tail->next;
	}
	free(tail->next);
	tail->next = NULL;

}

// 单链表头删
void SListPopFront(SListNode** pphead)
{
	assert(pphead);
	
	if (*pphead == NULL)
	{
		return;
	}
	SListNode* del = *pphead;
	*pphead = del->next;
	free(del);
	del = NULL;
}

// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);

	while (plist->data!= x)
	{
		plist = plist->next;
	}
	if (plist == NULL)
	{
		return NULL;
	}
	else
		return plist;
}

// 单链表在pos位置之后插入x
void SListInsertAfter( SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode*newnode= BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;

}

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	//SListNode*newnode = pos->next;	
	//
	//if (newnode != NULL)
	//{
	//	SListNode* nextnext = newnode->next;
	//	free(newnode);
	//	pos->next = nextnext;
	//}
	SListNode*newnode = pos;
	if (newnode->next != NULL)
	{
		SListNode*nextnext = newnode->next->next;
		free(newnode->next);
		pos->next = nextnext;
	}
}

// 单链表的销毁
void SListDestroy(SListNode* phead)
{
	assert(phead);

	free(phead->next);
	phead->data = 0;
	phead->next= NULL; 
}

Test.c–测试

#include "SList.h"

//尾插展示
void TestSList1()
{
	SListNode* plist=NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 7);
	SListPrint(plist);

}

//头查展示
void TestSList2()
{
	SListNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 7);
	SListPushFront(&plist, 11);
	SListPrint(plist);
}
// 单链表的尾删
void TestSList3()
{
	SListNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 7);
	SListPushFront(&plist, 11);
	SListPopBack(&plist);
	SListPopBack(&plist);
	SListPrint(plist);
}
void TestSList4()
{
	SListNode* plist = NULL;
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 8);
	SListPushFront(&plist, 9);
	SListPopFront(&plist);
	SListPrint(plist);
	SListNode* pos = SListFind(plist, 8);
	if (pos)
	{
		// ޸
		pos->data *= 10;
		printf("\n");
	}
	else
	{
		printf("\n");
	}
	SListPrint(plist);

}
void TestSList5()
{
	SListNode* plist = NULL;
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListNode* pos = SListFind(plist, 2);
	SListInsertAfter(pos, 4);
	SListPrint(plist);
}

void TestSList6()
{
	SListNode* plist = NULL;
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);
	SListPushFront(&plist, 7);
	SListPushFront(&plist, 8);
	SListPushFront(&plist, 8);
	SListPushFront(&plist, 8);
	SListNode* pos = SListFind(plist,7);
	SListEraseAfter(pos);
	SListPrint(plist);

}

void TestSList7()
{
	SListNode* plist = NULL;
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);
	SListPushFront(&plist, 7);
	SListDestroy(plist);
	SListPrint(plist);
}

int main()
{
	TestSList1();
	TestSList2();
	TestSList3();
	TestSList4();
	TestSList5();
	TestSList6();
	TestSList7();
}
链表面试题

例题1

删除链表中等于给定值 val 的所有结点 ：链接

图文解析：

实现代码：

struct ListNode* removeElements(struct ListNode* head, int val){
  struct ListNode* plist=NULL;
  struct ListNode* newnod=head;
    while(newnod)
    {       
        if(newnod->val!=val)
        {
            plist=newnod;
            newnod=newnod->next;
        }
        else 
        {
            if(plist==NULL)
            {
                head=newnod->next;
                free(newnod); 
                newnod=head;         
            }
            else
            {
               plist->next=newnod->next;
                free(newnod);
                newnod=plist->next;
            }
        }
    }
    return  head;
}

例题2

反转一个单链表：链接

方法1：我们用plist来改变地址指向，最开始将首元素next地址置为空，再将首元素地址赋予plist，将第二个元素的next地址改成第一个元素地址，接下来依次循环。主要是用plist与next保存地址。

图文解析：

实现代码：

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* plist=NULL;
    struct ListNode* cur=head;

    while(cur)
    {
        struct ListNode* next=cur->next;
        cur->next=plist;
        plist=cur;

        cur=next;
    }
    return plist;
}

方法2：我们用n1，n2，n3进行同时移动，将n1赋值为null，n2为首元素，n3为首元素next，我们改变了地址指向后，n1，n2，n3依次向右的移动，n1为n2，n2为n3，直到n2位空，用返回n1。

图文解析：

实现代码：

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* n1=NULL;
    struct ListNode* n2=head;
    struct ListNode* n3=NULL;
    while(n2)
    {
        n3=n2->next;
        n2->next=n1;
        n1=n2;
        n2=n3; 
                
    }
    return n1;
}

例题3：

给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点：链接

图文解析：

实现代码：

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow=head;
    struct ListNode* fsat=head;
    while(fsat&&fsat->next)
    {
         fsat=fsat->next->next;
         slow=slow->next;
    }
    return slow;
}

例题4

输入一个链表，输出该链表中倒数第k个结点：链接

图文解析：

实现代码：

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast=pListHead;
    struct ListNode* slow=pListHead;
    struct ListNode* cur=pListHead;
    int count=0;
    while(cur)
    {
        cur=cur->next;
        count++;
    }
    if(pListHead==NULL||k==0||k>count)
    {
        return NULL;
    }
    while(k--&&fast)
    {
        fast=fast->next;
    }
   
    while(fast)
    {


![img](https://img-blog.csdnimg.cn/img_convert/c44bd6239b541cdc5b2dbc79a4ed9060.png)
![img](https://img-blog.csdnimg.cn/img_convert/b63e34626e7cbe46a6fcb5becbc7f2a5.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

d;
    struct ListNode* fsat=head;
    while(fsat&&fsat->next)
    {
         fsat=fsat->next->next;
         slow=slow->next;
    }
    return slow;
}

例题4

输入一个链表，输出该链表中倒数第k个结点：链接

图文解析：

实现代码：

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast=pListHead;
    struct ListNode* slow=pListHead;
    struct ListNode* cur=pListHead;
    int count=0;
    while(cur)
    {
        cur=cur->next;
        count++;
    }
    if(pListHead==NULL||k==0||k>count)
    {
        return NULL;
    }
    while(k--&&fast)
    {
        fast=fast->next;
    }
   
    while(fast)
    {


[外链图片转存中...(img-8fBifEwe-1714873676203)]
[外链图片转存中...(img-y1EdByAd-1714873676204)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84181058
关注
  • 23
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构 - 链表 - 面试中常见的链表算法题
从零开始
01-17 4125
数据结构 - 链表 - 面试中常见的链表算法题 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍线性表中的常见的链表数据结构。包括 概念简介 链表节点的数据结构（Java） 常见的链表算法题（Java）。 概念简介 如果对链表概念已经基本掌握，可以跳过该部
数据结构-C语言描述（顺序表、链表）
04-01
水一下学校的实验报告，注释没有认真写，勿喷。
超硬核十万字！全网最全 数据结构 代码，随便秒杀老师/面试官，我说的
热门推荐
hebtu666
04-20 10万+
本文代码实现基本按照《数据结构》课本目录顺序，外加大量的复杂算法实现，一篇文章足够。能换你一个收藏了吧？
2024年大数据最新数据结构--时间复杂度和空间复杂_select from 时间复杂度
2401_84187537的博客
05-02 8
随着近些年计算机快速的发展，对程序员来说入职要求也越来越高了，公司对我们的代码能力要求也越来越高了，大厂笔试中几乎全是算法题而且难度大，中小厂的笔试中才会有算法题，所以现在也越来越卷。为了能有一份好工作，我们必须手撕数据结构。难道就只是入职也一好处吗？显然不是的，学好算法不论对你思考问题的方式还是对你编程的思维都会有很大的好处。数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。
数据结构学习笔记 1-1 链表（List）与 LeetCode真题图解（Java）
How many ten years in the life time?
01-06 4305
1-1 链表(List)及经典问题 链表基础知识 链表的典型应用场景 现在我们有这样一个需求：现在这个4GB的内存是一个连续的存储空间，我们要在这个存储空间里面开辟1GB的连续的存储空间，接下来我们是要在4GB的内存空间划分出来1GB的存储空间，如图： malloc函数是c语言里的内容，就好比java里的new；作用相同的，就是开辟存储空间。 可以想象成我找了一个1GB大小的数组，虽然有点夸张，只是举例。 经过我这样的申请空间之后，我们把我们的整个数据切分了，原本是好好的一整块数组，变成两块了，一个是
（左神）数据结构与算法 ---- 判断链表是否为回文结构的三种高效解法
weixin_51201930的博客
03-23 2639
链表在数据结构与算法中可谓“北斗之尊”，现在让我们通过判断链表回文的小练习进一步更深地了解链表~ 文章目录一、链表的节点结构二、判断一个链表是否为回文结构（一）解法1：将链表全部节点进栈出栈比较（空间复杂度为O(N)）（二）解法2：将链表右半部分节点进栈出栈比较（空间复杂度为O(2/N)）（三）解法3：快慢指针+指针逆序解法（空间复杂度为O(1)，符合题目要求） 简单回顾一下链表的结构~ 一、链表的节点结构 1.单链表的节点结构 Class Node<V>{ V value; .
探讨面试问题：链表和顺序表的区别
baiyang2001的博客
11-13 795
???? 当面试官问到以下三个问题的任意一个问题：???? 顺序表和链表的区别 数组和链表的区别 ArrayList 和 LinkedList 的区别 ???? 以上三个问题都是一个问题，就是在问：双向链表和顺序表的区别 技巧：当面试官问到 #### 和 #### 的区别的时候，一定记住，先从共同点出发 这两种数据结构的共同点都是：线性表 这两种数据结构的不同点都是：对数据的组织方式和操作方法 组织方式： 顺序表底层是一个数组，它在逻辑和物理上是连续的 链表是由若干个结点组成的一个
【数据结构初阶】复杂链表复制+带头双向循环链表+缓存级知识
The porters of knowledge
11-09 1039
经典的链表结构，值得你端详一下
面试官系列 - LeetCode链表知识点&题型总结
徐公，微信公众号同名
08-01 982
文章目录前言知识点什么是链表类别单向链表循环链表双向链表双向循环链表与数组的性能对比优缺点常用技巧题型总结基本操作删除类翻转类题型合并链表环形链表拆分链表排序链表小结**往期文章** 我的 CSDN 博客:https://blog.csdn.net/gdutxiaoxu 我的掘金：https://juejin.im/user/2207475076966584 github: https://github.com/gdutxiaoxu/ 微信公众号：徐公码字(stormjun94) 知乎：ht
数据结构 | 单链表SingleList【带你从浅入深真正搞懂链表】
做技术人 · 产优质博客 · 找好工作
11-10 3718
万字详解单链表，带你从浅入深真正搞懂链表，不再为指针而苦恼
数据结构-链表
temperamentalkj
03-23 2018
链表1、hot100 - 2. 两数相加 1、hot100 - 2. 两数相加 题目：https://leetcode-cn.com/problems/add-two-numbers/ 时间复杂度：O(max(m,n)) 空间复杂度：O(1)。注意返回值不计入空间复杂度 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(
链表_数据结构--链表_
10-01
在windows端利用python实现链表的相关功能
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
比特数据结构课件
shujujiegou.rar_c 数据结构_数据结构_栈_链表 实现_顺序表
09-22
数据结构源程序，包括：顺序表的基本运算实现，链表的基本运算与实现，栈的基本运算与实现以及实例等18个源程序。
数据结构与算法-顺序表（链表篇）
09-09
代码资源
线性数据结构-数组
最新发布
passworddddddd的博客
05-31 172
因为数组定长，当想往长度为8的数组中添加第九个元素时，操作系统会开辟一段长度为16的新的空间（操作系统会开辟一些提前量，多划一些空间），然后将旧数组的八个元素复制到新的数组中，并将新添加的元素，添加到新数组的第九个位置上，并且销毁就数组。1、因为空间必须是连续的，如果数组比较大，当系统的空间碎片较多时，容易存不下。在长度8的数组中删除第5个元素，不改变数组长度，从第六个元素开始向左移动一个单元，即数组删除。2、因为数组长度是固定，所以数组的内容难以被添加和删除。3、数组的变量指向了数组第一个元素的位置。
C语言.数据结构.单链表
Joseit的博客
05-31 746
C语言数据结构单链表技术博客文章摘要 本文深入探讨了C语言中的数据结构——单链表。首先，文章介绍了链表的概念及结构，强调了链表作为一种物理存储结构上非连续、非顺序的存储结构，其数据元素的逻辑顺序是通过链表中的指针链接次序实现的。通过将链表与火车车厢的类比，形象地展示了链表节点之间的独立性和链接关系。 接着，文章详细阐述了单链表的实现方法，包括定义链表节点结构体、实现基本的链表操作（如头部插入、删除、尾部插入、删除、查找、在指定位置插入/删除节点等），以及链表的销毁等功能。
C-数据结构-树状存储基本概念
aqiangdeba的博客
05-27 782
’’树状存储基本概念深度（层数）度（子树个数）叶子孩子兄弟堂兄弟二叉树：满二叉树：完全二叉树：存储：顺序，链式树的遍历：按层遍历，先序，中序，后序‘’’树是计算机科学中的一种重要数据结构。以下是关于树的基本概念和类型的详细介绍。
7-1 数据结构实验之链表一：顺序建立链表
06-28
### 回答1： 好的，我来回复。7-1 数据结构实验之链表一：顺序建立链表是一道链表实验题目，要求学生使用顺序存储的方式建立链表，并实现链表的基本操作，如插入、删除、查找等。这道题目可以帮助学生深入理解链表的原理和实现方式，提高其对数据结构的理解和应用能力。 ### 回答2： 链表是一种常见的数据结构，它是由一系列结点组成的线性结构。结点包括两部分内容，一部分是存储数据的元素，另一部分是指向下一个结点的指针。链表的优点在于可以动态地增加、删除结点，因此它常用于需要频繁增删数据的场合。 本次实验是链表的第一部分，即顺序建立链表。顺序建立链表指的是从头到尾依次输入结点，将其链接在一起形成链表。具体实现方法如下： 1. 定义一个结点结构体，包含存储数据的元素和指向下一个结点的指针。 2. 在主函数中定义一个头结点，头结点的数据元素可以不存储有效数据，仅用于方便遍历链表。 3. 通过循环输入数据，并将数据存储在新结点中。 4. 将新结点的指针指向头结点指向的下一个结点，再将头结点的指针指向新结点，即完成了新结点的插入。 5. 继续输入下一个数据，直到输入完毕。 6. 最后遍历链表输出所有数据。 顺序建立链表的算法简单易懂，适合初学者入门。但是该算法的缺点在于它需要依次遍历链表，时间复杂度较高，因此在数据量较大时效率会比较低。此外，该算法只能按照输入的顺序依次插入数据，不能根据数据的大小或其他规则来插入新结点，因此在一些需要按照某种规则排序的场合可能无法满足需求。 总之，顺序建立链表是链表的一种基本实现方法，掌握该算法对于学习其他链表操作是非常有帮助的。 ### 回答3： 链表是数据结构中很重要的一种，它可以实现灵活的插入、删除、查找等操作。其中，顺序建立链表是链表的一种常见方法。 顺序建立链表的过程中，我们需要先定义一个节点结构体，例如： typedef struct node{ int data; // 数据域 struct node* next; // 指针域 }Node; 在这个结构体中，有一个数据域用来存储节点的值，还有一个指针域用来指向下一个节点。接下来，我们可以通过输入数据来构建链表。 具体实现方法是，先定义一个头指针，然后通过循环读取输入的数据，并将其插入到链表中。例如，以下是一个简单的顺序建立链表的代码： void CreateList(Node *&head){ int data; Node *p, *q; head = NULL; q = head; cin >> data; while(data != -1){ p = new Node; p->data = data; p->next = NULL; if(head == NULL){ head = p; q = head; } else{ q->next = p; q = p; } cin >> data; } } 这段代码中，首先定义一个头指针head，将其初始化为NULL。然后依次读取输入的数据，直到读取到-1为止。在每次读取数据之后，新建一个节点p，并将输入的数据存储在节点的数据域中，然后将p插入到链表的尾部。 顺序建立链表的优点是简单快捷，代码实现比较容易，适用于已经知道链表数据的顺序的情况。但是其缺点是无法处理插入数据的顺序不确定的情况，因此需要使用其他方法进行插入操作，例如头插法或尾插法。 综上所述，链表是一个十分重要的数据结构，顺序建立链表是链表的一个常用构建方法，其优点是简单快捷，但对于插入顺序不确定的数据，需要使用其他方法进行插入操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值