精华内容
下载资源
问答
  • 指定位置插入: insert_pos_val(lk headNode, int pos, int val); #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> typedef struct LinkNode { int num; LinkNode* next; }...

    指定位置插入:
    insert_pos_val(lk headNode, int pos, int val);
    在这里插入图片描述

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    typedef struct LinkNode
    {
    	int num;
    	LinkNode* next;
    }Lk, * lk;
    //初始化头节点
    lk init_headNode()
    {
    	lk headNode = (lk)malloc(sizeof(Lk));
    	if (headNode == NULL)
    	{
    		return NULL;
    	}
    	headNode->next = NULL;
    	//指针遍历输出
    	lk endNode = headNode;
    	//输入-1结束向链表赋值
    	int val = -1;
    	while (1)
    	{
    		printf("请输入:\n");
    		scanf("%d", &val);
    		if (val == -1)
    		{
    			break;
    		}
    		lk newNode = (lk)malloc(sizeof(Lk));
    		newNode->num = val;
    		newNode->next = NULL;
    		//尾插法
    		endNode->next = newNode;
    		endNode = newNode;
    	}
    	return headNode;
    }
    //遍历输出
    void foreach_linkList(lk headNode)
    {
    	if (headNode == NULL)
    	{
    		return;
    	}
    	lk curNode = headNode->next;
    	while (curNode)
    	{
    		printf("%d\n", curNode->num);
    		curNode = curNode->next;
    	}
    }
    //指定位置插入一个值
    void insert_pos_val(lk headNode, int pos, int val)
    {
    	if (headNode == NULL)
    	{
    		return;
    	}
    	lk prveNode = headNode;
    	lk curNode = headNode->next;
    	//索引
    	int index = 0;
    	while (curNode)
    	{
    		if (index == pos)
    		{
    			break;
    		}
    		prveNode = curNode;
    		curNode = curNode->next;
    		index++;
    	}
    	if (pos > index)
    	{
    		printf("无法插入当前位置\n");
    		return;
    	}
    	lk newNode = (lk)malloc(sizeof(Lk));
    	newNode->num = val;
    	newNode->next = NULL;
    	prveNode->next = newNode;
    	newNode->next = curNode;
    }
    int main()
    {
    	lk headNode = init_headNode();
    	printf("打印输出链表:\n");
    	foreach_linkList(headNode);
    	printf("插入后打印输出链表:\n");
    	insert_pos_val(headNode, 10, 521);
    	foreach_linkList(headNode);
    	return 0;
    }
    

    在这里插入图片描述

    指定位置删除:
    在这里插入图片描述

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    typedef struct LinkNode
    {
    	int num;
    	LinkNode* next;
    }Lk, * lk;
    //初始化头节点
    lk init_headNode()
    {
    	lk headNode = (lk)malloc(sizeof(Lk));
    	if (headNode == NULL)
    	{
    		return NULL;
    	}
    	headNode->next = NULL;
    	//指针遍历输出
    	lk endNode = headNode;
    	//输入-1结束向链表赋值
    	int val = -1;
    	while (1)
    	{
    		printf("请输入:\n");
    		scanf("%d", &val);
    		if (val == -1)
    		{
    			break;
    		}
    		lk newNode = (lk)malloc(sizeof(Lk));
    		newNode->num = val;
    		newNode->next = NULL;
    		//尾插法
    		endNode->next = newNode;
    		endNode = newNode;
    	}
    	return headNode;
    }
    //遍历输出
    void foreach_linkList(lk headNode)
    {
    	if (headNode == NULL)
    	{
    		return;
    	}
    	lk curNode = headNode->next;
    	while (curNode)
    	{
    		printf("%d\n", curNode->num);
    		curNode = curNode->next;
    	}
    }
    //指定位置删除
    void delete_pos_val(lk headNode, int pos, int val)
    {
    	if (headNode == NULL)
    	{
    		return;
    	}
    	lk prveNode = headNode;
    	lk curNode = headNode->next;
    	//索引:跟据curNode位置移动
    	int index = 1;
    	while (curNode)
    	{
    		if (index == pos)
    		{
    			break;
    		}
    		prveNode = curNode;
    		curNode = curNode->next;
    		index++;
    	}
    	if (pos > index)
    	{
    		printf("没有当前元素可供删除\n");
    		return;
    	}
    	//改变prveNode指针指向
    	prveNode->next = curNode->next;
    	//释放curNode节点在堆区开辟的数据
    	free(curNode);
    }
    int main()
    {
    	lk headNode = init_headNode();
    	printf("打印输出链表:\n");
    	foreach_linkList(headNode);
    	printf("删除后打印输出链表:\n");
    	delete_pos_val(headNode, 2, 521);
    	foreach_linkList(headNode);
    	return 0;
    }
    

    在这里插入图片描述
    逆置链表方式:只对当前链表进行操作,不借用新链表
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    typedef struct LinkNode
    {
    	int num;
    	LinkNode* next;
    }Lk, * lk;
    //初始化头节点
    lk init_headNode()
    {
    	lk headNode = (lk)malloc(sizeof(Lk));
    	if (headNode == NULL)
    	{
    		return NULL;
    	}
    	headNode->next = NULL;
    	//指针遍历输出
    	lk endNode = headNode;
    	//输入-1结束向链表赋值
    	int val = -1;
    	while (1)
    	{
    		printf("请输入:\n");
    		scanf("%d", &val);
    		if (val == -1)
    		{
    			break;
    		}
    		lk newNode = (lk)malloc(sizeof(Lk));
    		newNode->num = val;
    		newNode->next = NULL;
    		//尾插法
    		endNode->next = newNode;
    		endNode = newNode;
    	}
    	return headNode;
    }
    //遍历输出
    void foreach_linkList(lk headNode)
    {
    	if (headNode == NULL)
    	{
    		return;
    	}
    	lk curNode = headNode->next;
    	while (curNode)
    	{
    		printf("%d\n", curNode->num);
    		curNode = curNode->next;
    	}
    }
    //逆置链表
    void reverse_pos_val(lk headNode)
    {
    	if (headNode == NULL)
    	{
    		return;
    	}
    	lk prveNode = headNode;
    	lk curNode = prveNode->next;
    	lk nextNode = curNode->next;
    	//第一步:
    	prveNode->next = NULL;
    	curNode->next = NULL;
    	//第二步到第五步
    	while (nextNode != NULL)
    	{
    		//辅助指针往后移动
    		prveNode = curNode;
    		curNode = nextNode;
    		nextNode = nextNode->next;
    		//移动过后改变链表中curNode节点next指针指向
    		curNode->next = prveNode;
    	}
       //第六步
    	headNode->next = curNode;	
    }
    int main()
    {
    	lk headNode = init_headNode();
    	printf("打印输出链表:\n");
    	foreach_linkList(headNode);
    	printf("逆置后打印输出链表:\n");
    	reverse_pos_val(headNode);
    	foreach_linkList(headNode);
    	return 0;
    }
    
    

    在这里插入图片描述
    方式二:准备一个新链表,取出之前链表中的元素,用头插法的方式插入新准备的链表中,这里不做演示

    展开全文
  • * 定义一个链表节点 */ typedef struct LinkedNode { int data; struct LinkedNode *next; } LinkedNode; /*头插法和尾插法,均是传入头指针,然后进行操作的,所以在入参的时候,用到的...

    实现代码

    #include <stdio.h>
    #include <stdlib.h>
    
    /*
     * 定义一个链表节点
     */
    typedef struct LinkedNode {
        int data;
        struct LinkedNode *next;
    } LinkedNode;
    
    /*头插法和尾插法,均是传入头指针,然后进行操作的,所以在入参的时候,用到的是双指针*/
    /*
     * 头插法
     * Following are the 4 steps to add node at the front.
     * Given a reference (pointer to pointer) to the head of a list
     * and an int,  inserts a new node on the front of the list.
     * 注意这里传的参数是指针的指针
     * Time complexity of push() is O(1) as it does constant amount of work.
     */
    void push(LinkedNode **head_ref, int new_data
    );
    
    /*
     * 尾插法
     * Add a node at the end: (6 steps process)
     * Since a Linked List is typically represented by the head of it, we have to traverse the list till end and then change the next of last node to new node.
     * Given a reference (pointer to pointer) to the head
     * of a list and an int, appends a new node at the end
     */
    void append(LinkedNode **head_ref, int new_data);
    
    /**
     * 给定一个节点,在这个节点后面插入数据
     * @param prev_node 是一个指针,这个指针目前指在哪个节点,就将新节点插入到其后面
     * @param new_data
     */
    void insertAfter(LinkedNode *prev_node, int new_data);
    
    /*输出各节点的值*/
    void printList(LinkedNode *node);
    
    int main() {
        //1.测试一下头插法
        LinkedNode *head = NULL;
        //2.测试一下尾插法
        LinkedNode *tail = NULL;
        //因为push的入参是指针的指针,所以这里一定要用&取指针的地址
        printf("%p\n", &head);
        printf("头插法\n");
        push(&head, 5);
        push(&head, 6);
        push(&head, 7);
        printList(head);
        printf("尾插法\n");
        append(&tail, 4);
        append(&tail, 3);
        append(&tail, 2);
        printList(tail);
        //这里要传节点
        //将值插到指定的节点后面
        //tail本来是指向4的位置,tail->next就是3的位置。将7插入到3后面
        printf("对指定的节点后插入数据\n");
        insertAfter(tail->next, 7);
        printList(tail);
        return 0;
    }
    
    /*1.头插法*/
    void push(LinkedNode **head_ref, int new_data) {
        //1.声明一个LinkedNode类型的指针,并且给它申请内存空间,使它变成一个节点
        LinkedNode *new_node = (LinkedNode *) malloc(sizeof(LinkedNode));
        //2.将new_data值赋值给新申请的节点
        new_node->data = new_data;
        //3.使新申请的节点的next指向原头指针head_ref指向的节点
        new_node->next = (*head_ref);
        //4.将头指针前移,使头指针head_ref指向新申请的节点
        (*head_ref) = new_node;
    }
    
    /*2.尾插法*/
    void append(LinkedNode **head_ref, int new_data) {
        //1.声明一个LinkedNode类型的指针,并且给它申请内存空间,使它变成一个节点
        LinkedNode *new_node = (LinkedNode *) malloc(sizeof(LinkedNode));
        //2.将new_data值赋值给新申请的节点
        new_node->data = new_data;
        //3.因为是尾插法,所以new_node的next指针势必为NULL
        new_node->next = NULL;
        //4.定义一个新的LinkedNode类型的指针*temp,使它初始时等于头指针*head_ref
        //然后向后移动一直到指向最后一个节点
        //注意这里一定要是*temp = *head_ref,不能少掉*
        LinkedNode *temp = *head_ref;
    
        //5.如果这个头指针*head_ref为NULL,证明这是一个空链表,空链表的话,就直接将头指针指向新节点
        if (*head_ref == NULL) {
            *head_ref = new_node;
            //返回
            return;
        }
        //6.如果这个头指针*head_ref不为为NULL,非空链表,就要通过临时指针temp找到最后一个节点
        while (temp->next != NULL) {
            temp = temp->next;
        }
    
        //7.将新节点链接在指针后面
        temp->next = new_node;
        return;
    }
    
    // This function prints contents of linked list starting from head
    void printList(LinkedNode *node) {
        while (node != NULL) {
            printf(" %d ", node->data);
            node = node->next;
        }
    }
    
    void insertAfter(LinkedNode *prev_node, int new_data) {
        //1.首先要判空,这个节点不能够为空
        if (NULL == prev_node) {
            printf("the given previous node cannot be NULL");
            return;
        }
    
        //2.创建一个指针,并且给这个指针申请内存空间,使之成为一个节点
        LinkedNode *new_node = (LinkedNode *) malloc(sizeof(LinkedNode));
        //3.给新节点赋值
        new_node->data = new_data;
    
        //4.把prev_node->next的节点赋值给new_node->next
        new_node->next = prev_node->next;
    
        //把新申请的节点
        prev_node->next = new_node;
    }
    

    输出

    0x7ffeead397b0
    头插法
     7  6  5 尾插法
     4  3  2 对指定的节点后插入数据
     4  3  7  2 
    
    展开全文
  • LinkList链表操作

    2009-07-28 15:57:00
    以下的C++类LinkList实现了线性链表的一般操作。可以直接在其他的程序中直接建立它的对象,其中线性表中的数据在此为整型,具体应用的时候可以适当的修改,并可以在此基础上继续封装特定的功能。头文件:LinkList....

    以下的C++类LinkList实现了线性链表的一般操作。可以直接在其他的程序中直接建立它的对象,其中线性表中的数据在此为整型,具体应用的时候可以适当的修改,并可以在此基础上继续封装特定的功能。

    头文件:LinkList.h

    typedef struct LNode {
    int data;
    struct LNode *next;
    }LNode, *pLinkList;

    class LinkList {
    private:
    pLinkList m_pList;
    int m_listLength;
    public:
    LinkList();
    ~LinkList();
    bool InitList ();
    bool DestroyList ();
    bool ClearList();
    bool IsEmpty ();
    int GetLength ();
    bool GetNode(int position, LNode** node);
    int LocateElem(int elem);
    bool SetNodeData(int position, int newData);
    bool GetNodeData(int position, int &data);
    bool InsertNode(int beforeWhich, int data);
    bool DeleteNode(int position);
    };

    Cpp文件:LinkList.cpp

    #include <iostream.h>
    #include "LinkList.h"

    LinkList::LinkList() {
    m_pList = NULL;
    m_listLength = 0;

    InitList();
    }

    LinkList::~LinkList() {
    if (!DestroyList()) {
      DestroyList();
    }
    }

    //初始化,分配一个头节点。
    bool LinkList::InitList() {
    if (!(m_pList = new LNode)) {
      return false;
    }
    m_pList->next = NULL;

    return true;
    }

    //销毁链表。
    bool LinkList::DestroyList() {
    if (!ClearList()) {
      return false;
    }

    delete m_pList;

    return true;
    }

    //判断链表是否为空。若为空,返回true,否则返回false。
    bool LinkList::IsEmpty() {
    if (m_pList->next == NULL) {
      return true;
    }
    return false;
    }

    //返回链表的中当前节点数。
    int LinkList::GetLength() {
    return m_listLength;
    }

    //将链表清空,释放当前所有节点。
    bool LinkList::ClearList() {
    if (m_pList == NULL) {
      return false;
    }

    LNode *pTemp = NULL;
    while (m_pList->next != NULL) {
      pTemp = m_pList->next;
      m_pList->next = pTemp->next;
      delete pTemp;
    }
    m_listLength = 0;

    return true;
    }

    //将position指定的节点内的数据设置为newData。
    //第一个有效节点的position为1。
    bool LinkList::SetNodeData(int position, int newData) {
    LNode *pTemp = NULL;

    if (!(GetNode(position, &pTemp))) {
      return false;
    }

    pTemp->data = newData;

    return true;
    }

    //得到指定位置节点的数据。
    //节点索引从1到listLength。
    bool LinkList::GetNodeData(int position, int &data) {
    LNode *pTemp = NULL;

    if (!(GetNode(position, &pTemp))) {
      return false;
    }

    data = pTemp->data;

    return true;
    }

    //在链表中插入一个节点。
    //插入的位置由beforeWhich指定,新节点插入在beforeWhich之前。
    //beforeWhich的取值在1到ListLength+1之间。
    bool LinkList::InsertNode(int beforeWhich, int data) {
    LNode *pTemp = NULL;

    if (beforeWhich < 1 || beforeWhich > (m_listLength + 1)) {
      return false;
    }

    if (!(GetNode(beforeWhich - 1, &pTemp))) {
      return false;
    }

    LNode *newNode = new LNode;
    newNode->data = data;
    newNode->next = pTemp->next;
    pTemp->next = newNode;

    m_listLength++;

    return true;
    }

    //删除一个指定的节点。
    //节点位置由position指定。
    //positon的值从1到listLength。
    //若链表为空或指定的节点不存在则返回false。
    bool LinkList::DeleteNode(int position) {
    if (position < 1 || position > m_listLength) {
      return false;
    }

    LNode *pTemp = NULL;
    if (!(GetNode(position - 1, &pTemp))) {
      return false;
    }

    LNode *pDel = NULL;
    pDel = pTemp->next;
    pTemp->next = pDel->next;
    delete pDel;

    m_listLength--;

    return true;
    }

    //得到指定位置节点的指针。
    bool LinkList::GetNode(int position, LNode **node) {
    LNode *pTemp = NULL;
    int curPos = -1;

    pTemp = m_pList;
    while (pTemp != NULL) {
      curPos++;
      if (curPos == position) 
       break;
      pTemp = pTemp->next;
    }

    if (curPos != position) {
      return false;
    }

    *node = pTemp;

    return true;
    }

    //定位与指定数据相等的数据节点。
    //如果在当前链表中已经存在该数据则返回该数据节点的索引号。
    //若不存在这样的节点则返回0。
    //节点索引从0开始到listLength。
    int LinkList::LocateElem(int elem) {
    LNode *pTemp = NULL;
    int curIndex = 1;

    pTemp = m_pList->next;
    while ((pTemp != NULL) && (pTemp->data != elem)) {
      pTemp = pTemp->next;
      curIndex++;
    }

    if (pTemp == NULL) {
      return 0;
    }

    return curIndex;
    }


    /*
    int main(){
    LinkList l;

    l.InsertNode(1, 10);
    l.InsertNode(2, 20);
    l.InsertNode(3, 30);
    l.InsertNode(4, 40);
    cout << l.GetLength() << endl;

    int dataTemp = 0;
    for (int i = 1; i <= l.GetLength(); i++) {
      l.GetNodeData(i, dataTemp);
      cout << dataTemp << endl;
    }

    if (l.SetNodeData(3, 50)) {
      cout <<"DONE/n";
    } else {
      cout << "Failed/n";
    }

    for (i = 1; i <= l.GetLength(); i++) {
      l.GetNodeData(i, dataTemp);
      cout << dataTemp << endl;
    }

    if (l.DeleteNode(4)) {
      cout <<"DONE/n";
    } else {
      cout << "Failed/n";
    }

    for (i = 1; i <= l.GetLength(); i++) {
      l.GetNodeData(i, dataTemp);
      cout << dataTemp << endl;
    }

    cout << l.LocateElem(50) << endl;
    return 0;
    }
    */

    展开全文
  • 下面是LinkList.h文件,包含链表的基本函数#include #include"malloc.h" #include"Node.h" #include #include using namespace std;template class LinkList { friend ostream& oper

    下面是LinkList.h文件,包含链表的基本函数

    #include<iostream>
    #include"malloc.h"
    #include"Node.h"
    #include <exception>
    #include <cstdlib>
    using namespace std;
    
    template < class T>
    class LinkList
    {
        friend ostream& operator<< <T>(ostream &out, LinkList<T> &list);//操作符重载,输出单链表的所有元素
    
    public:
        LinkList();                      //构造函数 
        LinkList(T value[], int n);      //创建链表(利用数组进行创建)
        ~LinkList() { delete head; }     //析构函数
        Node<T>*head;                    //头指针,指向单链表的头结点
        Node<T>*InsertNode(int i, int d);//指定位置插入节点
        int GetLength();                 //链表长度
        T DeleteNode(int i);             //删除指定位置节点,返回删除的元素
        void DeleteAllNode();            //删除整个链表
    
    
    };
    
    template < class T>
    ostream& operator<<(ostream &out, LinkList<T> &list)
    {
        if (list.head == NULL)
        {
            cout << "链表为空!" << endl;
            return out;
        }
        for (Node<T> *p = list.head->Next; p!= NULL; p = p->Next)
        {
            cout << p->data << "  ";
        }
        return out;
    }
    
    template<class T>
    LinkList<T>::LinkList()//创建空链表
    {
        this->head = new Node<T>();
    }
    
    template < class T>
    LinkList<T>::LinkList(T value[], int n)
    {
        if (n <= 0)
        {
            cout << "链表个数不合理,请重新设定!" << endl;
        }
        this->head = new Node<T>();
        Node<T> *Temp = this->head;
        for (int i = 0; i < n; i++)
        {
            Temp->Next = new Node<T>();
            Temp->Next->data = value[i];
            Temp = Temp->Next;
        }
        Temp->Next = NULL;
    }
    
    template < class T>
    Node<T>* LinkList<T>::InsertNode(int i, int d)
    {
        Node<T>*p = this->head;
        int j = 0;
        while (p && j < i - 1)
        {
            p = p->Next;
            j++;
        }
        if (!p || j>i - 1)
        {
            throw out_of_range("指针为空或者i的取值不合法!");
        }
        Node<T>*s = new Node<T>();
        s->data = d;
        s->Next = p->Next;
        p->Next = s;
    
        return 0;
    }
    
    template <class T>
    int LinkList<T>::GetLength()
    {
        Node<T>*p = new Node<T>();
        p = this->head;
        int n = 0;
        while (p->Next != NULL)
        {
            n += 1;
            p = p->Next;
        }
        return n;
    }
    
    template <class T>
    T LinkList<T>::DeleteNode(int i)
    {
        Node<T>*p = new Node<T>();
        p = this->head;
        int j = 0; T e;
        while (p && j < i-1)
        {
            p = p->Next;
            j++;
        }
        if (!p || j>i-1)
        {
            throw out_of_range("该位置指针为空或者输入位置不合法!");
        }
    
        Node<T>*s = new Node<T>();
        e = p->data;
        s = p->Next;
        p->Next = s->Next;
        free(s);
        return e;
    }
    
    template <class T>
    void LinkList<T>::DeleteAllNode()
    {
        while (this->head != nullptr)
        {
            head = head->Next;
        }
    }

    在上面文件中,Node.h中是结点类的实现,代码如下:

    template < class T>
    class Node
    {
    public:
        T data;
        Node<T> *Next;
        Node()
        {
            this->Next = NULL;
        }
        Node(T data, Node<T>*Next = NULL)
        {
            this->data = data;
            this->Next = Next;
        }
    
    };

    下面是LinkList.cpp文件,包含主函数

    #include<iostream>
    #include"LinkList.h"
    using namespace std;
    
    int main()
    {
        int a[5] = { 1, 4, 3, 6, 7 };
        //生成链表测试
        LinkList<int> list(a, 5);
        cout <<"生成的链表为:"<< list << endl;
        cout << "生成链表的长度为:" << list.GetLength() << endl;;
    
        //插入某位置元素测试
        list.InsertNode(3, 10);
        cout << "在第3个位置上插入数字10之后的新链表为:" << list << endl;
    
        //删除某位置元素测试
        list.DeleteNode(5);
        cout << "删除第5个位置的结点后的新链表为:" << list << endl;
    
        //删除所有元素测试
        list.DeleteAllNode();
        cout << "将元素全部删除!" << list << endl;
        return 0;
    }

    测试结果如下所示:

    生成的链表为:1  4  3  6  7
    生成链表的长度为:5
    在第3个位置上插入数字10之后的新链表为:1  4  10  3  6  7
    删除第5个位置的结点后的新链表为:1  4  10  3  7
    将元素全部删除!链表为空!
    
    请按任意键继续. . .
    
    展开全文
  • 参考:链表的12种基本操作(C++实现) 链表的几个基本操作代码只要弄懂指针、链表的数据结构就不难实现,代码如下,不懂得话可以留言询问,有错误的话请指正 #include<iostream> using namespace std; //定义...
  • //=============================================================//链表具体函数实现部分//=============================================================#include "LinkList.h"#include #include "stdafx.h...
  • 链表删除及插入

    2021-09-12 21:30:31
    题目:设指针la和lb分别指向两个无头结点单链表中的首元结点,试设计算法,从表la中删除自第i个元素起共len个元素,并将它们插入表lb的第j个元素之后 构造结构体 typedef struct node { int data; //数据 ...
  • 问题描述 链表是C++中比较有特色...在指定位置插入链表的新结点 小伙伴们需要自取,有帮助的话可以点个赞~ 注:本文中提供的代码均为完整代码,放入C++工程后可直接运行。 代码实现: 用C++类(class)实现,共包含三个
  • 以下是“链表指定节点后插入新元素”的简单示例: 1. 用c语言实现的版本 #include #include typedef char datatype; typedef struct node{ datatype data; struct node *next; } listnode; typedef ...
  • 手工实现LinkedList_在指定位置插入节点 public class SxtLinkedList04 { private Node first; private Node last; private int size; public void add(Object obj) { Node n1 = new Node(obj); if(first==...
  • //单链表在指定位置插入元素,O(n) ElemType ListInsert_L(LinkList *L , int i , ElemType e){ LinkList p = (LinkList)malloc(sizeof(LNode)); int j = 0; while (p && j ) { p = p
  • 思路:对【m, n】区间的数进行头插法插入 代码如下: # coding=utf-8 """思路就是针对反转区间的数使用头插法,逻辑比较繁琐""" class LinkNode(object): # 定义链表节点 def __init__(self, val, ...
  • 从前面的HashMap和ConcurrentHashMap的源码分析我们可以得知,其内部的数据结构都用到了链表,所以,对链表的深入掌握非常有必要。本文将重点介绍单链表数据结构,然后通过代码实现单链表的头插法和尾插法。 单链表...
  • 链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据。 “结点的序列”表示线性表称作线性链表...
  • 链表插入删除合并

    2019-01-14 19:54:10
    typedef int elemtype; 定义elemtype为int类型 ...typedef lnode* linklist; 给结构体更名 //链表输出 因为创建的链表含有头结点,所以新设了一个变量p,使p=L-&gt;next;如果没有头结点的话...
  •  我们知道数组是我们很熟悉的一种存放数据的东西,但是它的问题我们也知道,一经创建它的大小也就固定了,固定存在着一个重要的问题“内存浪费”和“内存溢出”,也就是它不能动态的变换它的大小,而链表就很好的...
  • #include <stdio.h> #include <stdlib.h> #define MaxSize 100 #define ElementType int typedef struct node{ ElementType data;... struct node *link;...}LNode,*LinkList; //求链表长度 int LENGTH(...
  • 前插法就是在头节点和首元节点之间插入节点,后接法是在链表的最后一个节点的末尾插入节点.   这里可能有人又有疑问了.什么是头节点?什么是首元节点?那么这里来解释一下:通常为了方便操作,链表的第一个节点是不用...
  • LinkList(双向链表实现)

    2019-07-29 22:42:00
    LinkedList是用链表结构存储数据的,比较适合数据的动态插入和删除,随机访问和遍历速度比较慢,还提供了List接口i中没有定义的方法,专门用于操作表头和表尾的元素,所以可以当作堆栈、队列和双向队列来使用。...
  • /********************************************************************* * 函数名称:linklist *...* 函数功能:在链表指定位置插入结点 * 参 数:head----链表的头结点 Loc-----需要插入的结点所在的位置
  • 链表:&emsp &nbsp 链表是一种物理存储单元上非连续...nbsp下面直接通过代码进行展示:包括初始化一个可以指向任何数据类型的链表链表指定位置插入节点元素、链表中删除指定位置的节点元素、获取链表的长度
  • 头指针链表指不带头节点的链表,这样的链表插入时需要考虑空表的情况,指定位置删除插入时也需要考虑是否在第一个节点处。因为头指针链表的很多操作都需要改变头指针。 下面是关于头指针链表的一些操作的实现。...
  • #pragma once #ifndef LIST #define LIST #include<iostream> #include<string> using namespace std; //template<...class LinkList { public: LinkList(); ~LinkList(); void cr

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,999
精华内容 3,599
关键字:

linklist链表指定位置插入