精华内容
下载资源
问答
  • 单链表有序插入,插入后依然有序

    千次阅读 2019-12-30 20:07:08
    } //有序单链表有序插入 升序 void insert(Node* head, int ele){ Node* p = head->next; //用于移动 Node* pr = head; //指向判断节点的前驱节点 while(p!=NULL){ //1 2 3 3 //2 if(p->data >= ele){//...
    #include <iostream>
    #include <iomanip>
    #include <string.h>
    #include <cmath>
    #include <algorithm>//算法头文件
    #include <fstream>
    #include <cstdlib>
    #include <vector>
    #include <sstream>
    using namespace std;
    
    //有头结点单链表 
    struct Node{
    	int data;	//数据域 
    	Node *next; //指针域 
    };
    
    //初始化单链表,即创建头指针
    Node* init(){
    	Node *head = new Node;
    	head->data = 0;
    	head->next = NULL;
    	return head;
    } 
    //打印链表
    void print(Node *head){
    	//因为要移动指针,所以用一个指针指向,保留原来数据不变
    	Node *p = head->next; //p指向链表
    	while(p != NULL){
    		cout<<p->data<<"  ";
    		p = p->next;
    	} 
    	cout<<endl;
    } 
    
    void insertBySort(Node* head, int ele){
    	Node* p = head;		//用于移动的节点   后继大节点 
    	Node* pr = head;	//用于保存当前插入节点的前驱小节点 
    	//先移动 
    	while((p=p->next)!=NULL  && p->data<ele){
    		pr = p; //这个循环结束后,就找到了当前节点的额前驱小节点和后继大节点 
    	}
    	Node* nl = new Node;
    	nl->data = ele;
    	nl->next = pr->next;
    	pr->next = nl;
    }
    
    //有序单链表中有序插入  升序
    void insert(Node* head, int ele){
    	Node* p = head->next; //用于移动 
    	Node* pr = head;	//指向判断节点的前驱节点 
    	while(p!=NULL){
    		//1 2 3 3
    		//2
    		if(p->data >= ele){//插入的元素小于等于链表里的 
    			//此时p已经到比插入元素大的后继节点了
    			Node* cur = new Node;
    			cur->data = ele;
    			cur->next = p;
    			pr->next = cur; 
    			return ;
    		}else{
    			p = p->next;
    			pr = pr->next;
    		}
    	}
    	//如果插入的元素比链表里的都大
    	Node* cur = new Node;
    	cur->data = ele;
    	cur->next = p;
    	pr->next = cur;
    }
    
    int main(){
    
    	Node *head = init();
    	
    	for(int i=10; i>=1; i--){
    		insertBySort(head,i);
    	}
    	
    	print(head);
    	
    	insert(head,6);
    	print(head);
    	insert(head,0);
    	print(head);
    	insert(head,100);
    	print(head);
    	
    	return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • 对加入的链表结点进行排序, 保持整体有序 public void addByOrder(Node node){ //临时变量 Node temp = head; boolean flag = false;// 标识是否可以插入结点 /* 对插入的结点进行排序的几种情况: 1. 新插入的结点...

    代码如下:

    package DataStrcture.ArrayDemo.singlelistdemo;
    
    public class OrderSingleListDemo {
        public static class Node{
            Node next;
            String name;
            int age;
            //个构造器用于初始化
            public Node(String name, int age){
                        this.name = name;
                        this.age=age;
            }
            ///tostring()方法输出
            public String toString(){
                return "name: "+name+", age: "+age;
            }
    
        }
            //头结点
            Node head = new Node("",0);
    
             对加入的链表结点进行排序, 保持整体有序
            public void addByOrder(Node node){
                //临时变量
                Node temp = head;
                boolean flag = false;// 标识是否可以插入结点
                /*
                    对插入的结点进行排序的几种情况:
                        1. 新插入的结点的大小正好处于最后;(temp.next==null)
                        2. 找到了第一个比新节点的大的结点(temp.next.id > node.id),立马跳出循环查到他的前面;
                        3. 找到的结点的值跟新结点的一样,如果不允许重复,此方法在这里就应该跳出并结束了
    
                 */
                while(true){
                    //情况一
                    if(temp.next == null){
                        flag = true;
                        break;
                    }
                    //情况2
                    if(temp.next.age > node.age){
                        flag = true;
                        break;
                    }
                    ///情况三
                    if(temp.next.age == node.age)
                        break;
                    //三种情况都没有(即都小于这个新节点的值),那就继续遍历呗
                    temp = temp.next;
                }
    
                if(flag){
                    node.next = temp.next;
                    temp.next = node;
                }else{
                    System.out.println("已经有重复结点存在了, 无法加入结点: "+node);
                }
            }
    
            ///对列表进行打印输出
        public void list(){
                ///临时变量
            Node temp = head;
    
            while(true){
                if(temp.next == null)
                    break;
                System.out.println(temp.next);
                temp = temp.next;
            }
        }
    
        public static void main(String[] args) {
                ///新建结点
            Node node_1 = new Node("小猪",14);
            Node node_2 = new Node("小狗",10);
            Node node_3 = new Node("小猫",8);
            Node node_4 = new Node("小兔纸",8);
            Node node_5 = new Node("小牛",16);
            Node node_6 = new Node("小沙比",28);
            Node node_7 = new Node("小羊",2);
    
            //新建链表
            OrderSingleListDemo sl = new OrderSingleListDemo();
    
            //加入链表
            sl.addByOrder(node_1);
            sl.addByOrder(node_2);
            sl.addByOrder(node_3);
            sl.addByOrder(node_4);
            sl.addByOrder(node_5);
            sl.addByOrder(node_6);
            sl.addByOrder(node_7);
    
            ///打印输出
            sl.list();
        }
    }
    
    

    输出结果:

    在这里插入图片描述

    展开全文
  • 单链表有序插入

    2017-06-16 12:38:27
    单链表有序插入,同上一个方法
    代码如下:
    
    #include "stdafx.h"
    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<time.h>
    #define N 10
    #include<string.h>
     
    struct list
    {
    	int data;
    	struct list *next;
    }*head=NULL,*end=NULL;
    
    list* insert(int data)
    {	
    	list*h1=(list*)malloc(sizeof(struct list));
    	if(head==NULL)
    	{h1->data=data;
    	h1->next=NULL;
    	end=h1;
    	head=h1;
    	return end;}
    	list*h2=head;
    	if(h2->data >= data){h1->data=data;h1->next=h2;head=h1;return end;}
    	h2=end;
    	if(h2->data <= data){h1->data=data;h2->next=h1;end=h1;h1->next=NULL;return end;}
    	h2=head;
    	while(h2->next->next!=NULL){if(data>=h2->data && data<=h2->next->data)break;h2=h2->next;}
    	h1->next=h2->next;
    	h2->next=h1;
    	h1->data=data;
    
    	return end;
    }
    void display()
    {list*h1=head;
    while(h1->next!=NULL){printf("%d\t",h1->data);h1=h1->next;}printf("%d\t",h1->data);
    }
    
    
    int main(int argc, char* argv[])
    {
    	int j;
    	srand(time(NULL)); 
    
    	for(int i = 0; i < N; i ++)        
    	{
    		j=rand()/100;
    		printf("%d\t", j);
    		insert(j);
    	}
    	putchar('\n');
    		display();
    
    	return 0;
    }
    

    展开全文
  • 单链表练习题-向有序单链表插入元素并保持有序(C语言实现) 文章目录单链表练习题-向有序单链表插入元素并保持有序(C语言实现)一、题目二、思路三、动手实现四、全部代码五、测试 一、题目 ​ 如图,原本链表就...

    单链表练习题-向有序单链表中插入元素并保持有序(C语言实现)

    一、题目

    ​ 如图,原本链表就有序:
    在这里插入图片描述
    假设现在要插入元素15,我们希望它插入在10和16之间。
    假设现在要插入元素5,我们希望它插入在7的前面。
    假设现在要插入元素22,我们希望它插入在20后面。

    二、思路

    ​ 由于原来的链表已经有序,那么我们只需要一个指针就可以了。用指针p遍历链表,比较p当前所指元素和p后继的元素,如果要插入的元素大于等于p所指元素,而且小于等于p的后继元素,这时就可以在p之后插入该元素,否则继续遍历下去,直到链表末尾。

    三、动手实现

    bool Insert_Order_List(LinkList *L,ElemType e)//有序插入
    {
    	LinkList *p = L;
    	
    	while(p->next!=NULL)
    	{
    		if((e>=p->data)&&(e<=p->next->data))
    		{
    			//申请一个新的结点
    			LinkList *s = (LinkList *)malloc(sizeof(LinkList));
    			s->data = e;//赋值 
    			
    			//修改指针  将结点s插入到结点p之后 
    			s->next = p->next;//s指针指向
    			p->next = s;
    			break;//插入之后跳出while循环	
    		}
    		else
    			p = p->next;
    	}
    	return true;
    } 
    

    四、全部代码

    #include<stdio.h>
    #include<stdlib.h>
    #include<stdbool.h> //根据C99标准,C语言使用bool类型需要添加这个头文件
    
    typedef int ElemType;
    
    typedef struct LinkNode
    {
    	ElemType data;
    	struct LinkNode *next;
    }LinkList;
    
    //------------ 函数声明 ----------//
    void MainMenu();
    bool InitLinkList(LinkList *L);//初始化 
    bool InsertLinkList(LinkList *L,ElemType e);//插入
    void PrintAll(LinkList *L);//输出所有元素 
    bool Insert_Order_List(LinkList *L,ElemType e);//有序插入 
    //------------ 函数声明 ----------//
    
    int main()
    {
    	LinkList L;
    	
    	int ch; 
    	ElemType element;
    	
    	if(InitLinkList(&L))
    		printf("初始化成功!\n");
    	else
    		printf("初始化失败!\n");
    	
    	while(1)
    	{
    		MainMenu(); 
    		printf("请输入您要执行的操作:");
    		scanf("%d",&ch);
    		
    		switch(ch)
    		{
    			case 0:		printf("感谢使用,已退出!");	exit(0);	break;
    			case 1:		printf("请输入您要插入的元素:\n");
    						scanf("%d",&element); 
    						if(InsertLinkList(&L,element))
    							printf("插入成功!\n");
    						else
    							printf("插入失败!\n");
    						break;
    			case 2:		PrintAll(&L);
    						break;		
    						
    			case 3:		printf("请输入您要插入的元素:\n");
    						scanf("%d",&element); 
    						if(Insert_Order_List(&L,element))
    							printf("有序插入成功!\n");
    						else
    							printf("有序插入失败!\n");
    						break;
    			default:	printf("您输入的操作指令有误!请重新输入!");
    		}
    	}
    	
    	return 0;
    }
    
    //主菜单,显示 
    void MainMenu()
    {
    	printf("\n\n\n");
    	printf("\t      **** 向有序单链表中插入元素并保持有序 ****\n\n"); 
    	printf("\t      -------	0.退出 \n\n");
    	printf("\t      -------	1.插入元素\n\n");
    	printf("\t      -------	2.输出所有元素\n\n");
    	printf("\t      -------	3.插入单链表并保持有序\n\n");
    	printf("\t      *************************************\n");
    }
    
    
    //初始化单链表(带头结点) 
    bool InitLinkList(LinkList *L)
    {
    	//先申请一个头结点
    	LinkList *head = (LinkList *)malloc(sizeof(LinkList));
    
    	L->next = head;
    	head->next = NULL;//头结点之后一开始还没元素
    	return true;
    } 
    
    //插入
    bool InsertLinkList(LinkList *L,ElemType e)
    {
    	//头插法
    	LinkList *p = L;//
    	
    	//申请一个新的结点
    	LinkList *s = (LinkList *)malloc(sizeof(LinkList));
    	
    	s->data = e;//赋值 
    	
    	//修改指针  将结点s插入到结点p之后 
    	s->next = p->next;//s指针指向
    	p->next = s;
    
    	return true;
    } 
    
    //打印所有元素 
    void PrintAll(LinkList *L)
    {
    	LinkList *q;
    	q = L->next;
    
    	//打印出所有元素 
    	while(q->next!=NULL)
    	{
    		printf("%d ",q->data);
    		q = q->next;
    	}
    }
    
    bool Insert_Order_List(LinkList *L,ElemType e)//有序插入
    {
    	LinkList *p = L;
    	
    	while(p->next!=NULL)
    	{
    		if((e>=p->data)&&(e<=p->next->data))
    		{
    			//申请一个新的结点
    			LinkList *s = (LinkList *)malloc(sizeof(LinkList));
    			
    			s->data = e;//赋值 
    			
    			//修改指针  将结点s插入到结点p之后 
    			s->next = p->next;//s指针指向
    			p->next = s;
    			break;//插入之后跳出while循环	
    		}
    		else
    			p = p->next;
    	}
    	return true;
    } 
    

    五、测试

    1.先插入一些元素并输出
    在这里插入图片描述
    2.插入5,并查看结果:
    在这里插入图片描述
    在这里插入图片描述
    3.插入20,并查看结果:
    在这里插入图片描述
    在这里插入图片描述
    4.插入15,并查看结果:
    在这里插入图片描述

    在这里插入图片描述
    可以看到无论是边界还是中间都已成功有序插入。

    展开全文
  • 这和插入排序的思想有点类似,我们直接在每次插入的时候都按照主关键字(即价格price)的顺序插,这样每次插入后都是有序的。 算法实现: typedef struct node { double price;//价格 int count;//数量 struct node...
  • **有序单链表插入,函数参数为指向链表第一个节点的指针及要插入的值 */ #include <stdio.h> #include <stdlib.h> #define FALSE 0 #define TRUE 1 typedef struct NODE { struct NODE* link; ...
  • 这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何...在有序单链表L中插入数值x,仍然有序。(输入单链表数值时需要从小到大输入) 欢迎使用Markdown编辑器 #include
  • 单链表有序插入节点

    千次阅读 2018-04-05 18:15:33
    单链表插入,有三种情况:1、插入在头结点之前 2、插入在中间节点 3、插入尾节点Node* insert(int num, Node* head){ Node*New, *previous, *p2;//p2用来保存前一个previo...
  • void FoundInsert(List* &L,int x)//链表的查找和插入 {  List* p;  List* p1;  List* p2;  p=L->next;  p2=L;  p1=(List*)malloc(sizeof(List));  p1->data=x;  while(p!=NULL&&p->data)  {  ...
  • 数据结构与算法-有序单链表插入

    千次阅读 2019-03-18 10:58:20
    //单链表基本操作 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int datatype; typedef struct node{ datatype data; struct node *next; }Lnode,*linklist; /********************...
  • 有序单链表插入和删除,插入一个数后仍然保持表按小到大的顺序排列
  • ***已知带头结点的动态单链表L中的结点是按整数值递增排序的,试写一算法将值为x的结点插入到表L中,使L仍然有序。 ** *****************************************************************************************...
  • 这里和顺序表那题题意是一样的,都是插入一个元素节点x后,使链表仍然有序。 那这两者有啥区别吗? 存储结构不一样。 顺序表是顺序存储结构,单链表是链表存储结构。 二者区别: 1.顺序表是先找到插入位置,然后将...
  • C语言实现的有序单链表插入(由小到大排列 "sll_node.h" struct NODE{ struct NODE *link; int value; } Node; #include #include #include "sll_node" #define FALSE 0 #defien TRUE 1 int sll_in
  • 给定这个环形单链表的头节点head和一个整数num,要生成节点值为num的新节点,并插入环形链表中,保证依然有序。 思路 本题题目不难,但一定要考虑全面 生成新的节点node,节点值为num 如果链表为空,node自己...
  • 按序号插入(对两个有序单链表合并为一个有序单链表有帮助) 此处用图解的方法说明头插法,其他方法是类似的就不一一画图了(ps:实在是画图太折磨人了) 尾插法的关键在于,每次插入时都需要先遍历链表,找到链表最后...
  • 单链表按照顺序插入节点

    千次阅读 2020-02-22 18:56:39
    单链表按照顺序插入节点 按照节点的no值进行排序插入链表 插入时: 定义一个temp辅助节点,插入的位置即:temp之后 如图:插入时,temp为2节点 temp.next = 节点4 因此有: 插入节点.next = temp.next ...
  • 建立单链表 单链表插入All possible cases: 所有可能的情况: Inserting at beginning 开始插入 Inserting at the ending 在末尾插入 Inserting at given position 在给定位置插入 Algorithms: 算法: 1)开始...
  • 有序的环形单链表插入新节点 题目描述 一个环形单链表从头节点 head 开始不降序,同时由最后的节点指回头节点。给定这样一个环形单链表的头节点 head 和 一个整数 num, 请生成节点值为 num 的新节点,并插入到...
  • 创建:先创建一个head头节点不存放具体的数据,作用:就是表示单链表的头。然后添加一个节点直接加入到链表最后。 遍历:通过一个临时变量,帮助遍历整个单链表。 public class SingleLinkedListDemo { public ...
  • 单链表有序插入

    2019-12-30 14:59:55
    //用于保存当前插入节点的前驱小节点 //先移动 while ( ( p = p -> next ) != NULL && p -> data < ele ) { pr = p ; //这个循环结束后,就找到了当前节点的前驱小节点和后继大节点 } Node ...
  • 单链表插入操作

    2020-03-24 19:36:03
    ①(按位序插入)带头节点 //在第i个位置插入元素e(带头结点) bool ListInsert(LinkList &L,int i,ElemType e) { if(i<1) return false; LNode *p; //指针p指向当前扫描到的节点 int j=0; //当前p指向...
  • //环内插入 在pre和cur之间插入 if(pre.value <= num && cur.value >= num) { break; } pre = cur; cur = cur.next; } pre.next = newNode; newNode.next = cur; return head.value ; }...
  • 有序单链表插入

    千次阅读 2017-03-10 11:53:26
    首先请尽量理解下面所给出的一个例子,它是我所给出的例子中的 有序单链表最终版://-----------------------【有序单链表最终版】------------------ // [3/10/2017 熊] //-------------------------------------...
  • 1、已知带头结点的动态单链表 L 中的结点是按整数值递增排序的,试写一 算法将值为 x 的结点插入到表 L 中,使 L 仍然有序。要求算法的时间复杂度为 O(n),空间复杂度为 O(1)。 2、设计一算法,逆置带头结点的动态...
  • 用Java实现单链表有序和无序添加对象 对象类(梁山好汉): class HeroNode{ public int no; //英雄的编号 public String name; //名字 public String nickname; //昵称 public HeroNode next; //指针,指向像一个...

空空如也

空空如也

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

单链表有序插入