精华内容
下载资源
问答
  • 链表选择排序

    2014-10-12 14:53:14
    链表选择排序

    链表选择排序

    #include <iostream>
    #include <malloc.h>
    using namespace std;
    typedef struct LNode{
        int index;
        struct LNode *next;
    }LNode,*LinkList;
    
    LinkList create(LinkList& L)
    {
        L = (LinkList)malloc(sizeof(LNode));
        LNode *s,*r=L;
        int x;
        cin>>x;
        while(x!=111){
            s = (LNode*)malloc(sizeof(LNode));
            s->index = x;
            r->next = s;
            r = s;
            cin>>x;
        }
        r->next = NULL;
        return L;
    }
    int lenOfList(const LinkList& L){
        LNode *p=L->next;
        int len=0;
        while(p){
            len++;
            p = p->next;
        }
        return len;
    }
    LNode* GetItem(const LinkList& L,int i){
        LNode* p=L->next;
        int j=1;
        if(i==0)
            return L;
        else if(i<1)
            return NULL;
        while(p&&j<i){
            p = p->next;
            j++;
        }
        return p;
    }
    void sortList(LinkList& L,int len){
        int i,j,min,temp;
        LNode *p=NULL,*q=NULL;
        for(i=1;i<=len;i++){
            min = i;
            for(j=i+1;j<=len;j++)
                if(GetItem(L,j)->index < GetItem(L,min)->index)
                    min = j;
            if(min!=i){
                p = GetItem(L,i);
                q = GetItem(L,min);
                temp = p->index;
                p->index = q->index;
                q->index = temp;
            }
        }
    }
    
    void display(const LinkList& L){
        LNode* p=L->next;
        while(p){
            cout<<p->index<<" ";
            p = p->next;
        }
        cout<<endl;
    }
    int main()
    {
        LinkList L;
        L = create(L);
        display(L);
        int len = lenOfList(L);
        //cout<<len<<endl;
        sortList(L,len);
        display(L);
        //cout<<L->index<<endl;
        return 0;
    }
    


    展开全文
  • 链表选择排序算法功能实现演示

    万次阅读 2020-05-02 11:58:28
    //选择排序 traverse_list(pHead); //遍历输出 while(true){} return 0; } //创建单链表 pNode create_list() { int len; //用来存放有效节点数 int i; int val; //存放用户临时输入的节点数据 //我们首先要先生成...

    算法:
    狭义的算法是与数据的存数方式密切相关
    广义的算法是与数据的存储方式无关
    泛型:
    利用某种技术达到的效果就是:不同的存数方式,执行的操作是一样的 

    #include <stdio.h>
    #include <malloc.h>
    #include <string.h>
    #include <stdlib.h>
    
    
    typedef struct Node {
    	int data;  //数据域
    	struct Node * pNext;   //指针域
    
    }Node, *pNode;
    
    //函数声明
    pNode create_list();
    void traverse_list(pNode  pHead);
    
    bool is_empty(pNode pHead);          //判断链表是否为空
    int length_list(pNode pHead);        //链表的长度
    bool insert_list(pNode, int, int);   //插入  第一个参数表示插入的链表  第二个参数表示插入的位置  第三个参数表示插入的元素
    bool delete_list(pNode, int, int *); //第一个参数表示要删除的位置,第二个参数表示要删除的位置 第三参数表示删除的元素的地址放入指针
    void sort_list(pNode pHead);
    
    int main(void) {
    
    	pNode  pHead = NULL;   //等价于 struct Node *pHead=NULL
    	pHead = create_list();    //create_list()创建一个非循环单链表,并将该链表的头结点的地址赋给pHead
    	traverse_list(pHead);
    
    	int len = length_list(pHead);
    	printf("链表的长度%d\n", len);
    
        sort_list(pHead);      //选择排序
    	traverse_list(pHead);  //遍历输出
    
    	 while(true){}
    
    	return 0;
    }
    
    //创建单链表
    pNode create_list() {
    
    	int len;   //用来存放有效节点数
    	int i;
    	int val; //存放用户临时输入的节点数据
    
    	//我们首先要先生成一个头结点  不存放有效数据
    	pNode pHead = (pNode)malloc(sizeof(Node));
    	if (NULL == pHead) {
    		printf("内存分配失败");
    		//程序退出
    		exit(-1);
    	}
    	
        
    	pNode pTail = pHead;    //pTail也指向了头结点
    	pTail->pNext = NULL;
    
    	printf("请输入你要输入节点的个数 len =");
    	scanf_s("%d", &len);
    
    	//假设输入的长度5,我们需要循环
    	for ( i = 0; i < len; i++){
    		printf("请输入第%d个节点的值:", i + 1);
    		scanf_s("%d", &val);
    
    		pNode pNew=(pNode)malloc(sizeof(Node));
    		if (NULL == pNew) {
    			printf("内存分配失败");
    			//程序退出
    			exit(-1);
    		}
    
    
    		pNew->data = val;
    		//pHead->pNext = pNew;
    		//pNew->pNext = NULL;
    		pTail->pNext = pNew;  //将这个新节点挂到尾节点
    		pNew->pNext = NULL;
    		pTail = pNew;
    
    	}
    
    	return pHead;
    }
    
    //遍历
    void traverse_list(pNode  pHead) {
    
    	pNode p = pHead->pNext;
    	while (p!=NULL){
    		printf("%d ",p->data);
    		p = p->pNext;
    	}
    	//换行
    	printf("\n");
    
    	return;
    }
    
    //判断链表是否为空
    bool is_empty(pNode pHead) {
    
    	if (NULL == pHead->pNext) {
    		return true;
    	}else {
    		return false;
    	}
    }
    
    //求一个链表的长度
    int length_list(pNode pHead) {
    	pNode p=pHead->pNext;   //第一个节点
    	int len = 0;
    	while (NULL != p) {   //只要指针指向的下一个元素不是空,指针就继续向后移动
    		++len;
    		p=p->pNext;
    	}
    	return len;
    }
    
    
    //排序算法
    void sort_arr(pNode pHead) {
    
    	int i, j, tmp;
    	int arr[6] = { 5,8,45,2,9,3 };
    	int len=length_list(pHead);  //获取链表长度
    	pNode p, q;
    	for (i = 0; i < len-1; i++){
    
    		for (j = i+1; j < len; j++){
    			
    		}
    
    	}
    
    }
    
    
    
    //选择排序  从小到大排
    void sort_list(pNode pHead){
    	int i,j,t;
    	int len = length_list(pHead);  //获取链表长度
    	pNode p,q;
    	for (i = 0, p = pHead->pNext; i < len - 1; ++i, p = p->pNext){
    		for (j = i + 1, q = p -> pNext; j < len; ++j, q = q->pNext) {
    			if (p->data > q->data) {        //类似于 数组中的: a[i] > a[j]
    				t = p->data;                //类似于数组中的: t = a[i];
    				p->data = q->data;          //类似于数组中的: a[i] = a[j];
    				q->data = t;                // 类似于数组中的: a[j] = t;
    			}
    		}
    	}
    }

    展开全文
  • 链表简单选择排序

    思路

    选择排序算法通过选择和交换来实现排序,其排序流程如下:
    (1)首先从原始数组中选择最小的1个数据,将其和位于第1个位置的数据交换。
    (2)接着从剩下的n-1个数据中选择次小的1个元素,将其和第2个位置的数据交换
    (3)然后,这样不断重复,直到最后两个数据完成交换。最后,便完成了对原始数组的从小到大的排序

    关于链表的实现有两点疑问:
    1,带头结点的单链表如何交换两个元素
    A,B两个元素要设4个指针分别指向A、B的前后节点。交换时,分AB相邻和不相邻两种情况:
    A,相邻只需要更改3个节点指向
    AB
    A的前置指向B,B指向A,A指向B的后置

    B,不相邻要更改4个节点指向
    A前置 A A后置 。。。。B前置 B B后置
    A的前置指向B,B指向A的后置
    B的前置指向A,A指向B的后置

    2,简单选择排序中,链表如何区分两个元素
    在数组的排序中,值是用下标来标识不同的元素,即使值相同也可区分。
    在链表的排序中,在之前的遍历中已经找到的是<min的元素,找到的元素一定和min的值不相同,故可以用p->data != min->data作为条件。或者结构体中加一个id来区分不同的元素。

    代码

    #include<stdio.h>
    #include "malloc.h"
    #include<stdlib.h>
    
    //定义链表结构体
    typedef struct Listnode
    {
    	int data;
    	struct Listnode* next;
    }Listnode;
    
    //交换链表中两个数据
    void swap(Listnode* p, Listnode* min, Listnode* pre, Listnode* lmin, Listnode* bmin)
    {
    	if (p->next == min)//min就在p后一位,交换相邻的两个节点
    	{
    		pre->next = min;
    		p->next = lmin;
    		min->next = p;
    	}
    	else//交换不相邻的两个节点
    	{
    		pre->next = min;
    		min->next = p->next;
    		p->next = lmin;
    		bmin->next = p;
    	}
    };
    
    void select_sort(Listnode* head)//简单选择排序(升序)
    {
    	Listnode* pre = head;
    	Listnode* p = pre->next;
    	Listnode* bmin = pre, * min, * lmin;//bmin是min前一个节点,lmin是min后一个节点
    	Listnode* bq, * q; //bq记录q的前一个节点
    
    	while (p->next)//从第一个元素开始遍历到n-1个元素
    	{
    		min = p;//从第一个元素开始遍历
    		lmin = min->next;//min的后一个节点
    		bq = p;//p的前一个节点
    		q = p->next;//p从第二个元素开始遍历
    		while (q)//循环在min后面到第n个元素,找到最小值节点
    		{
    			if (q->data < min->data)
    			{	//记录min及其前后两个节点
    				bmin = bq;
    				min = q;
    				lmin = min->next;
    			}
    			bq = q;
    			q = q->next;//遍历
    		}
    		if (p->data != min->data)//在min后找到更小的值就交换
    		{
    			swap(p, min, pre, lmin, bmin);
    		}
    		pre = pre->next;
    		p = pre->next;
    	}
    }
    
    //输出链表节点
    void print(Listnode* L)
    {
    	Listnode* p = L;
    	for (int i = 0;  i< L->data; ++i)//L为头结点不能动 否则每次遍历就会改变条件
    	{
    		printf("%d ", p->next->data);
    		p = p->next;
    	}
    }
    
    void test()
    {
    	//建立链表
    	Listnode* L = (Listnode *) malloc(sizeof(Listnode));
    	if (L == NULL) {
    		printf("内存分配不成功!\n");
    	}
    	else
    	{
    		L->data = 10;
    		Listnode* p = L;
    		for (int i = 0; i < L->data; ++i)
    		{
    			p->next = (Listnode*)malloc(sizeof(Listnode));
    			if (p->next) {
    				p = p->next;
    				p->data = rand() % 100;//取0-99的随机数  0-99,都为原值,100-199为0-99,以此类推
    			}
    		}
    		p->next = NULL;
    		printf("原始序列为:\n");
    		print(L);
    		select_sort(L);
    		printf("\n排序后为:\n");
    		print(L);
    	}
    }
    
    int main()
    {
    	test();
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • Java-链表选择排序

    2020-10-01 22:40:40
    给定一个无序单链表,实现单链表的选择排序(按升序排序)。 示例1 输入 [1,3,2,4,5] 输出 {1,2,3,4,5} import java.util.*; /* * public class ListNode { * int val; * ListNode next = null; * } ...

    题目描述

    给定一个无序单链表,实现单链表的选择排序(按升序排序)。

    示例1

    输入

    [1,3,2,4,5]

    输出

    {1,2,3,4,5}

     

    import java.util.*;
    
    /*
     * public class ListNode {
     *   int val;
     *   ListNode next = null;
     * }
     */
    
    public class Solution {
        /**
         * 
         * @param head ListNode类 the head node
         * @return ListNode类
         * 链表排序 只需要改变链表节点中的val进行替换即可 不用原有链表节点移动
         */
        public ListNode sortInList (ListNode head) {
            
            if(head == null){
                return head;
            }
            
            ListNode curNode = head;
            //记录当前链表节点的最小值
            int temp;
            
            while(curNode!=null){
                //当前节点的下一个节点,因为要从当前节点的后一节点开始 循环遍历出小于temp的 然后和首位置节点的val交换
                /**
                 * 内重循环从当前节点的下一个节点循环到尾节点,
                 * 找到和外重循环的值比较最小的那个,然后与外重循环进行交换
                 */
                ListNode nextNode = curNode.next;
                
                //从nextNode节点开始循环遍历出 后续节点中最小的那个节点的val
                while(nextNode!=null){
                    //每次循环以curNode的val作为链表最小值进行比较
                    if(curNode.val > nextNode.val){
                        temp = curNode.val;
                        curNode.val = nextNode.val;
                        nextNode.val = temp;
                    }
                    
                    nextNode = nextNode.next;
                }
                
                curNode = curNode.next;
            }
            
            return head;
        }
    }

     

    展开全文
  • 链表选择排序

    千次阅读 2014-09-20 11:14:35
    选择排序是一个比较简单的排序方法,但是当用到链表中的时候就会发现很多以前自己
  • void select_sort(struct node* head)//选择排序(升序) { struct node* pre = head; struct node* p = pre->next; struct node* bmin = pre, * min, * lmin;//bmin是min前一个节点,lmin是min后一个节点 ...
  • LC148 排序链表 老题新做 归并排序法 之前快速排序也是拿这个题开的头 结果时间复杂度直接给我爆炸了(为啥要快排链表啊!!)
  • 链表选择排序 *"); puts("*******************"); } typedef struct LNode { int num; //数据域 struct LNode *next; //指针域 }LNode,*LinkList; void BubbleSortMethod(int *num) //冒泡排序 { ...
  • #include <stdio.h> #include <string.h> #include <stdlib.h> struct student{ char name[16]; int score; struct student *next; }; struct student *head=NULL, *p, *t...struct studen...
  • head)//把链表选择排序 { b i; b j; b l; b k; b temp1; for(i=head->next,k=head;i!=NULL;i=i->next,k=k->next) for(l=i,j=i->next;j!=NULL;l=l->next,j=j->next) if(i->date&...
  • 链表升序排序

    2019-09-15 22:05:59
    //链表选择排序 升序排列 #include<stdio.h> #include<stdlib.h> #define N 8 typedef struct node { int data; struct node * next; }ElemSN; ElemSN * createlink(int a[]) ...
  • 链表选择排序/********************************* 链表的排序 *******************************************/ /* ========================== 功能:选择排序(由小到大) 返回:指向链表表头的指针 ==========...
  • 目录插入排序选择排序归并排序 插入排序 leetcode 147 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ ...
  • 链表排序之选择排序

    2017-04-02 17:53:03
    选择排序的思想在于选择出最小的节点,创建新链表,将原链表的最小节点删除,继续循环 TYPE* lain(int l, TYPE *head) { TYPE *first, *tail, *p_min, *min, *p; first = NULL; while (head != NULL) {
  • 链表选择排序

    2013-01-28 20:55:55
    对初学C++的学友来说链表排序无疑是首先要掌握必备的技能
  • 链表实现选择排序

    2020-10-22 15:03:01
    C++链表实现选择排序代码如下: #include<iostream> #include<stdio.h> using namespace std; int main() { struct node{ int data; struct node *link; };//定义节点数据类型 int nodeNum;//...
  • 链表进行相应操作 链表为双向链表 其中的操作有 快速排序 选择排序 插入 删除链表链表中获取一个数等等 程序并没有测试周全 欢迎下载 若发现问题希望在我CSDN留言 以便及时更改
  • 这是根据数据结构书上讲的线性表的排序方法改写成链表,上面有简单的测试程序。
  • c语言关于使用链表排序(选择排序、冒泡排序)

    万次阅读 多人点赞 2018-01-26 10:04:25
    链表冒泡排序 比较两个相邻的元素大小,每一趟会把较大(或较小)的数放在往后移。链表冒泡排序思想:设置两个指针,一个是当前指针,一个是尾指针,当前的指针指向头节点,将尾指针赋为空,当当前的指针不等于尾...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,201
精华内容 880
关键字:

链表选择排序