정적 순서 표

#ifndef __SEQ_TABLE_S_H__
#define __SEQ_TABLE_S_H__
#define MAX 100


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


typedef int DataType;

//         
typedef struct SeqList
{
	DataType arr[MAX];
	int size ;
}SeqList,*pSeqList;

void InitSeqList(pSeqList pSeq);//   
void PrintSeqList(SeqList Seq);//  

void PushBack(pSeqList pSeq,DataType x);//  
void PopBack(pSeqList pSeq);//  
void PushFront(pSeqList pSeq, DataType x);//  
void PopFront(pSeqList pSeq);//  

void Insert(pSeqList pSeq, int pos, DataType x);//    
void Remove(pSeqList pSeq, DataType x);//    
void RemoveAll(pSeqList pSeq, DataType x);//        
int Find(SeqList Seq,DataType x);//    
void ReverseList(pSeqList pSeq);//  
void SortList(pSeqList pSeq);//  
int BinarySearch(SeqList Seq,DataType x);//    


void InitSeqList(pSeqList pSeq)
{
	assert(pSeq);
	memset(pSeq->arr, 0, sizeof(pSeq->arr));//     
	pSeq->size = 0;
}

void PrintSeqList(SeqList Seq)
{
	int i = 0;
	for (i = 0; i < Seq.size; i++)
	{
		printf("%d ", Seq.arr[i]);

	}
	printf("over
");
}

void PushBack(pSeqList pSeq, DataType x)//  
{
	assert(pSeq);
	if (pSeq->size >= MAX)
	{
		printf("     
");
		return;
	}
//	pSeq->arr[pSeq->size] = x;
//	pSeq->size++;
	pSeq->arr[pSeq->size++]=x;
}

void PopBack(pSeqList pSeq)//  
{
	assert(pSeq);
	if (pSeq->size == 0)
	{
		printf("     
");
		return;
	}
	pSeq->size--;
}

void PushFront(pSeqList pSeq, DataType x)//  
{
	assert(pSeq);
	int i = 0;
	if (pSeq->size >= MAX)
	{
		printf("     
");
		return;
	}
	for (i = pSeq->size; i > 0; i--)
	{
		pSeq->arr[i] = pSeq->arr[i - 1];
	}
	pSeq->arr[0] = x;
	pSeq->size++;
}

void PopFront(pSeqList pSeq)//  
{
	assert(pSeq);
	int i = 0;
	if (pSeq->size == 0)
	{
		printf("     
");
		return;
	}
	for (i = 0; i < pSeq->size; i++)
	{
		pSeq->arr[i] = pSeq->arr[i + 1];
	}
	pSeq->size--;
}

void Insert(pSeqList pSeq, int pos, DataType x)//    
{
	int i = 0;
	assert(pSeq);
	assert((pos < pSeq->size) && (pos >= 0));

	if (pSeq->size == MAX)
	{
		printf("     
");
		return;
	}
	for (i = pSeq->size; i>pos; i--)
	{
		pSeq->arr[i] = pSeq->arr[i - 1];
	}
	pSeq->arr[pos] = x;
	pSeq->size++;
}
int Find(SeqList Seq, DataType x)
{
	int i = 0;
	for (i = 0; i < Seq.size; i++)
	{
		if (x == Seq.arr[i])
		{
			return i;
		}
	}
	return -1;
}

void Remove(pSeqList pSeq, DataType x)//    

{
	int pos = Find(*pSeq, x);
	int i = 0;
	assert(pSeq);
	if (pos != -1)
	{
		for (i = pos; i < pSeq->size; i++)
		{
			pSeq->arr[i] = pSeq ->arr[i + 1];
		}
		pSeq->size--;
	}
}

void RemoveAll(pSeqList pSeq, DataType x)//        
{
	while (Find(*pSeq, x) != -1)
	{
		Remove(pSeq, x);
	}
}
void ReverseList(pSeqList pSeq)//  
{
	int start = 0;
	int end = pSeq->size - 1;
	assert(pSeq);
	while (start < end)
	{
		DataType tmp = pSeq->arr[start];
		pSeq->arr[start] = pSeq->arr[end];
		pSeq->arr[end] = tmp;
		start++;
		end--;
	}
}
void SortList(pSeqList pSeq)//  
{
	assert(pSeq);
	int i = 0;
	int j = 0;

	for (i = 0; i < pSeq->size-1; i++)
	{
		for (j = 0; j < pSeq->size - i - 1; j++)
		{
			if (pSeq->arr[j]>pSeq->arr[j + 1])
			{
				DataType tmp = pSeq->arr[j];
				pSeq->arr[j] = pSeq->arr[j + 1];
				pSeq->arr[j + 1] = tmp;
			}
		
		}
	}
}
int BinarySearch(SeqList Seq, DataType x)//    
{
	int left = 0;
	int right = Seq.size - 1;
	while (left <= right)
	{
		int mid = left - ((left - right) >> 1);
		if (Seq.arr[mid] > x)
			right = mid - 1;
		else if (Seq.arr[mid] == x)
			return mid;
		else
			left = mid + 1;

	}
	return -1;
}

#endif//__SEQ_TABLE_S_H__