C语言（十六）

1、单链表简单选择排序

输入：输入多个整型数创造链表L（-1表示输入结束）。

输出：输出链表L简单选择排序后的升序序列。

优化目标：无

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int data;
    struct ListNode *next;
};

 void selectsort(struct ListNode *L)//简单选择排序
{
	struct ListNode *i=L;
	struct ListNode *min,*j;
    int temp;
    for(;i->next!=NULL;i=i->next){
         min=i;
        for(j=i->next;j!=NULL;j=j->next){//找到本次最小值结点
         	
         	 if(min->data>j->data)min=j;
         }
        if(min!=i){//交换结点数据
            temp=i->date;
            i->date=min->date;
            min->date=temp;
        }
    }
}


struct ListNode* readlist()//创建链表
{
    struct ListNode *head=NULL,*tail=NULL,*p=NULL;
    int data;
    scanf("%d", &data);
    while (data!=-1)
    {
        p=(struct ListNode*)malloc(sizeof(struct ListNode));
        p->data=data;
        p->next=NULL;
        if (head==NULL)
            head=p;
        else
            tail->next=p;
        tail=p;
        scanf("%d", &data);
    }
    return head;
}

void printlist(struct ListNode *L )//打印链表
{
     struct ListNode *p=L;
     while (p) {
           printf("%d ", p->data);
           p=p->next;
     }
     printf("\n");
}

int main()
{
    int m;
    struct ListNode *L=readlist();
    printlist(L);
    selectsort(L);
    printlist(L);
    return 0;
}

2、顺序表：
输入：输入整型数创造顺序表L
输出：输出顺序表L的各种操作
优化目标：无

#include<stdio.h>
#include<malloc.h>

#define ElemType int 
#define MaxSize 100   //顺序表的最大长度

typedef struct{
	ElemType *data;  //存储空间基址
	int length;
}SqList;

//初始化顺序表，创建一个空表
SqList* InitList()
{
	//申请内存
	SqList* L=(SqList*)malloc(sizeof(SqList));
	L->data=(ElemType *)malloc(MaxSize*sizeof(ElemType));
	if(!L->data)
	{
		printf("存储空间分配失败!");
	}
	L->length = 0;
}

//创建指定大小的顺序表
void CreateSqList(SqList *L, int n)   //n为需要创建顺序表的长度
{
	int i=0;
	if(n>MaxSize||n<1)
	{
		printf("顺序表的长度非法");
	}
	else
	{
		printf("请输入%d个数据:", n);
		for(;i<n;i++){
			scanf("%d",&L->data[i]);
			L->length++;
		}
	}
}

//打印顺序表
void PrintSqList(SqList *L)
{
	int i;
	printf("打印出的顺序表为:\n");
	printf("***********************\n");
	for(i=0;i<L->length;i++)
	{
		printf("%d  ",L->data[i]);
	}
	printf("\n***********************\n");
}

//插入函数,位置i插入数据,i及之后元素后移 1=<i<=length+1 
bool InsertSqList(SqList L, int i, ElemType e)
{
	if (i<1||i>L.length+1) //判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	if (L.length>=MaxSize)//判断存储空间是否已满
	{
		printf("当前存储空间已满！！！\n");
		return false;
	}
	for (int j=L.length;j>=i;j--)//位置i及之后元素后移
	{
		L.data[j]=L.data[j-1];
	}
	L.data[i-1]=e;
	L.length++;
	return true;
}

//删除函数,删除位置i的元素,i之后的元素依次前移
bool  ListDelete(SqList L, int i)
{
	if (i<1||i>L.length)
	{
		printf("位置无效！！！\n");
		return false;
	}
	for (int j=i;j<=L.length-1;j++)//位置i之后元素依次前移覆盖
	{
		L.data[j-1]=L.data[j];
	}
	L.length--;
	return true;
}

void delete(Sqlist L,int i,int j)//删除算法的扩展(删除下标i-j的元素)  
{
    int k,delta;
    delete=j+1-i;//i和j+1之间相差的值
    for(k=j+1;k<L.length;++k)
    {
        L.data[k-delete]=L.data[k];
    }
    L.length-=delete;
}

int LocateElem(SqList L, ElemType e)
{
	for (int i=0;i<L.length;i++)//从低位置查找
	{
		if (L.data[i]==e)
			return i+1;
	}
	return 0;
}
//倒置函数,将原顺序表直接倒置
void Reverse(SqList L)
{
    int i, temp;
	for (i=0;i<L.length/2;i++) {//两头的值分别交换
		temp=L.data[i];
		L.data[i]=L.data[L.length-1-i];
		L.data[L.length-1-i]=temp;
	}
}
//将顺序表中所有小于表头的元素的整数放在前半部分，大于表头元素的整数放在后半部分-类似快排
void move(Sqlist L)
{
    int temp;
    int i=0,j=L.length-1;
    temp=L.data[i];
    while(i<j)
    {
        while(i<j&&L.data[j]>temp)  --j;
    //j从右往左扫描，当碰到第一个比temp小的元素时停止，并且每一步都要判断i是否小于j
        if(i<j)
        {
            L.data[i]=L.data[j];
            ++i;//L.data[i]被替换后记得，i要后移一位
        }
 
        while(i<j&&L.data[i]<temp)  ++i;
   //i从左往右扫描，当碰到第一个比temp大的元素时停止，并且每一步都要判断i是否小于j
        if(i<j)
        {
            L.data[j]=L.data[i];
            --j;
        }
    }
    L.data[i]=temp;
}

int main()
{
	SqList *L=InitList();;

	//测试
	CreateSqList(L, 8);
	InsertSqList(L, 1, 0);
	DeleteSqList(L, 1);
	PrintSqList(L);
	delete(L,3,5)
	PrintSqList(L);
	Reverse(L);
	PrintSqList(L);
	move(L)
	return 0;
}

总结：今天练习了顺序表基本操作和链表选择排序，明天计划练习栈和队列的题。