顺序表操作与排序算法-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_33279168/article/details/79670824

head.h

#pragma once

#include<string.h>
#include<stdio.h>
#define MAX_SIZE 10 
typedef unsigned int size_t; 
typedef int DataType; 

typedef struct SeqList 
{ 
	DataType _array[MAX_SIZE]; 
	int  _size; // 顺序表中有效元素的个数 
}SeqList, *PSeqList; 

//typedef struct SeqList SeqList; 

/// 
// .h 
// 初始化顺序表 
void SeqListInit(PSeqList ps); 

// 尾插 
void SeqListPushBack(PSeqList ps, DataType data); 

// 尾删 
void SeqListPopBack(PSeqList ps); 

// 头插 
void SeqListPushFront(PSeqList ps, DataType data); 

// 头删 
void SeqListPopFront(PSeqList ps); 

// 任意位置中插入值为data的元素 
void SeqListInsert(PSeqList ps, int  pos, DataType data); 

// 删除任意位置中的元素 
void SeqListErase(PSeqList ps, int pos); 

// 在顺序表中查找值为data的元素，返回该元素在顺序表中的下标 
int SeqListFind(PSeqList ps, DataType data); 

// 删除顺序表中值为data的元素 
void SeqListRemove(PSeqList ps, DataType data); 

// 删除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList ps, DataType data); 

// 判断顺序表是否为空 
int SeqListEmpty(PSeqList ps); 

// 获取顺序表中元素的个数 
int SeqListSize(PSeqList ps); 

/ 
// 辅助操作 
// 打印顺序表中的元素 
void PrintSeqList(PSeqList ps); 

// 用冒泡排序对顺序表中的元素进行排序 
void BubbleSort(int* array, int size); 

// 用选择排序对顺序表中的元素进行排序 
void SelectSort(int* array, int size); 

// 选择排序优化---一次找出最大最小元素所在的位置 
void SelectSort_OP(int* array, int size);

head.c

#include "head.h"

void swap(int* arr1,int* arr2);  //交换函数声明
//初始化顺序表
void SeqListInit(PSeqList ps)
{
	int i=0;
	if (NULL==ps)
		return;
    memset(ps->_array,0,sizeof(DataType)*MAX_SIZE);
    ps->_size=0;
}

// 尾插 
void SeqListPushBack(PSeqList ps, DataType data)
{
	if(NULL==ps)
		return;
	if (ps->_size==MAX_SIZE)
		return;
	else 
	{
	  ps->_array[ps->_size]=data;
	  ps->_size++;
	}  
}

// 尾删 
void SeqListPopBack(PSeqList ps)
{
	if(NULL==ps)
		return;
	if (0==ps->_size)
	    return;
	else
	{	
		ps->_array[ps->_size-1]=0;

		ps->_size--;
	}
}

// 头插 
void SeqListPushFront(PSeqList ps, DataType data)
{
	int i=ps->_size-1;
	if(NULL==ps)
       return;
    if(ps->_size==MAX_SIZE)
		return;
    for (;i>=0;i--)
    {
		ps->_array[i+1]=ps->_array[i];
    }
	ps->_array[0]=data;
	ps->_size++;
}

// 头删 
void SeqListPopFront(PSeqList ps)
{
	int i=0;
	if(NULL==ps)
		return;
    for (;i<ps->_size-1;i++)
    {
		ps->_array[i]=ps->_array[i+1];
    }
	ps->_array[ps->_size-1]=0;
	ps->_size--;
}
// 任意位置中插入值为data的元素 
void SeqListInsert(PSeqList ps, int pos, DataType data)
{
	int i=0;
	if(NULL==ps)
		return;
    if(pos>=ps->_size||(ps->_size)==MAX_SIZE)
		return;
    for (i=ps->_size-1;i>=pos;i--)
    {
	   ps->_array[i+1]=ps->_array[i];
	}
	ps->_array[pos]=data;
	ps->_size++;
}

// 删除任意位置中的元素 
void SeqListErase(PSeqList ps, int pos)
{
	int i=0;
	if(NULL==ps)
       return;
	if (0==ps->_size||pos>=ps->_size)
        return;
    for (i=pos;i<ps->_size-1;i++)
    {
		ps->_array[i]=ps->_array[i+1];
    }
	ps->_array[ps->_size-1]=0;
	ps->_size--;
}

// 在顺序表中查找值为data的元素，返回该元素在顺序表中的下标 
int SeqListFind(PSeqList ps, DataType data)
{
	int i=0;
	if(NULL==ps)
		return 0;
    for (i=0;i<ps->_size;i++)
    {
        if(ps->_array[i]==data) 
			return i;
	}
	return 0;
}

// 删除顺序表中值为data的元素 
void SeqListRemove(PSeqList ps, DataType data)
{
	int i=0;
	if(NULL==ps)
		return;
    for(;i<ps->_size;i++)
	{
		if(ps->_array[i]==data)
		{	
			SeqListErase(ps,i);   
	        break;
		}
	}
}

// 删除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList ps, DataType data)
{
	int i=0;
	if(NULL==ps)
		return;
	while(i<ps->_size)
	{
		if(ps->_array[i]==data)
		{
			SeqListErase(ps,i);
			continue;
		}
		i++;
	}
}

// 判断顺序表是否为空 
int SeqListEmpty(PSeqList ps)
{
	if(NULL==ps)
		return 1;
	return 0;
}

// 获取顺序表中元素的个数 
int  SeqListSize(PSeqList ps)
{
	if(NULL==ps)
	{
		printf("元素表为空!\n");
		return 0;
	}
		return ps->_size;
}

/ 
// 辅助操作 
// 打印顺序表中的元素 
void PrintSeqList(PSeqList ps)
{
	int i=0;
	if(NULL==ps)
		return;
    for (;i<ps->_size;i++)
    {
		printf("%d ",ps->_array[i]);
    }
}

// 用冒泡排序对顺序表中的元素进行排序 
void BubbleSort(int* array, int size)
{
	int i=0;
	int j=0;
	if(0==size)
		return;	
    for(;i<size;i++)
	{
		int tmp=0;
		for (j=0;j<size-i;j++)
		{
           if(array[j]>array[j+1])
		   {
			   tmp=array[j];
			   array[j]=array[j+1];
			   array[j+1]=tmp;
		   }
		} 
	}
}

// 用选择排序对顺序表中的元素进行排序 
void SelectSort(int* array, int size)
{
	int i=0;
	int j=0;
	int maxpos=0;  
	int tmp=0;
	if(0==size)
		return;

	for(i=0;i<size;++i)  
	{  
		maxpos=size-i; 
		tmp=0;
		for(j=0;j<size-i;++j)  
		{  
			if(array[j]>array[maxpos])  
				maxpos=j;  
		}  
		if(maxpos!=size-i)  
		   swap(&array[maxpos],&array[j]);
	}  
}


// 选择排序优化---一次找出最大最小元素所在的位置 
void SelectSort_OP(int* array, int size)
{
	int i=0;
	int j=0;
	int maxpos=0;	
	int minpos=0;
	int begin=0;
	int end=size-1; 
	if(0==size)
		return;

	while (begin<end)
	{
		begin=i;
		end=size-1-i;
		minpos=i;
		maxpos=size-1-i; 
		
		for(j=i;j<size-i;++j)  
		{  
			if(array[j]>array[maxpos])  
				maxpos=j; 
			if (array[j]<array[minpos])
				minpos=j;
		}  
		if(maxpos!=end) 
		{
			swap(&array[maxpos],&array[end]);
		    if(minpos==end)
				minpos=maxpos;
		}
			if(minpos!=begin)  
			swap(&array[minpos],&array[begin]);
		i++;
	}

}

void swap(int* arr1,int* arr2)
{
	int tmp=*arr1;
	*arr1=*arr2;
	*arr2=tmp;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 
#include "head.h"
void test()
{
	SeqList s;

	SeqListInit(&s);
	SeqListPushBack(&s,9);       //尾插
	SeqListPushBack(&s,8); 
	SeqListPushBack(&s,7);
	SeqListPushBack(&s,6);
	SeqListPushBack(&s,5);
	SeqListPushBack(&s,4);
	SeqListPushBack(&s,3);
	SeqListPushBack(&s,2);
	SeqListPushBack(&s,1);
	SeqListPushBack(&s,0);
	    
	//SeqListPopBack(&s);       //初始化
    //SeqListPushFront(&s,3);   //头插
	//SeqListPopFront(&s);      //头删
    //SeqListInsert(&s,1,6);    //任意位置插入
    //SeqListErase(&s,3);         //任意位置删除
	//printf("%d\n",SeqListFind(&s,4));   //找元素，并返回下标
	//SeqListRemove(&s,4);      //删除数据为data的元素
	//SeqListRemoveAll(&s,4);      //删除所有数据为data的元素
    //BubbleSort(s._array,s._size);  //冒泡排序
	//SelectSort(s._array,s._size);    //选择排序
   	SelectSort_OP(s._array,s._size); //选择排序优化
} 

int main()
{
    test();
	return 0;
}

在实现选择排序优化函数的时候，遇到点问题：在升序中，如果最小元素处于尾位置，那么在第一次将最大元素放至end位置时，最小元素也会被放至交换前最大元素的位置，所以此时应该把minpos也改变，赋值为maxpos。

静态顺序表的实现